kclient: more endianity fixes

diff --git a/src/kernel/caps.c b/src/kernel/caps.c
index 22330c9370b6002b7ca9914c0029dde9d99be5d8..de30a5ab967e88ff2b3a63fd39a24ce40591c45a 100644 (file)
--- a/src/kernel/caps.c
+++ b/src/kernel/caps.c
@@ -77,7 +77,7 @@ static void __insert_cap_node(struct ceph_inode_info *ci,
 {
        struct rb_node **p = &ci->i_caps.rb_node;
        struct rb_node *parent = NULL;
-       struct ceph_cap *cap = 0;
+       struct ceph_cap *cap = NULL;
 
        while (*p) {
                parent = *p;
@@ -269,7 +269,7 @@ void ceph_remove_cap(struct ceph_cap *cap)
  * Caller holds i_lock
  *    -> we take mdsc->cap_delay_lock
  */
-void __cap_delay_requeue(struct ceph_mds_client *mdsc,
+static void __cap_delay_requeue(struct ceph_mds_client *mdsc,
                              struct ceph_inode_info *ci)
 {
        ci->i_hold_caps_until = round_jiffies(jiffies + HZ * 5);
@@ -358,10 +358,10 @@ static void send_cap_msg(struct ceph_mds_client *mdsc, __u64 ino, int op,
  * called with i_lock, then drops it.
  * caller should hold snap_rwsem, s_mutex.
  */
-void __send_cap(struct ceph_mds_client *mdsc,
+static void __send_cap(struct ceph_mds_client *mdsc,
                struct ceph_mds_session *session,
                struct ceph_cap *cap,
-               int used, int wanted)
+               int used, int wanted) __releases(cap->ci->vfs_inode->i_lock)
 {
        struct ceph_inode_info *ci = cap->ci;
        struct inode *inode = &ci->vfs_inode;

diff --git a/src/kernel/decode.h b/src/kernel/decode.h
index afec24b082745162d87315b7ea8a2fe070414bbd..ef21b69cce38e53fd371b8aa971190e089f7ce1c 100644 (file)
--- a/src/kernel/decode.h
+++ b/src/kernel/decode.h
@@ -37,6 +37,22 @@
                (*p)++;                                 \
        } while (0)
 
+#define ceph_decode_64_le(p, v)                                \
+       do {                                            \
+               v = *(__le64*)*(p);                     \
+               *(p) += sizeof(__u64);                  \
+       } while (0)
+#define ceph_decode_32_le(p, v)                                \
+       do {                                            \
+               v = *(__le32*)*(p);                     \
+               *(p) += sizeof(__u32);                  \
+       } while (0)
+#define ceph_decode_16_le(p, v)                                \
+       do {                                            \
+               v = *(__le16*)*(p);                     \
+               *(p) += sizeof(__u16);                  \
+       } while (0)
+
 #define ceph_decode_copy(p, pv, n)                     \
        do {                                            \
                memcpy(pv, *(p), n);                    \
@@ -86,17 +102,17 @@
 
 #define ceph_encode_64(p, v)                     \
        do {                                      \
-               *(__u64*)*(p) = cpu_to_le64((v)); \
+               *(__le64*)*(p) = cpu_to_le64((v)); \
                *(p) += sizeof(__u64);            \
        } while (0)
 #define ceph_encode_32(p, v)                     \
        do {                                      \
-               *(__u32*)*(p) = cpu_to_le32((v)); \
+               *(__le32*)*(p) = cpu_to_le32((v)); \
                *(p) += sizeof(__u32);            \
        } while (0)
 #define ceph_encode_16(p, v)                     \
        do {                                      \
-               *(__u16*)*(p) = cpu_to_le16((v)); \
+               *(__le16*)*(p) = cpu_to_le16((v)); \
                *(p) += sizeof(__u16);            \
        } while (0)
 #define ceph_encode_8(p, v)                      \

diff --git a/src/kernel/mds_client.c b/src/kernel/mds_client.c
index 333577486b49088b1fa1dd07a221c5350ab4e6be..44c10910b86e4fa2ddf4cbc6cec8ef16ef22e0a4 100644 (file)
--- a/src/kernel/mds_client.c
+++ b/src/kernel/mds_client.c
@@ -160,7 +160,7 @@ static int parse_reply_info_dir(void **p, void *end,
        info->dir_dir = *p;
        if (*p + sizeof(*info->dir_dir) > end)
                goto bad;
-       *p += sizeof(*info->dir_dir) + sizeof(__u32)*info->dir_dir->ndist;
+       *p += sizeof(*info->dir_dir) + sizeof(__u32)*le32_to_cpu(info->dir_dir->ndist);
        if (*p > end)
                goto bad;
 
@@ -442,7 +442,8 @@ static void __register_request(struct ceph_mds_client *mdsc,
                               struct ceph_mds_request *req)
 {
        struct ceph_mds_request_head *head = req->r_request->front.iov_base;
-       req->r_tid = head->tid = ++mdsc->last_tid;
+       req->r_tid = ++mdsc->last_tid;
+       head->tid = cpu_to_le64(req->r_tid);
        dout(30, "__register_request %p tid %lld\n", req, req->r_tid);
        get_request(req);
        radix_tree_insert(&mdsc->request_tree, req->r_tid, (void *)req);
@@ -1040,7 +1041,7 @@ ceph_mdsc_create_request(struct ceph_mds_client *mdsc, int op,
 
        /* encode head */
        /* tid, oldest_client_tid set by do_request */
-       head->mdsmap_epoch = cpu_to_le64(mdsc->mdsmap->m_epoch);
+       head->mdsmap_epoch = cpu_to_le32(mdsc->mdsmap->m_epoch);
        head->num_fwd = 0;
        /* head->retry_attempt = 0; set by do_request */
        head->mds_wants_replica_in_dirino = 0;
@@ -1091,7 +1092,7 @@ int ceph_mdsc_do_request(struct ceph_mds_client *mdsc,
        int mds = -1;
 
        dout(30, "do_request on %p\n", req);
-       BUG_ON(le32_to_cpu(req->r_request->hdr.type) !=
+       BUG_ON(le16_to_cpu(req->r_request->hdr.type) !=
               CEPH_MSG_CLIENT_REQUEST);
 
        mutex_lock(&mdsc->mutex);
@@ -1390,7 +1391,7 @@ static void send_mds_reconnect(struct ceph_mds_client *mdsc, int mds)
        int num_caps, num_realms = 0;
        int got;
        u64 next_snap_ino = 0;
-       u32 *pnum_realms;
+       __le32 *pnum_realms;
 
        dout(1, "reconnect to recovering mds%d\n", mds);
 
@@ -1667,7 +1668,7 @@ void ceph_mdsc_handle_lease(struct ceph_mds_client *mdsc, struct ceph_msg *msg)
        mask = le16_to_cpu(h->mask);
        dname.name = (void *)h + sizeof(*h) + sizeof(u32);
        dname.len = msg->front.iov_len - sizeof(*h) - sizeof(u32);
-       if (dname.len != le32_to_cpu(*(u32 *)(h+1)))
+       if (dname.len != le32_to_cpu(*(__le32 *)(h+1)))
                goto bad;
 
        /* find session */
@@ -1795,7 +1796,7 @@ void ceph_mdsc_lease_release(struct ceph_mds_client *mdsc, struct inode *inode,
                return;
        lease = msg->front.iov_base;
        lease->action = CEPH_MDS_LEASE_RELEASE;
-       lease->mask = mask;
+       lease->mask = cpu_to_le16(mask);
        lease->ino = cpu_to_le64(ceph_vino(inode).ino);
        lease->first = lease->last = cpu_to_le64(ceph_vino(inode).snap);
        *(__le32 *)((void *)lease + sizeof(*lease)) = cpu_to_le32(dnamelen);
@@ -2014,7 +2015,7 @@ void ceph_mdsc_stop(struct ceph_mds_client *mdsc)
  */
 void ceph_mdsc_handle_map(struct ceph_mds_client *mdsc, struct ceph_msg *msg)
 {
-       ceph_epoch_t epoch;
+       __u32 epoch;
        __u32 maplen;
        void *p = msg->front.iov_base;
        void *end = p + msg->front.iov_len;
@@ -2024,8 +2025,8 @@ void ceph_mdsc_handle_map(struct ceph_mds_client *mdsc, struct ceph_msg *msg)
        struct ceph_fsid fsid;
 
        ceph_decode_need(&p, end, sizeof(fsid)+2*sizeof(__u32), bad);
-       ceph_decode_64(&p, fsid.major);
-       ceph_decode_64(&p, fsid.minor);
+       ceph_decode_64_le(&p, fsid.major);
+       ceph_decode_64_le(&p, fsid.minor);
        if (!ceph_fsid_equal(&fsid, &mdsc->client->monc.monmap->fsid)) {
                derr(0, "got mdsmap with wrong fsid\n");
                return;

diff --git a/src/kernel/mds_client.h b/src/kernel/mds_client.h
index 29b5311130be38080715265d226a88c0050b0a4a..2d5605ed56761a8cae5735b5f6747f4257622f0a 100644 (file)
--- a/src/kernel/mds_client.h
+++ b/src/kernel/mds_client.h
@@ -99,11 +99,7 @@ struct ceph_mds_request {
        __u64             r_tid;      /* transaction id */
        struct ceph_msg  *r_request;  /* original request */
        struct ceph_msg  *r_reply;
-<<<<<<< HEAD:src/kernel/mds_client.h
-       struct ceph_mds_reply_info r_reply_info;  /* parsed reply */
-=======
        struct ceph_mds_reply_info_parsed r_reply_info;
->>>>>>> kclient: endianity handling fixes:src/kernel/mds_client.h
        int r_err;
        unsigned long r_timeout;  /* optional.  jiffies */
 

diff --git a/src/kernel/mdsmap.c b/src/kernel/mdsmap.c
index dce80686fb5ffa1b7d2701e69fec02f90fd4f891..911297ee036350e7d1e64af1c1cf5937209d5bbc 100644 (file)
--- a/src/kernel/mdsmap.c
+++ b/src/kernel/mdsmap.c
@@ -70,8 +70,8 @@ struct ceph_mdsmap *ceph_mdsmap_decode(void **p, void *end)
        ceph_decode_32(p, m->m_epoch);
        ceph_decode_32(p, m->m_client_epoch);
        ceph_decode_32(p, m->m_last_failure);
-       ceph_decode_32(p, m->m_created.tv_sec);
-       ceph_decode_32(p, m->m_created.tv_nsec);
+       ceph_decode_32_le(p, m->m_created.tv_sec);
+       ceph_decode_32_le(p, m->m_created.tv_nsec);
        ceph_decode_32(p, m->m_anchortable);
        ceph_decode_32(p, m->m_root);
        ceph_decode_32(p, m->m_session_timeout);

diff --git a/src/kernel/mdsmap.h b/src/kernel/mdsmap.h
index 1fa34c2e91808178e7ce2de4855f8303b4d8047e..b90dc5c042c05b3c6197fbcd30394460121be9d9 100644 (file)
--- a/src/kernel/mdsmap.h
+++ b/src/kernel/mdsmap.h
@@ -9,7 +9,7 @@
  * fields limited to those the client cares about
  */
 struct ceph_mdsmap {
-       ceph_epoch_t m_epoch, m_client_epoch, m_last_failure;
+       __u32 m_epoch, m_client_epoch, m_last_failure;
        struct ceph_timespec m_created;
        __u32 m_anchortable;
        __u32 m_root;

diff --git a/src/kernel/messenger.c b/src/kernel/messenger.c
index 1b0ad6e5dadf50283521cf8d090768498d48271d..9fab1017f305eeac4aec75675d53772e51998caf 100644 (file)
--- a/src/kernel/messenger.c
+++ b/src/kernel/messenger.c
@@ -1235,7 +1235,7 @@ static void process_message(struct ceph_connection *con)
        con->in_seq++;
        spin_unlock(&con->out_queue_lock);
 
-       dout(1, "===== %p %u from %s%d %d=%s len %d+%d (%u %u) =====\n",
+       dout(1, "===== %p %llu from %s%d %d=%s len %d+%d (%u %u) =====\n",
             con->in_msg, le64_to_cpu(con->in_msg->hdr.seq),
             ENTITY_NAME(con->in_msg->hdr.src.name),
             le16_to_cpu(con->in_msg->hdr.type),
@@ -2167,7 +2167,7 @@ void ceph_msg_put(struct ceph_msg *m)
        dout(20, "ceph_msg_put %p %d -> %d\n", m, atomic_read(&m->nref),
             atomic_read(&m->nref)-1);
        if (atomic_read(&m->nref) <= 0) {
-               derr(0, "bad ceph_msg_put on %p %u from %s%d %d=%s len %d+%d\n",
+               derr(0, "bad ceph_msg_put on %p %llu from %s%d %d=%s len %d+%d\n",
                     m, le64_to_cpu(m->hdr.seq),
                     ENTITY_NAME(m->hdr.src.name),
                     le16_to_cpu(m->hdr.type),

diff --git a/src/kernel/mon_client.c b/src/kernel/mon_client.c
index f599d6879449d9f5ddbf88cbb4de9833757fa259..e1549524471bc8f4895e65617443a5004bee3f8d 100644 (file)
--- a/src/kernel/mon_client.c
+++ b/src/kernel/mon_client.c
@@ -26,8 +26,8 @@ struct ceph_monmap *ceph_monmap_decode(void *p, void *end)
 
        ceph_decode_need(&p, end, 2*sizeof(__u32) + 2*sizeof(__u64), bad);
        ceph_decode_32(&p, m->epoch);
-       ceph_decode_64(&p, m->fsid.major);
-       ceph_decode_64(&p, m->fsid.minor);
+       ceph_decode_64_le(&p, m->fsid.major);
+       ceph_decode_64_le(&p, m->fsid.minor);
        ceph_decode_32(&p, m->num_mon);
        ceph_decode_need(&p, end, m->num_mon*sizeof(m->mon_inst[0]), bad);
        ceph_decode_copy(&p, m->mon_inst, m->num_mon*sizeof(m->mon_inst[0]));
@@ -272,10 +272,10 @@ void ceph_monc_handle_statfs_reply(struct ceph_mon_client *monc,
        req = radix_tree_lookup(&monc->statfs_request_tree, tid);
        if (req) {
                radix_tree_delete(&monc->statfs_request_tree, tid);
-               req->buf->f_total = le64_to_cpu(reply->st.f_total);
-               req->buf->f_free = le64_to_cpu(reply->st.f_free);
-               req->buf->f_avail = le64_to_cpu(reply->st.f_avail);
-               req->buf->f_objects = le64_to_cpu(reply->st.f_objects);
+               req->buf->f_total = reply->st.f_total;
+               req->buf->f_free = reply->st.f_free;
+               req->buf->f_avail = reply->st.f_avail;
+               req->buf->f_objects = reply->st.f_objects;
                req->result = 0;
        }
        spin_unlock(&monc->lock);

diff --git a/src/kernel/mon_client.h b/src/kernel/mon_client.h
index b32f27abde3e333efc0066a0b27e63dc9a097b65..287f50aa0780c3d23352c5088137aa3dfbb8d836 100644 (file)
--- a/src/kernel/mon_client.h
+++ b/src/kernel/mon_client.h
@@ -9,7 +9,7 @@ struct ceph_client;
 struct ceph_mount_args;
 
 struct ceph_monmap {
-       ceph_epoch_t epoch;
+       __u32 epoch;
        struct ceph_fsid fsid;
        __u32 num_mon;
        struct ceph_entity_inst mon_inst[0];

diff --git a/src/kernel/osd_client.c b/src/kernel/osd_client.c
index ae894e2ffd816384bbdaea8aabf519773e67df29..e81810b9207a65cd327649c3d08b63ef408a8d77 100644 (file)
--- a/src/kernel/osd_client.c
+++ b/src/kernel/osd_client.c
@@ -42,8 +42,8 @@ static void calc_layout(struct ceph_osd_client *osdc,
        __u64 orig_len = *plen;
        __u64 objoff, objlen;
 
-       reqhead->oid.ino = vino.ino;
-       reqhead->oid.snap = vino.snap;
+       reqhead->oid.ino = cpu_to_le64(vino.ino);
+       reqhead->oid.snap = cpu_to_le64(vino.snap);
 
        calc_file_object_mapping(layout, off, plen, &reqhead->oid,
                                 &objoff, &objlen);
@@ -104,7 +104,7 @@ static struct ceph_msg *new_request_msg(struct ceph_osd_client *osdc, int op,
 
        /* encode head */
        head->op = cpu_to_le32(op);
-       head->client_inc = 1; /* always, for now. */
+       head->client_inc = cpu_to_le32(1); /* always, for now. */
        head->flags = 0;
 
        /* snaps */
@@ -169,7 +169,8 @@ static int register_request(struct ceph_osd_client *osdc,
        }
 
        mutex_lock(&osdc->request_mutex);
-       req->r_tid = head->tid = ++osdc->last_tid;
+       req->r_tid = ++osdc->last_tid;
+       head->tid = cpu_to_le64(req->r_tid);
        req->r_flags = 0;
        req->r_pgid.pg64 = le64_to_cpu(head->layout.ol_pgid);
        req->r_reply = NULL;
@@ -318,7 +319,7 @@ void ceph_osdc_handle_reply(struct ceph_osd_client *osdc, struct ceph_msg *msg)
        }
        dout(10, "handle_reply tid %llu flags %d |= %d\n", tid, req->r_flags,
             rhead->flags);
-       req->r_flags |= rhead->flags;
+       req->r_flags |= le32_to_cpu(rhead->flags);
        __unregister_request(osdc, req);
        mutex_unlock(&osdc->request_mutex);
 
@@ -332,7 +333,7 @@ done:
 
 bad:
        derr(0, "got corrupt osd_op_reply got %d %d expected %d\n",
-            (int)msg->front.iov_len, (int)msg->hdr.front_len,
+            (int)msg->front.iov_len, le32_to_cpu(msg->hdr.front_len),
             (int)sizeof(*rhead));
 }
 
@@ -406,8 +407,8 @@ void ceph_osdc_handle_map(struct ceph_osd_client *osdc, struct ceph_msg *msg)
 
        /* verify fsid */
        ceph_decode_need(&p, end, sizeof(fsid), bad);
-       ceph_decode_64(&p, fsid.major);
-       ceph_decode_64(&p, fsid.minor);
+       ceph_decode_64_le(&p, fsid.major);
+       ceph_decode_64_le(&p, fsid.minor);
        if (!ceph_fsid_equal(&fsid, &osdc->client->monc.monmap->fsid)) {
                derr(0, "got map with wrong fsid, ignoring\n");
                return;
@@ -519,7 +520,7 @@ int ceph_osdc_prepare_pages(void *p, struct ceph_msg *m, int want)
        struct ceph_osd_request *req;
        __u64 tid;
        int ret = -1;
-       int type = le32_to_cpu(m->hdr.type);
+       int type = le16_to_cpu(m->hdr.type);
 
        dout(10, "prepare_pages on msg %p want %d\n", m, want);
        if (unlikely(type != CEPH_MSG_OSD_OPREPLY))
@@ -638,8 +639,8 @@ static void handle_timeout(struct work_struct *work)
                next_tid = req->r_tid + 1;
                if (time_after(jiffies, req->r_last_stamp + timeout)) {
                        struct ceph_entity_name n = {
-                               .type = CEPH_ENTITY_TYPE_OSD,
-                               .num = req->r_last_osd
+                               .type = cpu_to_le32(CEPH_ENTITY_TYPE_OSD),
+                               .num = cpu_to_le32(req->r_last_osd)
                        };
                        ceph_ping(osdc->client->msgr, n, &req->r_last_osd_addr);
                }
@@ -882,8 +883,8 @@ more:
                return PTR_ERR(req);
        reqm = req->r_request;
        reqhead = reqm->front.iov_base;
-       reqhead->flags = CEPH_OSD_OP_ACK | /* just ack for now... FIXME */
-               CEPH_OSD_OP_ORDERSNAP;     /* get EOLDSNAPC if out of order */
+       reqhead->flags = cpu_to_le32(CEPH_OSD_OP_ACK | /* just ack for now... FIXME */
+               CEPH_OSD_OP_ORDERSNAP);     /* get EOLDSNAPC if out of order */
 
        dout(10, "sync_write %llu~%llu -> %d pages\n", off, len,
             req->r_num_pages);
@@ -961,9 +962,9 @@ int ceph_osdc_writepages(struct ceph_osd_client *osdc, struct ceph_vino vino,
        reqm = req->r_request;
        reqhead = reqm->front.iov_base;
        if (osdc->client->mount_args.flags & CEPH_MOUNT_UNSAFE_WRITEBACK)
-               reqhead->flags = CEPH_OSD_OP_ACK;
+               reqhead->flags = cpu_to_le32(CEPH_OSD_OP_ACK);
        else
-               reqhead->flags = CEPH_OSD_OP_SAFE;
+               reqhead->flags = cpu_to_le32(CEPH_OSD_OP_SAFE);
 
        len = le64_to_cpu(reqhead->length);
        dout(10, "writepages %llu~%llu -> %d pages\n", off, len,
@@ -973,8 +974,8 @@ int ceph_osdc_writepages(struct ceph_osd_client *osdc, struct ceph_vino vino,
        memcpy(req->r_pages, pages, req->r_num_pages * sizeof(struct page *));
        reqm->pages = req->r_pages;
        reqm->nr_pages = req->r_num_pages;
-       reqm->hdr.data_len = len;
-       reqm->hdr.data_off = off;
+       reqm->hdr.data_len = cpu_to_le32(len);
+       reqm->hdr.data_off = cpu_to_le32(off);
 
        rc = do_sync_request(osdc, req);
        ceph_osdc_put_request(req);
@@ -999,16 +1000,16 @@ int ceph_osdc_writepages_start(struct ceph_osd_client *osdc,
        dout(10, "writepages_start %llu~%llu, %d pages\n", off, len, num_pages);
 
        if (osdc->client->mount_args.flags & CEPH_MOUNT_UNSAFE_WRITEBACK)
-               reqhead->flags = CEPH_OSD_OP_ACK;
+               reqhead->flags = cpu_to_le32(CEPH_OSD_OP_ACK);
        else
-               reqhead->flags = CEPH_OSD_OP_SAFE;
+               reqhead->flags = cpu_to_le32(CEPH_OSD_OP_SAFE);
        reqhead->length = cpu_to_le64(len);
 
        /* reference pages in message */
        reqm->pages = req->r_pages;
        reqm->nr_pages = req->r_num_pages = num_pages;
-       reqm->hdr.data_len = len;
-       reqm->hdr.data_off = off;
+       reqm->hdr.data_len = cpu_to_le32(len);
+       reqm->hdr.data_off = cpu_to_le32(off);
 
        rc = start_request(osdc, req);
        return rc;

diff --git a/src/kernel/osdmap.c b/src/kernel/osdmap.c
index b37f771b057a6858f9088492164cf1cfb3ed3b32..e13ae2dc8248638c5215e1a1c8e0aae012b75a89 100644 (file)
--- a/src/kernel/osdmap.c
+++ b/src/kernel/osdmap.c
@@ -328,13 +328,13 @@ struct ceph_osdmap *osdmap_decode(void **p, void *end)
                return ERR_PTR(-ENOMEM);
 
        ceph_decode_need(p, end, 2*sizeof(__u64)+11*sizeof(__u32), bad);
-       ceph_decode_64(p, map->fsid.major);
-       ceph_decode_64(p, map->fsid.minor);
+       ceph_decode_64_le(p, map->fsid.major);
+       ceph_decode_64_le(p, map->fsid.minor);
        ceph_decode_32(p, map->epoch);
-       ceph_decode_32(p, map->ctime.tv_sec);
-       ceph_decode_32(p, map->ctime.tv_nsec);
-       ceph_decode_32(p, map->mtime.tv_sec);
-       ceph_decode_32(p, map->mtime.tv_nsec);
+       ceph_decode_32_le(p, map->ctime.tv_sec);
+       ceph_decode_32_le(p, map->ctime.tv_nsec);
+       ceph_decode_32_le(p, map->mtime.tv_sec);
+       ceph_decode_32_le(p, map->mtime.tv_nsec);
        ceph_decode_32(p, map->pg_num);
        ceph_decode_32(p, map->pgp_num);
        ceph_decode_32(p, map->lpg_num);
@@ -426,12 +426,12 @@ struct ceph_osdmap *apply_incremental(void **p, void *end,
 
        ceph_decode_need(p, end, sizeof(fsid)+sizeof(ctime)+2*sizeof(__u32),
                         bad);
-       ceph_decode_64(p, fsid.major);
-       ceph_decode_64(p, fsid.minor);
+       ceph_decode_64_le(p, fsid.major);
+       ceph_decode_64_le(p, fsid.minor);
        ceph_decode_32(p, epoch);
        BUG_ON(epoch != map->epoch+1);
-       ceph_decode_32(p, ctime.tv_sec);
-       ceph_decode_32(p, ctime.tv_nsec);
+       ceph_decode_32_le(p, ctime.tv_sec);
+       ceph_decode_32_le(p, ctime.tv_nsec);
        ceph_decode_32(p, new_flags);
 
        /* full map? */
@@ -583,7 +583,7 @@ void calc_file_object_mapping(struct ceph_file_layout *layout,
 
        dout(80, "mapping %llu~%llu  osize %u fl_su %u\n", off, *plen,
             osize, su);
-       su_per_object = osize / layout->fl_stripe_unit;
+       su_per_object = osize / le32_to_cpu(layout->fl_stripe_unit);
        dout(80, "osize %u / su %u = su_per_object %u\n", osize, su,
             su_per_object);
 
@@ -598,7 +598,7 @@ void calc_file_object_mapping(struct ceph_file_layout *layout,
        stripepos = bl % sc;
        objsetno = stripeno / su_per_object;
 
-       oid->bno = objsetno * sc + stripepos;
+       oid->bno = cpu_to_le32(objsetno * sc + stripepos);
        dout(80, "objset %u * sc %u = bno %u\n", objsetno, sc, oid->bno);
        /* *oxoff = *off / layout->fl_stripe_unit; */
        t = off;

diff --git a/src/kernel/osdmap.h b/src/kernel/osdmap.h
index 45bad6ac400a100d79515814cd273461eecfe3b8..5d27f89469c0e0d5789ae0fb01a2b855bb8f87f0 100644 (file)
--- a/src/kernel/osdmap.h
+++ b/src/kernel/osdmap.h
@@ -6,15 +6,15 @@
 
 struct ceph_osdmap {
        struct ceph_fsid fsid;
-       ceph_epoch_t epoch;
-       ceph_epoch_t mkfs_epoch;
+       __u32 epoch;
+       __u32 mkfs_epoch;
        struct ceph_timespec ctime, mtime;
 
        __u32 pg_num, pg_num_mask;
        __u32 pgp_num, pgp_num_mask;
        __u32 lpg_num, lpg_num_mask;
        __u32 lpgp_num, lpgp_num_mask;
-       ceph_epoch_t last_pg_change;
+       __u32 last_pg_change;
 
        __u32 flags;