osd: name args in ceph_osd_op union

diff --git a/src/client/SyntheticClient.cc b/src/client/SyntheticClient.cc
index 2ef066ee5e3d0a953e24a2bd3740fbb468bb5f07..b5d7b37c9c1a82b074f67672425d6897c64ac649 100644 (file)
--- a/src/client/SyntheticClient.cc
+++ b/src/client/SyntheticClient.cc
@@ -2270,8 +2270,8 @@ int SyntheticClient::object_rw(int nobj, int osize, int wrpc,
       ObjectOperation m;
       OSDOp op;
       op.op.op = CEPH_OSD_OP_WRITE;
-      op.op.offset = 0;
-      op.op.length = osize;
+      op.op.extent.offset = 0;
+      op.op.extent.length = osize;
       op.data = bl;
       m.ops.push_back(op);
       if (do_sync) {

diff --git a/src/include/rados.h b/src/include/rados.h
index ea267c4201ae760796d08aa39bcbff72659ffb47..a48cf4ae391e6078df09cc7cb2a697bd42e0977b 100644 (file)
--- a/src/include/rados.h
+++ b/src/include/rados.h
@@ -301,31 +301,29 @@ enum {
  * payload
  */
 struct ceph_osd_op {
-       __le16 op;
+       __le16 op;           /* CEPH_OSD_OP_* */
+       __le32 flags;        /* CEPH_OSD_FLAG_* */
        union {
                struct {
                        __le64 offset, length;
-               } __attribute__ ((packed));
+               } __attribute__ ((packed)) extent;
                struct {
                        __le32 name_len;
                        __le32 value_len;
-               } __attribute__ ((packed));
+               } __attribute__ ((packed)) xattr;
                struct {
                        __le64 truncate_size;
                        __le32 truncate_seq;
-               } __attribute__ ((packed));
+               } __attribute__ ((packed)) trunc;
                struct {
                        __u8 class_len;
                        __u8 method_len;
                        __u8 argc;
                        __le32 indata_len;
-               } __attribute__ ((packed));
+               } __attribute__ ((packed)) cls;
                struct {
-                       __le64 pgls_cookie, count;
-               } __attribute__ ((packed));
-               struct {
-                       __le32 flags;
-               } __attribute__ ((packed));
+                       __le64 cookie, count;
+               } __attribute__ ((packed)) pgls;
        };
        __le32 payload_len;
 } __attribute__ ((packed));

diff --git a/src/kernel/addr.c b/src/kernel/addr.c
index 91e95cac6204da3c65a6c173a81e7b34c40cc027..00379f10c95c3b23d59cd079cb301b5ab873aa4d 100644 (file)
--- a/src/kernel/addr.c
+++ b/src/kernel/addr.c
@@ -524,7 +524,7 @@ static void writepages_finish(struct ceph_osd_request *req,
        WARN_ON(le32_to_cpu(replyhead->num_ops) == 0);
        op = (void *)(replyhead + 1);
        rc = le32_to_cpu(replyhead->result);
-       bytes = le64_to_cpu(op->length);
+       bytes = le64_to_cpu(op->extent.length);
 
        if (rc >= 0) {
                wrote = (bytes + (offset & ~PAGE_CACHE_MASK) + ~PAGE_CACHE_MASK)
@@ -837,7 +837,7 @@ get_more_pages:
                req->r_num_pages = locked_pages;
                reqhead = req->r_request->front.iov_base;
                op = (void *)(reqhead + 1);
-               op->length = cpu_to_le64(len);
+               op->extent.length = cpu_to_le64(len);
                op->payload_len = cpu_to_le32(len);
                req->r_request->hdr.data_len = cpu_to_le32(len);
 

diff --git a/src/kernel/osd_client.c b/src/kernel/osd_client.c
index 41cde0cf5bf8a6b50347c016c375cae80f78b634..978593a4f466a8c6060f064cc73536341441a8a2 100644 (file)
--- a/src/kernel/osd_client.c
+++ b/src/kernel/osd_client.c
@@ -64,8 +64,8 @@ static void calc_layout(struct ceph_osd_client *osdc,
        sprintf(req->r_oid, "%llx.%08llx", vino.ino, bno);
        req->r_oid_len = strlen(req->r_oid);
 
-       op->offset = cpu_to_le64(objoff);
-       op->length = cpu_to_le64(objlen);
+       op->extent.offset = cpu_to_le64(objoff);
+       op->extent.length = cpu_to_le64(objlen);
        req->r_num_pages = calc_pages_for(off, *plen);
 
        dout("calc_layout %s (%d) %llu~%llu (%d pages)\n",
@@ -205,9 +205,10 @@ struct ceph_osd_request *ceph_osdc_new_request(struct ceph_osd_client *osdc,
                op++;
                op->op = cpu_to_le16(opcode == CEPH_OSD_OP_READ ?
                             CEPH_OSD_OP_MASKTRUNC : CEPH_OSD_OP_SETTRUNC);
-               op->truncate_seq = cpu_to_le32(truncate_seq);
-               prevofs = le64_to_cpu((op-1)->offset);
-               op->truncate_size = cpu_to_le64(truncate_size - (off-prevofs));
+               op->trunc.truncate_seq = cpu_to_le32(truncate_seq);
+               prevofs = le64_to_cpu((op-1)->extent.offset);
+               op->trunc.truncate_size = cpu_to_le64(truncate_size -
+                                                     (off-prevofs));
        }
        if (do_sync) {
                op++;

diff --git a/src/messages/MOSDOp.h b/src/messages/MOSDOp.h
index 835cd0968455d11698d52a6aa3b403725fc4bf7a..5a70766d826d5814afb662cfb028b794b122545e 100644 (file)
--- a/src/messages/MOSDOp.h
+++ b/src/messages/MOSDOp.h
@@ -105,8 +105,8 @@ public:
   void add_simple_op(int o, __u64 off, __u64 len) {
     OSDOp osd_op;
     osd_op.op.op = o;
-    osd_op.op.offset = off;
-    osd_op.op.length = len;
+    osd_op.op.extent.offset = off;
+    osd_op.op.extent.length = len;
     ops.push_back(osd_op);
   }
   void write(__u64 off, __u64 len, bufferlist& bl) {

diff --git a/src/messages/MOSDSubOp.h b/src/messages/MOSDSubOp.h
index b20162c76cb9f1cde4b8411f9b8106801aac992e..3ffae10a10263a6fda42cbfde9abbe925ee039e6 100644 (file)
--- a/src/messages/MOSDSubOp.h
+++ b/src/messages/MOSDSubOp.h
@@ -131,7 +131,7 @@ public:
     ::encode(data_subset, payload);
     ::encode(clone_subsets, payload);
     if (ops.size())
-      header.data_off = ops[0].op.offset;
+      header.data_off = ops[0].op.extent.offset;
     else
       header.data_off = 0;
   }

diff --git a/src/objclass/class_api.cc b/src/objclass/class_api.cc
index 369b6f37829aefb8dee30125c41c9a9a86b1dcbb..b2ee1889db93ccee22ac4819694c3477abf41fa6 100644 (file)
--- a/src/objclass/class_api.cc
+++ b/src/objclass/class_api.cc
@@ -98,11 +98,11 @@ int cls_call(cls_method_context_t hctx, const char *cls, const char *method,
   int r;
 
   op.op.op = CEPH_OSD_OP_CALL;
-  op.op.class_len = strlen(cls);
-  op.op.method_len = strlen(method);
-  op.op.indata_len = datalen;
-  op.data.append(cls, op.op.class_len);
-  op.data.append(method, op.op.method_len);
+  op.op.cls.class_len = strlen(cls);
+  op.op.cls.method_len = strlen(method);
+  op.op.cls.indata_len = datalen;
+  op.data.append(cls, op.op.cls.class_len);
+  op.data.append(method, op.op.cls.method_len);
   op.data.append(indata, datalen);
   r = (*pctx)->pg->do_osd_ops(*pctx, nops, odata);
 
@@ -125,7 +125,7 @@ int cls_getxattr(cls_method_context_t hctx, const char *name,
 
   op.op.op = CEPH_OSD_OP_GETXATTR;
   op.data.append(name);
-  op.op.name_len = strlen(name);
+  op.op.xattr.name_len = strlen(name);
   r = (*pctx)->pg->do_osd_ops(*pctx, nops, odata);
 
   *outdata = (char *)malloc(odata.length());
@@ -148,8 +148,8 @@ int cls_setxattr(cls_method_context_t hctx, const char *name,
   op.op.op = CEPH_OSD_OP_SETXATTR;
   op.data.append(name);
   op.data.append(value);
-  op.op.name_len = strlen(name);
-  op.op.value_len = val_len;
+  op.op.xattr.name_len = strlen(name);
+  op.op.xattr.value_len = val_len;
   r = (*pctx)->pg->do_osd_ops(*pctx, nops, odata);
 
   return r;
@@ -161,8 +161,8 @@ int cls_read(cls_method_context_t hctx, int ofs, int len,
   ReplicatedPG::OpContext **pctx = (ReplicatedPG::OpContext **)hctx;
   vector<OSDOp> ops(1);
   ops[0].op.op = CEPH_OSD_OP_READ;
-  ops[0].op.offset = ofs;
-  ops[0].op.length = len;
+  ops[0].op.extent.offset = ofs;
+  ops[0].op.extent.length = len;
   bufferlist odata;
   int r = (*pctx)->pg->do_osd_ops(*pctx, ops, odata);
 
@@ -178,8 +178,8 @@ int cls_cxx_read(cls_method_context_t hctx, int ofs, int len, bufferlist *outbl)
   ReplicatedPG::OpContext **pctx = (ReplicatedPG::OpContext **)hctx;
   vector<OSDOp> ops(1);
   ops[0].op.op = CEPH_OSD_OP_READ;
-  ops[0].op.offset = ofs;
-  ops[0].op.length = len;
+  ops[0].op.extent.offset = ofs;
+  ops[0].op.extent.length = len;
   return (*pctx)->pg->do_osd_ops(*pctx, ops, *outbl);
 }
 
@@ -188,8 +188,8 @@ int cls_cxx_write(cls_method_context_t hctx, int ofs, int len, bufferlist *inbl)
   ReplicatedPG::OpContext **pctx = (ReplicatedPG::OpContext **)hctx;
   vector<OSDOp> ops(1);
   ops[0].op.op = CEPH_OSD_OP_WRITE;
-  ops[0].op.offset = ofs;
-  ops[0].op.length = len;
+  ops[0].op.extent.offset = ofs;
+  ops[0].op.extent.length = len;
   ops[0].data = *inbl;
   bufferlist outbl;
   return (*pctx)->pg->do_osd_ops(*pctx, ops, outbl);
@@ -200,11 +200,11 @@ int cls_cxx_replace(cls_method_context_t hctx, int ofs, int len, bufferlist *inb
   ReplicatedPG::OpContext **pctx = (ReplicatedPG::OpContext **)hctx;
   vector<OSDOp> ops(2);
   ops[0].op.op = CEPH_OSD_OP_TRUNCATE;
-  ops[0].op.offset = 0;
-  ops[0].op.length = 0;
+  ops[0].op.extent.offset = 0;
+  ops[0].op.extent.length = 0;
   ops[1].op.op = CEPH_OSD_OP_WRITE;
-  ops[1].op.offset = ofs;
-  ops[1].op.length = len;
+  ops[1].op.extent.offset = ofs;
+  ops[1].op.extent.length = len;
   ops[1].data = *inbl;
   bufferlist outbl;
   return (*pctx)->pg->do_osd_ops(*pctx, ops, outbl);

diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc
index b5e30365d2d5f84ca5ee89abada16e19d38fa30b..f489f585fa718469429206f1ae05662f34532311 100644 (file)
--- a/src/osd/OSD.cc
+++ b/src/osd/OSD.cc
@@ -4073,8 +4073,8 @@ void OSD::init_op_flags(MOSDOp *op)
        bufferlist::iterator bp = iter->data.begin();
        int is_write, is_read;
        string cname, mname;
-       bp.copy(iter->op.class_len, cname);
-       bp.copy(iter->op.method_len, mname);
+       bp.copy(iter->op.cls.class_len, cname);
+       bp.copy(iter->op.cls.method_len, mname);
        is_read = class_handler->get_method_flags(cname, mname) & CLS_METHOD_RD;
        is_write = class_handler->get_method_flags(cname, mname) & CLS_METHOD_WR;
        dout(0) << "class " << cname << " method " << mname

diff --git a/src/osd/ReplicatedPG.cc b/src/osd/ReplicatedPG.cc
index d084bffeb116a3d1423d74f5f3615a7e4a617247..b095c8ac9e938addff3b37362e597d7bfbb9b22a 100644 (file)
--- a/src/osd/ReplicatedPG.cc
+++ b/src/osd/ReplicatedPG.cc
@@ -346,7 +346,7 @@ bool ReplicatedPG::preprocess_op(MOSDOp *op, utime_t now)
   // if this is a read and the data is in the cache, do an immediate read.. 
   if ( g_conf.osd_immediate_read_from_cache ) {
     if (osd->store->is_cached(info.pgid.to_coll(), soid,
-                             readop.offset,
+                             readop.extent.offset,
                              readop.length) == 0) {
       if (!is_primary() && !op->get_source().is_osd()) {
        // am i allowed?
@@ -389,10 +389,10 @@ void ReplicatedPG::do_pg_op(MOSDOp *op)
         dout(10) << " pgls pg=" << op->get_pg() << dendl;
        // read into a buffer
         PGLSResponse response;
-        response.handle = (collection_list_handle_t)(__u64)(p->op.pgls_cookie);
+        response.handle = (collection_list_handle_t)(__u64)(p->op.pgls.cookie);
         vector<sobject_t> sentries;
        result = osd->store->collection_list_partial(coll_t::build_pg_coll(info.pgid), snapid,
-                                                    sentries, p->op.length,
+                                                    sentries, p->op.pgls.count,
                                                     &response.handle);
        if (result == 0) {
           vector<sobject_t>::iterator iter;
@@ -888,8 +888,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
     bufferlist::iterator bp = osd_op.data.begin();
     switch (op.op) {
     case CEPH_OSD_OP_CALL:
-      bp.copy(op.class_len, cname);
-      bp.copy(op.method_len, mname);
+      bp.copy(op.cls.class_len, cname);
+      bp.copy(op.cls.method_len, mname);
       is_modify = osd->class_handler->get_method_flags(cname, mname) & CLS_METHOD_WR;
       break;
 
@@ -905,9 +905,9 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
     // munge ZERO -> TRUNCATE?  (don't munge to DELETE or we risk hosing attributes)
     if (op.op == CEPH_OSD_OP_ZERO &&
        ctx->obs->exists &&
-       op.offset + op.length >= oi.size) {
-      dout(10) << " munging ZERO " << op.offset << "~" << op.length
-              << " -> TRUNCATE " << op.offset << " (old size is " << oi.size << ")" << dendl;
+       op.extent.offset + op.extent.length >= oi.size) {
+      dout(10) << " munging ZERO " << op.extent.offset << "~" << op.extent.length
+              << " -> TRUNCATE " << op.extent.offset << " (old size is " << oi.size << ")" << dendl;
       op.op = CEPH_OSD_OP_TRUNCATE;
     }
 
@@ -919,26 +919,26 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
       {
        // read into a buffer
        bufferlist bl;
-       int r = osd->store->read(coll_t::build_pg_coll(info.pgid), soid, op.offset, op.length, bl);
+       int r = osd->store->read(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset, op.extent.length, bl);
        if (odata.length() == 0)
-         ctx->data_off = op.offset;
+         ctx->data_off = op.extent.offset;
        odata.claim(bl);
        if (r >= 0) 
-         op.length = r;
+         op.extent.length = r;
        else {
          result = r;
-         op.length = 0;
+         op.extent.length = 0;
        }
-       info.stats.num_rd_kb += SHIFT_ROUND_UP(op.length, 10);
+       info.stats.num_rd_kb += SHIFT_ROUND_UP(op.extent.length, 10);
        info.stats.num_rd++;
-       dout(10) << " read got " << r << " / " << op.length << " bytes from obj " << soid << dendl;
+       dout(10) << " read got " << r << " / " << op.extent.length << " bytes from obj " << soid << dendl;
       }
       break;
 
     case CEPH_OSD_OP_CALL:
       {
        bufferlist indata;
-       bp.copy(op.indata_len, indata);
+       bp.copy(op.cls.indata_len, indata);
        
        ClassHandler::ClassData *cls;
         ClassVersion version;
@@ -958,7 +958,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
            dout(10) << "call method " << cname << "." << mname << dendl;
            result = method->exec((cls_method_context_t)&ctx, indata, outdata);
            dout(10) << "method called response length=" << outdata.length() << dendl;
-           op.length = outdata.length();
+           op.extent.length = outdata.length();
            odata.claim_append(outdata);
          }
        }
@@ -981,12 +981,12 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
 
     case CEPH_OSD_OP_GETXATTR:
       {
-       nstring name(op.name_len + 1);
+       nstring name(op.xattr.name_len + 1);
        name[0] = '_';
-       bp.copy(op.name_len, name.data()+1);
+       bp.copy(op.xattr.name_len, name.data()+1);
        int r = osd->store->getattr(coll_t::build_pg_coll(info.pgid), soid, name.c_str(), odata);
        if (r >= 0) {
-         op.value_len = r;
+         op.xattr.value_len = r;
          result = 0;
        } else
          result = r;
@@ -1018,7 +1018,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
        OSDOp& m = *p;
        
        // are we beyond truncate_size?
-       if (rd.op.offset + rd.op.length > m.op.truncate_size) { 
+       if (rd.op.extent.offset + rd.op.extent.length > m.op.trunc.truncate_size) {     
          __u32 seq = 0;
          interval_set<__u64> tm;
          if (oi.truncate_info.length()) {
@@ -1028,11 +1028,11 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
          }
          
          // truncated portion of the read
-         unsigned from = MAX(rd.op.offset, m.op.truncate_size);  // also end of data
-         unsigned to = rd.op.offset + rd.op.length;
+         unsigned from = MAX(rd.op.extent.offset, m.op.trunc.truncate_size);  // also end of data
+         unsigned to = rd.op.extent.offset + rd.op.extent.length;
          unsigned trim = to-from;
          
-         rd.op.length = rd.op.length - trim;
+         rd.op.extent.length = rd.op.extent.length - trim;
          
          dout(10) << " masktrunc " << m << ": overlap " << from << "~" << trim << dendl;
          
@@ -1042,7 +1042,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
          truncated.substr_of(odata, odata.length() - trim, trim);
          keep.swap(odata);
          
-         if (seq == rd.op.truncate_seq) {
+         if (seq == rd.op.trunc.truncate_seq) {
            // keep any valid extents beyond 'from'
            unsigned data_end = from;
            for (map<__u64,__u64>::iterator q = tm.m.begin();
@@ -1060,7 +1060,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
                  bp.zero();
                  odata.push_back(bp);
                  dout(20) << "  adding " << bp.length() << " zeros" << dendl;
-                 rd.op.length = rd.op.length + bp.length();
+                 rd.op.extent.length = rd.op.extent.length + bp.length();
                  data_end += bp.length();
                }
 
@@ -1068,7 +1068,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
                b.substr_of(truncated, s-from, l);
                dout(20) << "  adding " << b.length() << " bytes from " << s << "~" << l << dendl;
                odata.claim_append(b);
-               rd.op.length = rd.op.length + l;
+               rd.op.extent.length = rd.op.extent.length + l;
                data_end += l;
              }
            } // for
@@ -1084,29 +1084,29 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
 
     case CEPH_OSD_OP_WRITE:
       { // write
-        if (op.length) {
+        if (op.extent.length) {
          bufferlist nbl;
-         bp.copy(op.length, nbl);
-         t.write(coll_t::build_pg_coll(info.pgid), soid, op.offset, op.length, nbl);
+         bp.copy(op.extent.length, nbl);
+         t.write(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset, op.extent.length, nbl);
         } else {
           t.touch(coll_t::build_pg_coll(info.pgid), soid);
         }
        if (ssc->snapset.clones.size()) {
          snapid_t newest = *ssc->snapset.clones.rbegin();
          interval_set<__u64> ch;
-         ch.insert(op.offset, op.length);
+         ch.insert(op.extent.offset, op.extent.length);
          ch.intersection_of(ssc->snapset.clone_overlap[newest]);
          ssc->snapset.clone_overlap[newest].subtract(ch);
          add_interval_usage(ch, info.stats);
        }
-       if (op.offset + op.length > oi.size) {
-         __u64 new_size = op.offset + op.length;
+       if (op.extent.offset + op.extent.length > oi.size) {
+         __u64 new_size = op.extent.offset + op.extent.length;
          info.stats.num_bytes += new_size - oi.size;
          info.stats.num_kb += SHIFT_ROUND_UP(new_size, 10) - SHIFT_ROUND_UP(oi.size, 10);
          oi.size = new_size;
        }
        info.stats.num_wr++;
-       info.stats.num_wr_kb += SHIFT_ROUND_UP(op.length, 10);
+       info.stats.num_wr_kb += SHIFT_ROUND_UP(op.extent.length, 10);
        ssc->snapset.head_exists = true;
       }
       break;
@@ -1114,37 +1114,37 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
     case CEPH_OSD_OP_WRITEFULL:
       { // write full object
        bufferlist nbl;
-       bp.copy(op.length, nbl);
+       bp.copy(op.extent.length, nbl);
        t.truncate(coll_t::build_pg_coll(info.pgid), soid, 0);
-       t.write(coll_t::build_pg_coll(info.pgid), soid, op.offset, op.length, nbl);
+       t.write(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset, op.extent.length, nbl);
        if (ssc->snapset.clones.size()) {
          snapid_t newest = *ssc->snapset.clones.rbegin();
          ssc->snapset.clone_overlap.erase(newest);
          oi.size = 0;
        }
-       if (op.length != oi.size) {
+       if (op.extent.length != oi.size) {
          info.stats.num_bytes -= oi.size;
          info.stats.num_kb -= SHIFT_ROUND_UP(oi.size, 10);
-         info.stats.num_bytes += op.length;
-         info.stats.num_kb += SHIFT_ROUND_UP(op.length, 10);
-         oi.size = op.length;
+         info.stats.num_bytes += op.extent.length;
+         info.stats.num_kb += SHIFT_ROUND_UP(op.extent.length, 10);
+         oi.size = op.extent.length;
        }
        info.stats.num_wr++;
-       info.stats.num_wr_kb += SHIFT_ROUND_UP(op.length, 10);
+       info.stats.num_wr_kb += SHIFT_ROUND_UP(op.extent.length, 10);
        ssc->snapset.head_exists = true;
       }
       break;
 
     case CEPH_OSD_OP_ZERO:
       { // zero
-       assert(op.length);
+       assert(op.extent.length);
        if (!ctx->obs->exists)
          t.touch(coll_t::build_pg_coll(info.pgid), soid);
-       t.zero(coll_t::build_pg_coll(info.pgid), soid, op.offset, op.length);
+       t.zero(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset, op.extent.length);
        if (ssc->snapset.clones.size()) {
          snapid_t newest = *ssc->snapset.clones.rbegin();
          interval_set<__u64> ch;
-         ch.insert(op.offset, op.length);
+         ch.insert(op.extent.offset, op.extent.length);
          ch.intersection_of(ssc->snapset.clone_overlap[newest]);
          ssc->snapset.clone_overlap[newest].subtract(ch);
          add_interval_usage(ch, info.stats);
@@ -1169,26 +1169,26 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
       { // truncate
        if (!ctx->obs->exists)
          t.touch(coll_t::build_pg_coll(info.pgid), soid);
-       t.truncate(coll_t::build_pg_coll(info.pgid), soid, op.offset);
+       t.truncate(coll_t::build_pg_coll(info.pgid), soid, op.extent.offset);
        if (ssc->snapset.clones.size()) {
          snapid_t newest = *ssc->snapset.clones.rbegin();
          interval_set<__u64> trim;
-         if (oi.size > op.offset) {
-           trim.insert(op.offset, oi.size-op.offset);
+         if (oi.size > op.extent.offset) {
+           trim.insert(op.extent.offset, oi.size-op.extent.offset);
            trim.intersection_of(ssc->snapset.clone_overlap[newest]);
            add_interval_usage(trim, info.stats);
          }
          interval_set<__u64> keep;
-         if (op.offset)
-           keep.insert(0, op.offset);
+         if (op.extent.offset)
+           keep.insert(0, op.extent.offset);
          ssc->snapset.clone_overlap[newest].intersection_of(keep);
        }
-       if (op.offset != oi.size) {
+       if (op.extent.offset != oi.size) {
          info.stats.num_bytes -= oi.size;
          info.stats.num_kb -= SHIFT_ROUND_UP(oi.size, 10);
-         info.stats.num_bytes += op.offset;
-         info.stats.num_kb += SHIFT_ROUND_UP(op.offset, 10);
-         oi.size = op.offset;
+         info.stats.num_bytes += op.extent.offset;
+         info.stats.num_kb += SHIFT_ROUND_UP(op.extent.offset, 10);
+         oi.size = op.extent.offset;
        }
        info.stats.num_wr++;
        // do no set head_exists, or we will break above DELETE -> TRUNCATE munging.
@@ -1222,11 +1222,11 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
       {
        if (!ctx->obs->exists)
          t.touch(coll_t::build_pg_coll(info.pgid), soid);
-       nstring name(op.name_len + 1);
+       nstring name(op.xattr.name_len + 1);
        name[0] = '_';
-       bp.copy(op.name_len, name.data()+1);
+       bp.copy(op.xattr.name_len, name.data()+1);
        bufferlist bl;
-       bp.copy(op.value_len, bl);
+       bp.copy(op.xattr.value_len, bl);
        if (!ctx->obs->exists)  // create object if it doesn't yet exist.
          t.touch(coll_t::build_pg_coll(info.pgid), soid);
        t.setattr(coll_t::build_pg_coll(info.pgid), soid, name, bl);
@@ -1237,9 +1237,9 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
 
     case CEPH_OSD_OP_RMXATTR:
       {
-       nstring name(op.name_len + 1);
+       nstring name(op.xattr.name_len + 1);
        name[0] = '_';
-       bp.copy(op.name_len, name.data()+1);
+       bp.copy(op.xattr.name_len, name.data()+1);
        t.rmattr(coll_t::build_pg_coll(info.pgid), soid, name);
        info.stats.num_wr++;
       }
@@ -1254,8 +1254,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
        vector<OSDOp> nops(1);
        OSDOp& newop = nops[0];
        newop.op.op = CEPH_OSD_OP_WRITE;
-       newop.op.offset = oi.size;
-       newop.op.length = op.length;
+       newop.op.extent.offset = oi.size;
+       newop.op.extent.length = op.extent.length;
         newop.data = osd_op.data;
        do_osd_ops(ctx, nops, odata);
       }
@@ -1277,14 +1277,14 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
          p = oi.truncate_info.begin();
          ::decode(seq, p);
        }
-       if (seq < op.truncate_seq) {
-         seq = op.truncate_seq;
-         tm.insert(wr.op.offset, wr.op.length);
+       if (seq < op.trunc.truncate_seq) {
+         seq = op.trunc.truncate_seq;
+         tm.insert(wr.op.extent.offset, wr.op.extent.length);
        } else {
          if (oi.truncate_info.length())
            ::decode(tm, p);
          interval_set<__u64> n;
-         n.insert(wr.op.offset, wr.op.length);
+         n.insert(wr.op.extent.offset, wr.op.extent.length);
          tm.union_of(n);
        }
        dout(10) << " settrunc seq " << seq << " map " << tm << dendl;
@@ -1303,14 +1303,14 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
          ::decode(old_seq, p);
        }
        
-       if (op.truncate_seq > old_seq) {
+       if (op.trunc.truncate_seq > old_seq) {
          // just truncate/delete.
          vector<OSDOp> nops(1);
          OSDOp& newop = nops[0];
          newop.op.op = CEPH_OSD_OP_TRUNCATE;
-         newop.op.offset = op.truncate_size;
+         newop.op.extent.offset = op.trunc.truncate_size;
           newop.data = osd_op.data;
-         dout(10) << " seq " << op.truncate_seq << " > old_seq " << old_seq
+         dout(10) << " seq " << op.trunc.truncate_seq << " > old_seq " << old_seq
                   << ", truncating with " << newop << dendl;
          do_osd_ops(ctx, nops, odata);
        } else {
@@ -1323,7 +1323,7 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
          tm.intersection_of(zero);
          zero.subtract(tm);
          
-         dout(10) << " seq " << op.truncate_seq << " == old_seq " << old_seq
+         dout(10) << " seq " << op.trunc.truncate_seq << " == old_seq " << old_seq
                   << ", tm " << tm << ", zeroing " << zero << dendl;
          for (map<__u64,__u64>::iterator p = zero.m.begin();
               p != zero.m.end();
@@ -1331,8 +1331,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
            vector<OSDOp> nops(1);
            OSDOp& newop = nops[0];
            newop.op.op = CEPH_OSD_OP_ZERO;
-           newop.op.offset = p->first;
-           newop.op.length = p->second;
+           newop.op.extent.offset = p->first;
+           newop.op.extent.length = p->second;
             newop.data = osd_op.data;
            do_osd_ops(ctx, nops, odata);
          }
@@ -1350,8 +1350,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
        vector<OSDOp> nops(1);
        OSDOp& newop = nops[0];
        newop.op.op = CEPH_OSD_OP_READ;
-       newop.op.offset = 0;
-       newop.op.length = 0;
+       newop.op.extent.offset = 0;
+       newop.op.extent.length = 0;
        do_osd_ops(ctx, nops, odata);
       }
       break;
@@ -1375,8 +1375,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
        vector<OSDOp> nops(1);
        OSDOp& newop = nops[0];
        newop.op.op = CEPH_OSD_OP_WRITEFULL;
-       newop.op.offset = 0;
-       newop.op.length = osd_op.data.length();
+       newop.op.extent.offset = 0;
+       newop.op.extent.length = osd_op.data.length();
        newop.data = osd_op.data;
        bufferlist r;
        do_osd_ops(ctx, nops, r);
@@ -1390,8 +1390,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
        vector<OSDOp> nops(1);
        OSDOp& newop = nops[0];
        newop.op.op = CEPH_OSD_OP_READ;
-       newop.op.offset = 0;
-       newop.op.length = 0;
+       newop.op.extent.offset = 0;
+       newop.op.extent.length = 0;
        do_osd_ops(ctx, nops, ibl);
        dout(10) << "tmapup read " << ibl.length() << dendl;
 
@@ -1575,8 +1575,8 @@ int ReplicatedPG::do_osd_ops(OpContext *ctx, vector<OSDOp>& ops,
        // write it out
        dout(20) << "tmapput write " << obl.length() << dendl;
        newop.op.op = CEPH_OSD_OP_WRITEFULL;
-       newop.op.offset = 0;
-       newop.op.length = obl.length();
+       newop.op.extent.offset = 0;
+       newop.op.extent.length = obl.length();
         newop.data = obl;
        do_osd_ops(ctx, nops, odata);
       }
@@ -2905,8 +2905,8 @@ void ReplicatedPG::push(const sobject_t& soid, int peer,
                                   osd->osdmap->get_epoch(), osd->get_tid(), oi.version);
   subop->ops = vector<OSDOp>(1);
   subop->ops[0].op.op = CEPH_OSD_OP_PUSH;
-  subop->ops[0].op.offset = 0;
-  subop->ops[0].op.length = size;
+  subop->ops[0].op.extent.offset = 0;
+  subop->ops[0].op.extent.length = size;
   subop->ops[0].data = bl;
   subop->data_subset.swap(data_subset);
   subop->clone_subsets.swap(clone_subsets);
@@ -3026,7 +3026,7 @@ void ReplicatedPG::sub_op_push(MOSDSubOp *op)
   dout(7) << "op_push " 
           << soid 
           << " v " << v 
-         << " len " << push.op.length
+         << " len " << push.op.extent.length
          << " data_subset " << op->data_subset
          << " clone_subsets " << op->clone_subsets
          << " data len " << op->get_data().length()
@@ -3040,8 +3040,8 @@ void ReplicatedPG::sub_op_push(MOSDSubOp *op)
 
   // determine data/clone subsets
   data_subset = op->data_subset;
-  if (data_subset.empty() && push.op.length && push.op.length == data.length())
-    data_subset.insert(0, push.op.length);
+  if (data_subset.empty() && push.op.extent.length && push.op.extent.length == data.length())
+    data_subset.insert(0, push.op.extent.length);
   clone_subsets = op->clone_subsets;
 
   if (is_primary()) {

diff --git a/src/osd/osd_types.h b/src/osd/osd_types.h
index 41129044ecb813f5998cef44513969dbae0b13fb..b42b8dd0959502fbef34a7cfaa2b67d2fef2ab47 100644 (file)
--- a/src/osd/osd_types.h
+++ b/src/osd/osd_types.h
@@ -1222,31 +1222,31 @@ inline ostream& operator<<(ostream& out, const OSDOp& op) {
     case CEPH_OSD_OP_DELETE:
       break;
     case CEPH_OSD_OP_TRUNCATE:
-      out << " " << op.op.offset;
+      out << " " << op.op.extent.offset;
       break;
     case CEPH_OSD_OP_SETTRUNC:
     case CEPH_OSD_OP_MASKTRUNC:
     case CEPH_OSD_OP_TRIMTRUNC:
-      out << " " << op.op.truncate_seq << "@" << op.op.truncate_size;      
+      out << " " << op.op.trunc.truncate_seq << "@" << op.op.trunc.truncate_size;
       break;
     default:
-      out << " " << op.op.offset << "~" << op.op.length;
+      out << " " << op.op.extent.offset << "~" << op.op.extent.length;
     }
   } else if (ceph_osd_op_type_attr(op.op.op)) {
     // xattr name
-    if (op.op.name_len && op.data.length()) {
+    if (op.op.xattr.name_len && op.data.length()) {
       out << " ";
-      op.data.write(0, op.op.name_len, out);
+      op.data.write(0, op.op.xattr.name_len, out);
     }
-    if (op.op.value_len)
-      out << " (" << op.op.value_len << ")";
+    if (op.op.xattr.value_len)
+      out << " (" << op.op.xattr.value_len << ")";
   } else if (ceph_osd_op_type_exec(op.op.op)) {
     // class.method
-    if (op.op.class_len && op.data.length()) {
+    if (op.op.cls.class_len && op.data.length()) {
       out << " ";
-      op.data.write(0, op.op.class_len, out);
+      op.data.write(0, op.op.cls.class_len, out);
       out << ".";
-      op.data.write(op.op.class_len, op.op.method_len, out);
+      op.data.write(op.op.cls.class_len, op.op.cls.method_len, out);
     }
   }
   return out;

diff --git a/src/osdc/Filer.h b/src/osdc/Filer.h
index 3cbcdcce8e5ee2a4c8afb5438f6117ee5392e0df..08b64dc3e031d9eda800e2de5da8a358b6179aa8 100644 (file)
--- a/src/osdc/Filer.h
+++ b/src/osdc/Filer.h
@@ -152,8 +152,8 @@ class Filer {
     if (extents.size() == 1) {
       vector<OSDOp> ops(1);
       ops[0].op.op = CEPH_OSD_OP_TRIMTRUNC;
-      ops[0].op.truncate_seq = truncate_seq;
-      ops[0].op.truncate_size = extents[0].offset;
+      ops[0].op.trunc.truncate_seq = truncate_seq;
+      ops[0].op.trunc.truncate_size = extents[0].offset;
       objecter->_modify(extents[0].oid, extents[0].layout, ops, mtime, snapc, flags, onack, oncommit);
     } else {
       C_Gather *gack = 0, *gcom = 0;
@@ -164,8 +164,8 @@ class Filer {
       for (vector<ObjectExtent>::iterator p = extents.begin(); p != extents.end(); p++) {
        vector<OSDOp> ops(1);
        ops[0].op.op = CEPH_OSD_OP_TRIMTRUNC;
-       ops[0].op.truncate_size = p->offset;
-       ops[0].op.truncate_seq = truncate_seq;
+       ops[0].op.trunc.truncate_size = p->offset;
+       ops[0].op.trunc.truncate_seq = truncate_seq;
        objecter->_modify(extents[0].oid, p->layout, ops, mtime, snapc, flags,
                          gack ? gack->new_sub():0,
                          gcom ? gcom->new_sub():0);

diff --git a/src/osdc/Objecter.h b/src/osdc/Objecter.h
index 80d55a6eef46fcca0b3c058d47e7c1ae4a659d74..68ca690b801e3d1ba4e0adcbc66a8a685f4dbe22 100644 (file)
--- a/src/osdc/Objecter.h
+++ b/src/osdc/Objecter.h
@@ -58,16 +58,16 @@ struct ObjectOperation {
     int s = ops.size();
     ops.resize(s+1);
     ops[s].op.op = op;
-    ops[s].op.offset = off;
-    ops[s].op.length = len;
+    ops[s].op.extent.offset = off;
+    ops[s].op.extent.length = len;
     ops[s].data.claim_append(bl);
   }
   void add_xattr(int op, const char *name, const bufferlist& data) {
     int s = ops.size();
     ops.resize(s+1);
     ops[s].op.op = op;
-    ops[s].op.name_len = (name ? strlen(name) : 0);
-    ops[s].op.value_len = data.length();
+    ops[s].op.xattr.name_len = (name ? strlen(name) : 0);
+    ops[s].op.xattr.value_len = data.length();
     if (name)
       ops[s].data.append(name);
     ops[s].data.append(data);
@@ -76,19 +76,19 @@ struct ObjectOperation {
     int s = ops.size();
     ops.resize(s+1);
     ops[s].op.op = op;
-    ops[s].op.class_len = strlen(cname);
-    ops[s].op.method_len = strlen(method);
-    ops[s].op.indata_len = indata.length();
-    ops[s].data.append(cname, ops[s].op.class_len);
-    ops[s].data.append(method, ops[s].op.method_len);
+    ops[s].op.cls.class_len = strlen(cname);
+    ops[s].op.cls.method_len = strlen(method);
+    ops[s].op.cls.indata_len = indata.length();
+    ops[s].data.append(cname, ops[s].op.cls.class_len);
+    ops[s].data.append(method, ops[s].op.cls.method_len);
     ops[s].data.append(indata);
   }
   void add_pgls(int op, __u64 count, __u64 cookie) {
     int s = ops.size();
     ops.resize(s+1);
     ops[s].op.op = op;
-    ops[s].op.count = count;
-    ops[s].op.pgls_cookie = cookie;
+    ops[s].op.pgls.count = count;
+    ops[s].op.pgls.cookie = cookie;
   }
 
   // ------
@@ -464,8 +464,8 @@ private:
             Context *onfinish) {
     vector<OSDOp> ops(1);
     ops[0].op.op = CEPH_OSD_OP_READ;
-    ops[0].op.offset = off;
-    ops[0].op.length = len;
+    ops[0].op.extent.offset = off;
+    ops[0].op.extent.length = len;
     Op *o = new Op(oid, ol, ops, flags, onfinish, 0);
     o->snapid = snap;
     o->outbl = pbl;
@@ -477,8 +477,8 @@ private:
             Context *onfinish) {
     vector<OSDOp> ops(1);
     ops[0].op.op = CEPH_OSD_OP_GETXATTR;
-    ops[0].op.name_len = (name ? strlen(name) : 0);
-    ops[0].op.value_len = 0;
+    ops[0].op.xattr.name_len = (name ? strlen(name) : 0);
+    ops[0].op.xattr.value_len = 0;
     if (name)
       ops[0].data.append(name);
     Op *o = new Op(oid, ol, ops, flags, onfinish, 0);
@@ -521,8 +521,8 @@ private:
               Context *onack, Context *oncommit) {
     vector<OSDOp> ops(1);
     ops[0].op.op = CEPH_OSD_OP_WRITE;
-    ops[0].op.offset = off;
-    ops[0].op.length = len;
+    ops[0].op.extent.offset = off;
+    ops[0].op.extent.length = len;
     ops[0].data = bl;
     Op *o = new Op(oid, ol, ops, flags, onack, oncommit);
     o->mtime = mtime;
@@ -534,8 +534,8 @@ private:
                   Context *onack, Context *oncommit) {
     vector<OSDOp> ops(1);
     ops[0].op.op = CEPH_OSD_OP_WRITEFULL;
-    ops[0].op.offset = 0;
-    ops[0].op.length = bl.length();
+    ops[0].op.extent.offset = 0;
+    ops[0].op.extent.length = bl.length();
     ops[0].data = bl;
     Op *o = new Op(oid, ol, ops, flags, onack, oncommit);
     o->mtime = mtime;
@@ -547,8 +547,8 @@ private:
              Context *onack, Context *oncommit) {
     vector<OSDOp> ops(1);
     ops[0].op.op = CEPH_OSD_OP_ZERO;
-    ops[0].op.offset = off;
-    ops[0].op.length = len;
+    ops[0].op.extent.offset = off;
+    ops[0].op.extent.length = len;
     Op *o = new Op(oid, ol, ops, flags, onack, oncommit);
     o->mtime = mtime;
     o->snapc = snapc;
@@ -592,8 +592,8 @@ private:
               Context *onack, Context *oncommit) {
     vector<OSDOp> ops(1);
     ops[0].op.op = CEPH_OSD_OP_SETXATTR;
-    ops[0].op.name_len = (name ? strlen(name) : 0);
-    ops[0].op.value_len = bl.length();
+    ops[0].op.xattr.name_len = (name ? strlen(name) : 0);
+    ops[0].op.xattr.value_len = bl.length();
     if (name)
       ops[0].data.append(name);
    ops[0].data.append(bl);