[ceph.git] / ceph / src / objclass / class_api.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab

#include "common/config.h"
#include "common/debug.h"

#include "objclass/objclass.h"
#include "osd/PrimaryLogPG.h"
#include "osd/osd_types.h"

#include "osd/ClassHandler.h"

#include "auth/Crypto.h"
#include "common/armor.h"

static constexpr int dout_subsys = ceph_subsys_objclass;

static ClassHandler *ch;

void cls_initialize(ClassHandler *h)
{
  ch = h;
}

void cls_finalize()
{
  ch = NULL;
}


void *cls_alloc(size_t size)
{
  return malloc(size);
}

void cls_free(void *p)
{
  free(p);
}

int cls_register(const char *name, cls_handle_t *handle)
{
  ClassHandler::ClassData *cls = ch->register_class(name);
  *handle = (cls_handle_t)cls;
  return (cls != NULL);
}

int cls_unregister(cls_handle_t handle)
{
  ClassHandler::ClassData *cls = (ClassHandler::ClassData *)handle;
  ch->unregister_class(cls);
  return 1;
}

int cls_register_method(cls_handle_t hclass, const char *method,
                        int flags,
                        cls_method_call_t class_call, cls_method_handle_t *handle)
{
  if (!(flags & (CLS_METHOD_RD | CLS_METHOD_WR)))
    return -EINVAL;
  ClassHandler::ClassData *cls = (ClassHandler::ClassData *)hclass;
  cls_method_handle_t hmethod =(cls_method_handle_t)cls->register_method(method, flags, class_call);
  if (handle)
    *handle = hmethod;
  return (hmethod != NULL);
}

int cls_register_cxx_method(cls_handle_t hclass, const char *method,
                            int flags,
			    cls_method_cxx_call_t class_call, cls_method_handle_t *handle)
{
  ClassHandler::ClassData *cls = (ClassHandler::ClassData *)hclass;
  cls_method_handle_t hmethod = (cls_method_handle_t)cls->register_cxx_method(method, flags, class_call);
  if (handle)
    *handle = hmethod;
  return (hmethod != NULL);
}

int cls_unregister_method(cls_method_handle_t handle)
{
  ClassHandler::ClassMethod *method = (ClassHandler::ClassMethod *)handle;
  method->unregister();
  return 1;
}

int cls_register_cxx_filter(cls_handle_t hclass,
                            const std::string &filter_name,
                            cls_cxx_filter_factory_t fn,
                            cls_filter_handle_t *handle)
{
  ClassHandler::ClassData *cls = (ClassHandler::ClassData *)hclass;
  cls_filter_handle_t hfilter = (cls_filter_handle_t)cls->register_cxx_filter(filter_name, fn);
  if (handle) {
    *handle = hfilter;
  }
  return (hfilter != NULL);
}

void cls_unregister_filter(cls_filter_handle_t handle)
{
  ClassHandler::ClassFilter *filter = (ClassHandler::ClassFilter *)handle;
  filter->unregister();
}

int cls_call(cls_method_context_t hctx, const char *cls, const char *method,
                                 char *indata, int datalen,
                                 char **outdata, int *outdatalen)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  bufferlist idata;
  vector<OSDOp> nops(1);
  OSDOp& op = nops[0];
  int r;

  op.op.op = CEPH_OSD_OP_CALL;
  op.op.cls.class_len = strlen(cls);
  op.op.cls.method_len = strlen(method);
  op.op.cls.indata_len = datalen;
  op.indata.append(cls, op.op.cls.class_len);
  op.indata.append(method, op.op.cls.method_len);
  op.indata.append(indata, datalen);
  r = (*pctx)->pg->do_osd_ops(*pctx, nops);
  if (r < 0)
    return r;

  *outdata = (char *)malloc(op.outdata.length());
  if (!*outdata)
    return -ENOMEM;
  memcpy(*outdata, op.outdata.c_str(), op.outdata.length());
  *outdatalen = op.outdata.length();

  return r;
}

int cls_getxattr(cls_method_context_t hctx, const char *name,
                                 char **outdata, int *outdatalen)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  bufferlist name_data;
  vector<OSDOp> nops(1);
  OSDOp& op = nops[0];
  int r;

  op.op.op = CEPH_OSD_OP_GETXATTR;
  op.indata.append(name);
  op.op.xattr.name_len = strlen(name);
  r = (*pctx)->pg->do_osd_ops(*pctx, nops);
  if (r < 0)
    return r;

  *outdata = (char *)malloc(op.outdata.length());
  if (!*outdata)
    return -ENOMEM;
  memcpy(*outdata, op.outdata.c_str(), op.outdata.length());
  *outdatalen = op.outdata.length();

  return r;
}

int cls_setxattr(cls_method_context_t hctx, const char *name,
                                 const char *value, int val_len)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  bufferlist name_data;
  vector<OSDOp> nops(1);
  OSDOp& op = nops[0];
  int r;

  op.op.op = CEPH_OSD_OP_SETXATTR;
  op.indata.append(name);
  op.indata.append(value);
  op.op.xattr.name_len = strlen(name);
  op.op.xattr.value_len = val_len;
  r = (*pctx)->pg->do_osd_ops(*pctx, nops);

  return r;
}

int cls_read(cls_method_context_t hctx, int ofs, int len,
                                 char **outdata, int *outdatalen)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  ops[0].op.op = CEPH_OSD_OP_SYNC_READ;
  ops[0].op.extent.offset = ofs;
  ops[0].op.extent.length = len;
  int r = (*pctx)->pg->do_osd_ops(*pctx, ops);
  if (r < 0)
    return r;

  *outdata = (char *)malloc(ops[0].outdata.length());
  if (!*outdata)
    return -ENOMEM;
  memcpy(*outdata, ops[0].outdata.c_str(), ops[0].outdata.length());
  *outdatalen = ops[0].outdata.length();

  return *outdatalen;
}

int cls_get_request_origin(cls_method_context_t hctx, entity_inst_t *origin)
{
  PrimaryLogPG::OpContext **pctx = static_cast<PrimaryLogPG::OpContext **>(hctx);
  *origin = (*pctx)->op->get_req()->get_orig_source_inst();
  return 0;
}

int cls_cxx_create(cls_method_context_t hctx, bool exclusive)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  ops[0].op.op = CEPH_OSD_OP_CREATE;
  ops[0].op.flags = (exclusive ? CEPH_OSD_OP_FLAG_EXCL : 0);
  return (*pctx)->pg->do_osd_ops(*pctx, ops);
}

int cls_cxx_remove(cls_method_context_t hctx)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  ops[0].op.op = CEPH_OSD_OP_DELETE;
  return (*pctx)->pg->do_osd_ops(*pctx, ops);
}

int cls_cxx_stat(cls_method_context_t hctx, uint64_t *size, time_t *mtime)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  int ret;
  ops[0].op.op = CEPH_OSD_OP_STAT;
  ret = (*pctx)->pg->do_osd_ops(*pctx, ops);
  if (ret < 0)
    return ret;
  bufferlist::iterator iter = ops[0].outdata.begin();
  utime_t ut;
  uint64_t s;
  try {
    ::decode(s, iter);
    ::decode(ut, iter);
  } catch (buffer::error& err) {
    return -EIO;
  }
  if (size)
    *size = s;
  if (mtime)
    *mtime = ut.sec();
  return 0;
}

int cls_cxx_stat2(cls_method_context_t hctx, uint64_t *size, ceph::real_time *mtime)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  int ret;
  ops[0].op.op = CEPH_OSD_OP_STAT;
  ret = (*pctx)->pg->do_osd_ops(*pctx, ops);
  if (ret < 0)
    return ret;
  bufferlist::iterator iter = ops[0].outdata.begin();
  real_time ut;
  uint64_t s;
  try {
    ::decode(s, iter);
    ::decode(ut, iter);
  } catch (buffer::error& err) {
    return -EIO;
  }
  if (size)
    *size = s;
  if (mtime)
    *mtime = ut;
  return 0;
}

int cls_cxx_read(cls_method_context_t hctx, int ofs, int len, bufferlist *outbl)
{
  return cls_cxx_read2(hctx, ofs, len, outbl, 0);
}

int cls_cxx_read2(cls_method_context_t hctx, int ofs, int len,
                  bufferlist *outbl, uint32_t op_flags)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  int ret;
  ops[0].op.op = CEPH_OSD_OP_SYNC_READ;
  ops[0].op.extent.offset = ofs;
  ops[0].op.extent.length = len;
  ops[0].op.flags = op_flags;
  ret = (*pctx)->pg->do_osd_ops(*pctx, ops);
  if (ret < 0)
    return ret;
  outbl->claim(ops[0].outdata);
  return outbl->length();
}

int cls_cxx_write(cls_method_context_t hctx, int ofs, int len, bufferlist *inbl)
{
  return cls_cxx_write2(hctx, ofs, len, inbl, 0);
}

int cls_cxx_write2(cls_method_context_t hctx, int ofs, int len,
                   bufferlist *inbl, uint32_t op_flags)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  ops[0].op.op = CEPH_OSD_OP_WRITE;
  ops[0].op.extent.offset = ofs;
  ops[0].op.extent.length = len;
  ops[0].op.flags = op_flags;
  ops[0].indata = *inbl;
  return (*pctx)->pg->do_osd_ops(*pctx, ops);
}

int cls_cxx_write_full(cls_method_context_t hctx, bufferlist *inbl)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  ops[0].op.op = CEPH_OSD_OP_WRITEFULL;
  ops[0].op.extent.offset = 0;
  ops[0].op.extent.length = inbl->length();
  ops[0].indata = *inbl;
  return (*pctx)->pg->do_osd_ops(*pctx, ops);
}

int cls_cxx_replace(cls_method_context_t hctx, int ofs, int len, bufferlist *inbl)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(2);
  ops[0].op.op = CEPH_OSD_OP_TRUNCATE;
  ops[0].op.extent.offset = 0;
  ops[0].op.extent.length = 0;
  ops[1].op.op = CEPH_OSD_OP_WRITE;
  ops[1].op.extent.offset = ofs;
  ops[1].op.extent.length = len;
  ops[1].indata = *inbl;
  return (*pctx)->pg->do_osd_ops(*pctx, ops);
}

int cls_cxx_getxattr(cls_method_context_t hctx, const char *name,
                     bufferlist *outbl)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  bufferlist name_data;
  vector<OSDOp> nops(1);
  OSDOp& op = nops[0];
  int r;

  op.op.op = CEPH_OSD_OP_GETXATTR;
  op.indata.append(name);
  op.op.xattr.name_len = strlen(name);
  r = (*pctx)->pg->do_osd_ops(*pctx, nops);
  if (r < 0)
    return r;

  outbl->claim(op.outdata);
  return outbl->length();
}

int cls_cxx_getxattrs(cls_method_context_t hctx, map<string, bufferlist> *attrset)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> nops(1);
  OSDOp& op = nops[0];
  int r;

  op.op.op = CEPH_OSD_OP_GETXATTRS;
  r = (*pctx)->pg->do_osd_ops(*pctx, nops);
  if (r < 0)
    return r;

  bufferlist::iterator iter = op.outdata.begin();
  try {
    ::decode(*attrset, iter);
  } catch (buffer::error& err) {
    return -EIO;
  }
  return 0;
}

int cls_cxx_setxattr(cls_method_context_t hctx, const char *name,
                     bufferlist *inbl)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  bufferlist name_data;
  vector<OSDOp> nops(1);
  OSDOp& op = nops[0];
  int r;

  op.op.op = CEPH_OSD_OP_SETXATTR;
  op.indata.append(name);
  op.indata.append(*inbl);
  op.op.xattr.name_len = strlen(name);
  op.op.xattr.value_len = inbl->length();
  r = (*pctx)->pg->do_osd_ops(*pctx, nops);

  return r;
}

int cls_cxx_snap_revert(cls_method_context_t hctx, snapid_t snapid)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  ops[0].op.op = CEPH_OSD_OP_ROLLBACK;
  ops[0].op.snap.snapid = snapid;
  return (*pctx)->pg->do_osd_ops(*pctx, ops);
}

int cls_cxx_map_get_all_vals(cls_method_context_t hctx, map<string, bufferlist>* vals,
                             bool *more)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  OSDOp& op = ops[0];
  int ret;

  string start_after;
  string filter_prefix;
  uint64_t max = (uint64_t)-1;

  ::encode(start_after, op.indata);
  ::encode(max, op.indata);
  ::encode(filter_prefix, op.indata);

  op.op.op = CEPH_OSD_OP_OMAPGETVALS;
  
  ret = (*pctx)->pg->do_osd_ops(*pctx, ops);
  if (ret < 0)
    return ret;

  bufferlist::iterator iter = op.outdata.begin();
  try {
    ::decode(*vals, iter);
    ::decode(*more, iter);
  } catch (buffer::error& err) {
    return -EIO;
  }
  return vals->size();
}

int cls_cxx_map_get_keys(cls_method_context_t hctx, const string &start_obj,
			 uint64_t max_to_get, set<string> *keys,
                         bool *more)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  OSDOp& op = ops[0];
  int ret;

  ::encode(start_obj, op.indata);
  ::encode(max_to_get, op.indata);

  op.op.op = CEPH_OSD_OP_OMAPGETKEYS;

  ret = (*pctx)->pg->do_osd_ops(*pctx, ops);
  if (ret < 0)
    return ret;

  bufferlist::iterator iter = op.outdata.begin();
  try {
    ::decode(*keys, iter);
    ::decode(*more, iter);
  } catch (buffer::error& err) {
    return -EIO;
  }
  return keys->size();
}

int cls_cxx_map_get_vals(cls_method_context_t hctx, const string &start_obj,
			 const string &filter_prefix, uint64_t max_to_get,
			 map<string, bufferlist> *vals, bool *more)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  OSDOp& op = ops[0];
  int ret;

  ::encode(start_obj, op.indata);
  ::encode(max_to_get, op.indata);
  ::encode(filter_prefix, op.indata);

  op.op.op = CEPH_OSD_OP_OMAPGETVALS;
  
  ret = (*pctx)->pg->do_osd_ops(*pctx, ops);
  if (ret < 0)
    return ret;

  bufferlist::iterator iter = op.outdata.begin();
  try {
    ::decode(*vals, iter);
    ::decode(*more, iter);
  } catch (buffer::error& err) {
    return -EIO;
  }
  return vals->size();
}

int cls_cxx_map_read_header(cls_method_context_t hctx, bufferlist *outbl)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  OSDOp& op = ops[0];
  int ret;
  op.op.op = CEPH_OSD_OP_OMAPGETHEADER;
  ret = (*pctx)->pg->do_osd_ops(*pctx, ops);
  if (ret < 0)
    return ret;

  outbl->claim(op.outdata);

  return 0;
}

int cls_cxx_map_get_val(cls_method_context_t hctx, const string &key,
			bufferlist *outbl)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  OSDOp& op = ops[0];
  int ret;

  set<string> k;
  k.insert(key);
  ::encode(k, op.indata);

  op.op.op = CEPH_OSD_OP_OMAPGETVALSBYKEYS;
  ret = (*pctx)->pg->do_osd_ops(*pctx, ops);
  if (ret < 0)
    return ret;

  bufferlist::iterator iter = op.outdata.begin();
  try {
    map<string, bufferlist> m;

    ::decode(m, iter);
    map<string, bufferlist>::iterator iter = m.begin();
    if (iter == m.end())
      return -ENOENT;

    *outbl = iter->second;
  } catch (buffer::error& e) {
    return -EIO;
  }
  return 0;
}

int cls_cxx_map_set_val(cls_method_context_t hctx, const string &key,
			bufferlist *inbl)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  OSDOp& op = ops[0];
  bufferlist& update_bl = op.indata;
  map<string, bufferlist> m;
  m[key] = *inbl;
  ::encode(m, update_bl);

  op.op.op = CEPH_OSD_OP_OMAPSETVALS;

  return (*pctx)->pg->do_osd_ops(*pctx, ops);
}

int cls_cxx_map_set_vals(cls_method_context_t hctx,
			 const std::map<string, bufferlist> *map)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  OSDOp& op = ops[0];
  bufferlist& update_bl = op.indata;
  ::encode(*map, update_bl);

  op.op.op = CEPH_OSD_OP_OMAPSETVALS;

  return (*pctx)->pg->do_osd_ops(*pctx, ops);
}

int cls_cxx_map_clear(cls_method_context_t hctx)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  OSDOp& op = ops[0];

  op.op.op = CEPH_OSD_OP_OMAPCLEAR;

  return (*pctx)->pg->do_osd_ops(*pctx, ops);
}

int cls_cxx_map_write_header(cls_method_context_t hctx, bufferlist *inbl)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  OSDOp& op = ops[0];
  op.indata.claim(*inbl);

  op.op.op = CEPH_OSD_OP_OMAPSETHEADER;

  return (*pctx)->pg->do_osd_ops(*pctx, ops);
}

int cls_cxx_map_remove_key(cls_method_context_t hctx, const string &key)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> ops(1);
  OSDOp& op = ops[0];
  bufferlist& update_bl = op.indata;
  set<string> to_rm;
  to_rm.insert(key);

  ::encode(to_rm, update_bl);

  op.op.op = CEPH_OSD_OP_OMAPRMKEYS;

  return (*pctx)->pg->do_osd_ops(*pctx, ops);
}

int cls_cxx_list_watchers(cls_method_context_t hctx,
			  obj_list_watch_response_t *watchers)
{
  PrimaryLogPG::OpContext **pctx = (PrimaryLogPG::OpContext **)hctx;
  vector<OSDOp> nops(1);
  OSDOp& op = nops[0];
  int r;

  op.op.op = CEPH_OSD_OP_LIST_WATCHERS;
  r = (*pctx)->pg->do_osd_ops(*pctx, nops);
  if (r < 0)
    return r;

  bufferlist::iterator iter = op.outdata.begin();
  try {
    ::decode(*watchers, iter);
  } catch (buffer::error& err) {
    return -EIO;
  }
  return 0;
}

int cls_gen_random_bytes(char *buf, int size)
{
  return get_random_bytes(buf, size);
}

int cls_gen_rand_base64(char *dest, int size) /* size should be the required string size + 1 */
{
  char buf[size];
  char tmp_dest[size + 4]; /* so that there's space for the extra '=' characters, and some */
  int ret;

  ret = cls_gen_random_bytes(buf, sizeof(buf));
  if (ret < 0) {
    lgeneric_derr(ch->cct) << "cannot get random bytes: " << ret << dendl;
    return -1;
  }

  ret = ceph_armor(tmp_dest, &tmp_dest[sizeof(tmp_dest)],
		   (const char *)buf, ((const char *)buf) + ((size - 1) * 3 + 4 - 1) / 4);
  if (ret < 0) {
    lgeneric_derr(ch->cct) << "ceph_armor failed" << dendl;
    return -1;
  }
  tmp_dest[ret] = '\0';
  memcpy(dest, tmp_dest, size);
  dest[size-1] = '\0';

  return 0;
}

uint64_t cls_current_version(cls_method_context_t hctx)
{
  PrimaryLogPG::OpContext *ctx = *(PrimaryLogPG::OpContext **)hctx;

  return ctx->pg->info.last_user_version;
}


int cls_current_subop_num(cls_method_context_t hctx)
{
  PrimaryLogPG::OpContext *ctx = *(PrimaryLogPG::OpContext **)hctx;

  return ctx->current_osd_subop_num;
}

uint64_t cls_get_features(cls_method_context_t hctx)
{
  PrimaryLogPG::OpContext *ctx = *(PrimaryLogPG::OpContext **)hctx;
  return ctx->pg->get_osdmap()->get_up_osd_features();
}

uint64_t cls_get_client_features(cls_method_context_t hctx)
{
  PrimaryLogPG::OpContext *ctx = *(PrimaryLogPG::OpContext **)hctx;
  return ctx->op->get_req()->get_connection()->get_features();
}

void cls_cxx_subop_version(cls_method_context_t hctx, string *s)
{
  if (!s)
    return;

  char buf[32];
  uint64_t ver = cls_current_version(hctx);
  int subop_num = cls_current_subop_num(hctx);
  snprintf(buf, sizeof(buf), "%lld.%d", (long long)ver, subop_num);

  *s = buf;
}

int cls_log(int level, const char *format, ...)
{
   int size = 256;
   va_list ap;
   while (1) {
     char buf[size];
     va_start(ap, format);
     int n = vsnprintf(buf, size, format, ap);
     va_end(ap);
#define MAX_SIZE 8196
     if ((n > -1 && n < size) || size > MAX_SIZE) {
       ldout(ch->cct, level) << buf << dendl;
       return n;
     }
     size *= 2;
   }
}
Commit	Line	Data
7c673cae FG	1	// -- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t --
	2	// vim: ts=8 sw=2 smarttab
	3
	4	#include "common/config.h"
	5	#include "common/debug.h"
	6
	7	#include "objclass/objclass.h"
	8	#include "osd/PrimaryLogPG.h"
	9	#include "osd/osd_types.h"
	10
	11	#include "osd/ClassHandler.h"
	12
	13	#include "auth/Crypto.h"
	14	#include "common/armor.h"
	15
	16	static constexpr int dout_subsys = ceph_subsys_objclass;
	17
	18	static ClassHandler *ch;
	19
	20	void cls_initialize(ClassHandler *h)
	21	{
	22	ch = h;
	23	}
	24
	25	void cls_finalize()
	26	{
	27	ch = NULL;
	28	}
	29
	30
	31	void *cls_alloc(size_t size)
	32	{
	33	return malloc(size);
	34	}
	35
	36	void cls_free(void *p)
	37	{
	38	free(p);
	39	}
	40
	41	int cls_register(const char name, cls_handle_t handle)
	42	{
	43	ClassHandler::ClassData *cls = ch->register_class(name);
	44	*handle = (cls_handle_t)cls;
	45	return (cls != NULL);
	46	}
	47
	48	int cls_unregister(cls_handle_t handle)
	49	{
	50	ClassHandler::ClassData cls = (ClassHandler::ClassData )handle;
	51	ch->unregister_class(cls);
	52	return 1;
	53	}
	54
	55	int cls_register_method(cls_handle_t hclass, const char *method,
	56	int flags,
	57	cls_method_call_t class_call, cls_method_handle_t *handle)
	58	{
	59	if (!(flags & (CLS_METHOD_RD \| CLS_METHOD_WR)))
	60	return -EINVAL;
	61	ClassHandler::ClassData cls = (ClassHandler::ClassData )hclass;
	62	cls_method_handle_t hmethod =(cls_method_handle_t)cls->register_method(method, flags, class_call);
	63	if (handle)
	64	*handle = hmethod;
65	return (hmethod != NULL);
66	}
67
68	int cls_register_cxx_method(cls_handle_t hclass, const char *method,
69	int flags,
70	cls_method_cxx_call_t class_call, cls_method_handle_t *handle)
71	{
72	ClassHandler::ClassData cls = (ClassHandler::ClassData )hclass;
73	cls_method_handle_t hmethod = (cls_method_handle_t)cls->register_cxx_method(method, flags, class_call);
74	if (handle)
75	*handle = hmethod;
76	return (hmethod != NULL);
77	}
78
79	int cls_unregister_method(cls_method_handle_t handle)
80	{
81	ClassHandler::ClassMethod method = (ClassHandler::ClassMethod )handle;
82	method->unregister();
83	return 1;
84	}
85
86	int cls_register_cxx_filter(cls_handle_t hclass,
87	const std::string &filter_name,
88	cls_cxx_filter_factory_t fn,
89	cls_filter_handle_t *handle)
90	{
91	ClassHandler::ClassData cls = (ClassHandler::ClassData )hclass;
92	cls_filter_handle_t hfilter = (cls_filter_handle_t)cls->register_cxx_filter(filter_name, fn);
93	if (handle) {
94	*handle = hfilter;
95	}
96	return (hfilter != NULL);
97	}
98
99	void cls_unregister_filter(cls_filter_handle_t handle)
100	{
101	ClassHandler::ClassFilter filter = (ClassHandler::ClassFilter )handle;
102	filter->unregister();
103	}
104
105	int cls_call(cls_method_context_t hctx, const char cls, const char method,
106	char *indata, int datalen,
107	char *outdata, int outdatalen)
108	{
109	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
110	bufferlist idata;
111	vector<OSDOp> nops(1);
112	OSDOp& op = nops[0];
113	int r;
114
115	op.op.op = CEPH_OSD_OP_CALL;
116	op.op.cls.class_len = strlen(cls);
117	op.op.cls.method_len = strlen(method);
118	op.op.cls.indata_len = datalen;
119	op.indata.append(cls, op.op.cls.class_len);
120	op.indata.append(method, op.op.cls.method_len);
121	op.indata.append(indata, datalen);
122	r = (pctx)->pg->do_osd_ops(pctx, nops);
123	if (r < 0)
124	return r;
125
126	outdata = (char )malloc(op.outdata.length());
127	if (!*outdata)
128	return -ENOMEM;
129	memcpy(*outdata, op.outdata.c_str(), op.outdata.length());
130	*outdatalen = op.outdata.length();
131
132	return r;
133	}
134
135	int cls_getxattr(cls_method_context_t hctx, const char *name,
136	char *outdata, int outdatalen)
137	{
138	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
139	bufferlist name_data;
140	vector<OSDOp> nops(1);
141	OSDOp& op = nops[0];
142	int r;
143
144	op.op.op = CEPH_OSD_OP_GETXATTR;
145	op.indata.append(name);
146	op.op.xattr.name_len = strlen(name);
147	r = (pctx)->pg->do_osd_ops(pctx, nops);
148	if (r < 0)
149	return r;
150
151	outdata = (char )malloc(op.outdata.length());
152	if (!*outdata)
153	return -ENOMEM;
154	memcpy(*outdata, op.outdata.c_str(), op.outdata.length());
155	*outdatalen = op.outdata.length();
156
157	return r;
158	}
159
160	int cls_setxattr(cls_method_context_t hctx, const char *name,
161	const char *value, int val_len)
162	{
163	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
164	bufferlist name_data;
165	vector<OSDOp> nops(1);
166	OSDOp& op = nops[0];
167	int r;
168
169	op.op.op = CEPH_OSD_OP_SETXATTR;
170	op.indata.append(name);
171	op.indata.append(value);
172	op.op.xattr.name_len = strlen(name);
173	op.op.xattr.value_len = val_len;
174	r = (pctx)->pg->do_osd_ops(pctx, nops);
175
176	return r;
177	}
178
179	int cls_read(cls_method_context_t hctx, int ofs, int len,
180	char *outdata, int outdatalen)
181	{
182	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
183	vector<OSDOp> ops(1);
184	ops[0].op.op = CEPH_OSD_OP_SYNC_READ;
185	ops[0].op.extent.offset = ofs;
186	ops[0].op.extent.length = len;
187	int r = (pctx)->pg->do_osd_ops(pctx, ops);
188	if (r < 0)
189	return r;
190
191	outdata = (char )malloc(ops[0].outdata.length());
192	if (!*outdata)
193	return -ENOMEM;
194	memcpy(*outdata, ops[0].outdata.c_str(), ops[0].outdata.length());
195	*outdatalen = ops[0].outdata.length();
196
197	return *outdatalen;
198	}
199
200	int cls_get_request_origin(cls_method_context_t hctx, entity_inst_t *origin)
201	{
202	PrimaryLogPG::OpContext pctx = static_cast<PrimaryLogPG::OpContext >(hctx);
203	origin = (pctx)->op->get_req()->get_orig_source_inst();
204	return 0;
205	}
206
207	int cls_cxx_create(cls_method_context_t hctx, bool exclusive)
208	{
209	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
210	vector<OSDOp> ops(1);
211	ops[0].op.op = CEPH_OSD_OP_CREATE;
212	ops[0].op.flags = (exclusive ? CEPH_OSD_OP_FLAG_EXCL : 0);
213	return (pctx)->pg->do_osd_ops(pctx, ops);
214	}
215
216	int cls_cxx_remove(cls_method_context_t hctx)
217	{
218	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
219	vector<OSDOp> ops(1);
220	ops[0].op.op = CEPH_OSD_OP_DELETE;
221	return (pctx)->pg->do_osd_ops(pctx, ops);
222	}
223
224	int cls_cxx_stat(cls_method_context_t hctx, uint64_t size, time_t mtime)
225	{
226	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
227	vector<OSDOp> ops(1);
228	int ret;
229	ops[0].op.op = CEPH_OSD_OP_STAT;
230	ret = (pctx)->pg->do_osd_ops(pctx, ops);
231	if (ret < 0)
232	return ret;
233	bufferlist::iterator iter = ops[0].outdata.begin();
234	utime_t ut;
235	uint64_t s;
236	try {
237	::decode(s, iter);
238	::decode(ut, iter);
239	} catch (buffer::error& err) {
240	return -EIO;
241	}
242	if (size)
243	*size = s;
244	if (mtime)
245	*mtime = ut.sec();
246	return 0;
247	}
248
249	int cls_cxx_stat2(cls_method_context_t hctx, uint64_t size, ceph::real_time mtime)
250	{
251	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
252	vector<OSDOp> ops(1);
253	int ret;
254	ops[0].op.op = CEPH_OSD_OP_STAT;
255	ret = (pctx)->pg->do_osd_ops(pctx, ops);
256	if (ret < 0)
257	return ret;
258	bufferlist::iterator iter = ops[0].outdata.begin();
259	real_time ut;
260	uint64_t s;
261	try {
262	::decode(s, iter);
263	::decode(ut, iter);
264	} catch (buffer::error& err) {
265	return -EIO;
266	}
267	if (size)
268	*size = s;
269	if (mtime)
270	*mtime = ut;
271	return 0;
272	}
273
274	int cls_cxx_read(cls_method_context_t hctx, int ofs, int len, bufferlist *outbl)
275	{
276	return cls_cxx_read2(hctx, ofs, len, outbl, 0);
277	}
278
279	int cls_cxx_read2(cls_method_context_t hctx, int ofs, int len,
280	bufferlist *outbl, uint32_t op_flags)
281	{
282	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
283	vector<OSDOp> ops(1);
284	int ret;
285	ops[0].op.op = CEPH_OSD_OP_SYNC_READ;
286	ops[0].op.extent.offset = ofs;
287	ops[0].op.extent.length = len;
288	ops[0].op.flags = op_flags;
289	ret = (pctx)->pg->do_osd_ops(pctx, ops);
290	if (ret < 0)
291	return ret;
292	outbl->claim(ops[0].outdata);
293	return outbl->length();
294	}
295
296	int cls_cxx_write(cls_method_context_t hctx, int ofs, int len, bufferlist *inbl)
297	{
298	return cls_cxx_write2(hctx, ofs, len, inbl, 0);
299	}
300
301	int cls_cxx_write2(cls_method_context_t hctx, int ofs, int len,
302	bufferlist *inbl, uint32_t op_flags)
303	{
304	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
305	vector<OSDOp> ops(1);
306	ops[0].op.op = CEPH_OSD_OP_WRITE;
307	ops[0].op.extent.offset = ofs;
308	ops[0].op.extent.length = len;
309	ops[0].op.flags = op_flags;
310	ops[0].indata = *inbl;
311	return (pctx)->pg->do_osd_ops(pctx, ops);
312	}
313
314	int cls_cxx_write_full(cls_method_context_t hctx, bufferlist *inbl)
315	{
316	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
317	vector<OSDOp> ops(1);
318	ops[0].op.op = CEPH_OSD_OP_WRITEFULL;
319	ops[0].op.extent.offset = 0;
320	ops[0].op.extent.length = inbl->length();
321	ops[0].indata = *inbl;
322	return (pctx)->pg->do_osd_ops(pctx, ops);
323	}
324
325	int cls_cxx_replace(cls_method_context_t hctx, int ofs, int len, bufferlist *inbl)
326	{
327	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
328	vector<OSDOp> ops(2);
329	ops[0].op.op = CEPH_OSD_OP_TRUNCATE;
330	ops[0].op.extent.offset = 0;
331	ops[0].op.extent.length = 0;
332	ops[1].op.op = CEPH_OSD_OP_WRITE;
333	ops[1].op.extent.offset = ofs;
334	ops[1].op.extent.length = len;
335	ops[1].indata = *inbl;
336	return (pctx)->pg->do_osd_ops(pctx, ops);
337	}
338
339	int cls_cxx_getxattr(cls_method_context_t hctx, const char *name,
340	bufferlist *outbl)
341	{
342	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
343	bufferlist name_data;
344	vector<OSDOp> nops(1);
345	OSDOp& op = nops[0];
346	int r;
347
348	op.op.op = CEPH_OSD_OP_GETXATTR;
349	op.indata.append(name);
350	op.op.xattr.name_len = strlen(name);
351	r = (pctx)->pg->do_osd_ops(pctx, nops);
352	if (r < 0)
353	return r;
354
355	outbl->claim(op.outdata);
356	return outbl->length();
357	}
358
359	int cls_cxx_getxattrs(cls_method_context_t hctx, map<string, bufferlist> *attrset)
360	{
361	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
362	vector<OSDOp> nops(1);
363	OSDOp& op = nops[0];
364	int r;
365
366	op.op.op = CEPH_OSD_OP_GETXATTRS;
367	r = (pctx)->pg->do_osd_ops(pctx, nops);
368	if (r < 0)
369	return r;
370
371	bufferlist::iterator iter = op.outdata.begin();
372	try {
373	::decode(*attrset, iter);
374	} catch (buffer::error& err) {
375	return -EIO;
376	}
377	return 0;
378	}
379
380	int cls_cxx_setxattr(cls_method_context_t hctx, const char *name,
381	bufferlist *inbl)
382	{
383	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
384	bufferlist name_data;
385	vector<OSDOp> nops(1);
386	OSDOp& op = nops[0];
387	int r;
388
389	op.op.op = CEPH_OSD_OP_SETXATTR;
390	op.indata.append(name);
391	op.indata.append(*inbl);
392	op.op.xattr.name_len = strlen(name);
393	op.op.xattr.value_len = inbl->length();
394	r = (pctx)->pg->do_osd_ops(pctx, nops);
395
396	return r;
397	}
398
399	int cls_cxx_snap_revert(cls_method_context_t hctx, snapid_t snapid)
400	{
401	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
402	vector<OSDOp> ops(1);
403	ops[0].op.op = CEPH_OSD_OP_ROLLBACK;
404	ops[0].op.snap.snapid = snapid;
405	return (pctx)->pg->do_osd_ops(pctx, ops);
406	}
407
c07f9fc5 FG	408	int cls_cxx_map_get_all_vals(cls_method_context_t hctx, map<string, bufferlist>* vals,
c07f9fc5 FG	409	bool *more)
7c673cae FG	410	{
	411	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
	412	vector<OSDOp> ops(1);
	413	OSDOp& op = ops[0];
	414	int ret;
	415
	416	string start_after;
	417	string filter_prefix;
	418	uint64_t max = (uint64_t)-1;
	419
	420	::encode(start_after, op.indata);
	421	::encode(max, op.indata);
	422	::encode(filter_prefix, op.indata);
	423
	424	op.op.op = CEPH_OSD_OP_OMAPGETVALS;
	425
	426	ret = (pctx)->pg->do_osd_ops(pctx, ops);
	427	if (ret < 0)
	428	return ret;
	429
	430	bufferlist::iterator iter = op.outdata.begin();
	431	try {
	432	::decode(*vals, iter);
c07f9fc5	433	::decode(*more, iter);
7c673cae FG	434	} catch (buffer::error& err) {
	435	return -EIO;
	436	}
	437	return vals->size();
	438	}
	439
	440	int cls_cxx_map_get_keys(cls_method_context_t hctx, const string &start_obj,
c07f9fc5 FG	441	uint64_t max_to_get, set<string> *keys,
c07f9fc5 FG	442	bool *more)
7c673cae FG	443	{
	444	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
	445	vector<OSDOp> ops(1);
	446	OSDOp& op = ops[0];
	447	int ret;
	448
	449	::encode(start_obj, op.indata);
	450	::encode(max_to_get, op.indata);
	451
	452	op.op.op = CEPH_OSD_OP_OMAPGETKEYS;
	453
	454	ret = (pctx)->pg->do_osd_ops(pctx, ops);
	455	if (ret < 0)
	456	return ret;
	457
	458	bufferlist::iterator iter = op.outdata.begin();
	459	try {
	460	::decode(*keys, iter);
c07f9fc5	461	::decode(*more, iter);
7c673cae FG	462	} catch (buffer::error& err) {
	463	return -EIO;
	464	}
	465	return keys->size();
	466	}
	467
	468	int cls_cxx_map_get_vals(cls_method_context_t hctx, const string &start_obj,
	469	const string &filter_prefix, uint64_t max_to_get,
c07f9fc5	470	map<string, bufferlist> vals, bool more)
7c673cae FG	471	{
	472	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
	473	vector<OSDOp> ops(1);
	474	OSDOp& op = ops[0];
	475	int ret;
	476
	477	::encode(start_obj, op.indata);
	478	::encode(max_to_get, op.indata);
	479	::encode(filter_prefix, op.indata);
	480
	481	op.op.op = CEPH_OSD_OP_OMAPGETVALS;
	482
	483	ret = (pctx)->pg->do_osd_ops(pctx, ops);
	484	if (ret < 0)
	485	return ret;
	486
	487	bufferlist::iterator iter = op.outdata.begin();
	488	try {
	489	::decode(*vals, iter);
c07f9fc5	490	::decode(*more, iter);
7c673cae FG	491	} catch (buffer::error& err) {
	492	return -EIO;
	493	}
	494	return vals->size();
	495	}
	496
	497	int cls_cxx_map_read_header(cls_method_context_t hctx, bufferlist *outbl)
	498	{
	499	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
	500	vector<OSDOp> ops(1);
	501	OSDOp& op = ops[0];
	502	int ret;
	503	op.op.op = CEPH_OSD_OP_OMAPGETHEADER;
	504	ret = (pctx)->pg->do_osd_ops(pctx, ops);
	505	if (ret < 0)
	506	return ret;
	507
	508	outbl->claim(op.outdata);
	509
	510	return 0;
	511	}
	512
	513	int cls_cxx_map_get_val(cls_method_context_t hctx, const string &key,
	514	bufferlist *outbl)
	515	{
	516	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
	517	vector<OSDOp> ops(1);
	518	OSDOp& op = ops[0];
	519	int ret;
	520
	521	set<string> k;
	522	k.insert(key);
	523	::encode(k, op.indata);
	524
	525	op.op.op = CEPH_OSD_OP_OMAPGETVALSBYKEYS;
	526	ret = (pctx)->pg->do_osd_ops(pctx, ops);
	527	if (ret < 0)
	528	return ret;
	529
	530	bufferlist::iterator iter = op.outdata.begin();
	531	try {
	532	map<string, bufferlist> m;
	533
	534	::decode(m, iter);
	535	map<string, bufferlist>::iterator iter = m.begin();
	536	if (iter == m.end())
	537	return -ENOENT;
	538
	539	*outbl = iter->second;
	540	} catch (buffer::error& e) {
	541	return -EIO;
	542	}
	543	return 0;
	544	}
	545
	546	int cls_cxx_map_set_val(cls_method_context_t hctx, const string &key,
	547	bufferlist *inbl)
	548	{
	549	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
	550	vector<OSDOp> ops(1);
	551	OSDOp& op = ops[0];
	552	bufferlist& update_bl = op.indata;
	553	map<string, bufferlist> m;
	554	m[key] = *inbl;
555	::encode(m, update_bl);
556
557	op.op.op = CEPH_OSD_OP_OMAPSETVALS;
558
559	return (pctx)->pg->do_osd_ops(pctx, ops);
560	}
561
562	int cls_cxx_map_set_vals(cls_method_context_t hctx,
563	const std::map<string, bufferlist> *map)
564	{
565	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
566	vector<OSDOp> ops(1);
567	OSDOp& op = ops[0];
568	bufferlist& update_bl = op.indata;
569	::encode(*map, update_bl);
570
571	op.op.op = CEPH_OSD_OP_OMAPSETVALS;
572
573	return (pctx)->pg->do_osd_ops(pctx, ops);
574	}
575
576	int cls_cxx_map_clear(cls_method_context_t hctx)
577	{
578	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
579	vector<OSDOp> ops(1);
580	OSDOp& op = ops[0];
581
582	op.op.op = CEPH_OSD_OP_OMAPCLEAR;
583
584	return (pctx)->pg->do_osd_ops(pctx, ops);
585	}
586
587	int cls_cxx_map_write_header(cls_method_context_t hctx, bufferlist *inbl)
588	{
589	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
590	vector<OSDOp> ops(1);
591	OSDOp& op = ops[0];
592	op.indata.claim(*inbl);
593
594	op.op.op = CEPH_OSD_OP_OMAPSETHEADER;
595
596	return (pctx)->pg->do_osd_ops(pctx, ops);
597	}
598
599	int cls_cxx_map_remove_key(cls_method_context_t hctx, const string &key)
600	{
601	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
602	vector<OSDOp> ops(1);
603	OSDOp& op = ops[0];
604	bufferlist& update_bl = op.indata;
605	set<string> to_rm;
606	to_rm.insert(key);
607
608	::encode(to_rm, update_bl);
609
610	op.op.op = CEPH_OSD_OP_OMAPRMKEYS;
611
612	return (pctx)->pg->do_osd_ops(pctx, ops);
613	}
614
615	int cls_cxx_list_watchers(cls_method_context_t hctx,
616	obj_list_watch_response_t *watchers)
617	{
618	PrimaryLogPG::OpContext pctx = (PrimaryLogPG::OpContext )hctx;
619	vector<OSDOp> nops(1);
620	OSDOp& op = nops[0];
621	int r;
622
623	op.op.op = CEPH_OSD_OP_LIST_WATCHERS;
624	r = (pctx)->pg->do_osd_ops(pctx, nops);
625	if (r < 0)
626	return r;
627
628	bufferlist::iterator iter = op.outdata.begin();
629	try {
630	::decode(*watchers, iter);
631	} catch (buffer::error& err) {
632	return -EIO;
633	}
634	return 0;
635	}
636
637	int cls_gen_random_bytes(char *buf, int size)
638	{
639	return get_random_bytes(buf, size);
640	}
641
642	int cls_gen_rand_base64(char dest, int size) / size should be the required string size + 1 */
643	{
644	char buf[size];
645	char tmp_dest[size + 4]; /* so that there's space for the extra '=' characters, and some */
646	int ret;
647
648	ret = cls_gen_random_bytes(buf, sizeof(buf));
649	if (ret < 0) {
650	lgeneric_derr(ch->cct) << "cannot get random bytes: " << ret << dendl;
651	return -1;
652	}
653
654	ret = ceph_armor(tmp_dest, &tmp_dest[sizeof(tmp_dest)],
655	(const char )buf, ((const char )buf) + ((size - 1) * 3 + 4 - 1) / 4);
656	if (ret < 0) {
657	lgeneric_derr(ch->cct) << "ceph_armor failed" << dendl;
658	return -1;
659	}
660	tmp_dest[ret] = '\0';
661	memcpy(dest, tmp_dest, size);
662	dest[size-1] = '\0';
663
664	return 0;
665	}
666
667	uint64_t cls_current_version(cls_method_context_t hctx)
668	{
669	PrimaryLogPG::OpContext ctx = (PrimaryLogPG::OpContext **)hctx;
670
671	return ctx->pg->info.last_user_version;
672	}
673
674
675	int cls_current_subop_num(cls_method_context_t hctx)
676	{
677	PrimaryLogPG::OpContext ctx = (PrimaryLogPG::OpContext **)hctx;
678
679	return ctx->current_osd_subop_num;
680	}
681
682	uint64_t cls_get_features(cls_method_context_t hctx)
683	{
684	PrimaryLogPG::OpContext ctx = (PrimaryLogPG::OpContext **)hctx;
685	return ctx->pg->get_osdmap()->get_up_osd_features();
686	}
687
688	uint64_t cls_get_client_features(cls_method_context_t hctx)
689	{
690	PrimaryLogPG::OpContext ctx = (PrimaryLogPG::OpContext **)hctx;
691	return ctx->op->get_req()->get_connection()->get_features();
692	}
693
694	void cls_cxx_subop_version(cls_method_context_t hctx, string *s)
695	{
696	if (!s)
697	return;
698
699	char buf[32];
700	uint64_t ver = cls_current_version(hctx);
701	int subop_num = cls_current_subop_num(hctx);
702	snprintf(buf, sizeof(buf), "%lld.%d", (long long)ver, subop_num);
703
704	*s = buf;
705	}
706
707	int cls_log(int level, const char *format, ...)
708	{
709	int size = 256;
710	va_list ap;
711	while (1) {
712	char buf[size];
713	va_start(ap, format);
714	int n = vsnprintf(buf, size, format, ap);
715	va_end(ap);
716	#define MAX_SIZE 8196
717	if ((n > -1 && n < size) \|\| size > MAX_SIZE) {
718	ldout(ch->cct, level) << buf << dendl;
719	return n;
720	}
721	size *= 2;
722	}
723	}