common/admin_socket: return int from hook call()

Previously, call() returned a bool.  Return an int instead so we can
wire this up to tell command return values.

The admin socket 'ceph daemon ...' unix domain socket protocol does not
pass a return code, only data, so we cannot pass these errors that way.
We have two choices: make error codes silently succeed when accessed via
asok (so that we get an error string etc), or make them fail without any
specific error code or string.

Unfortunately, there are several cases where an exception was caught and
what() returned as a string, or where error strings are returned.  These
would "blindly" fail if we took the latter approach.

So, for the asok interface, -ENOSYS means a "hard" error that gives the
user no data and makes the 'ceph daemon ...' command return an error code.
Other error codes are interpreted as a success.  This is ONLY for the
asok interface; the tell interface has full fidelity with error codes and
error strings.

Note that this means that 'net new' tell-style commands that we move over
to this handler will also appear to succeed via the 'ceph daemon'
interface when they return error codes.

Signed-off-by: Sage Weil <sage@redhat.com>

diff --git a/src/client/Client.cc b/src/client/Client.cc
index 27e3043ef3a6abe0fa04f6e28be5715ca1292561..6081a96eef808e22dbfd9014facd6a398c5c917e 100644 (file)
--- a/src/client/Client.cc
+++ b/src/client/Client.cc
@@ -138,9 +138,10 @@ Client::CommandHook::CommandHook(Client *client) :
 {
 }
 
-bool Client::CommandHook::call(std::string_view command,
-                              const cmdmap_t& cmdmap,
-                              std::string_view format, bufferlist& out)
+int Client::CommandHook::call(
+  std::string_view command,
+  const cmdmap_t& cmdmap,
+  std::string_view format, bufferlist& out)
 {
   std::unique_ptr<Formatter> f(Formatter::create(format));
   f->open_object_section("result");
@@ -161,7 +162,7 @@ bool Client::CommandHook::call(std::string_view command,
   }
   f->close_section();
   f->flush(out);
-  return true;
+  return 0;
 }
 
 

diff --git a/src/client/Client.h b/src/client/Client.h
index 612c1ec50170ba31743dcb9195bd94a23e38733c..9b634f54b105f72559b0091db85778386216629b 100644 (file)
--- a/src/client/Client.h
+++ b/src/client/Client.h
@@ -265,8 +265,8 @@ public:
   class CommandHook : public AdminSocketHook {
   public:
     explicit CommandHook(Client *client);
-    bool call(std::string_view command, const cmdmap_t& cmdmap,
-              std::string_view format, bufferlist& out) override;
+    int call(std::string_view command, const cmdmap_t& cmdmap,
+            std::string_view format, bufferlist& out) override;
   private:
     Client *m_client;
   };

diff --git a/src/common/admin_socket.cc b/src/common/admin_socket.cc
index 898c8534809a152a58ab092ea830a94264d28ebf..16c811f4e88a6ad5af385c1ad09655015e97017c 100644 (file)
--- a/src/common/admin_socket.cc
+++ b/src/common/admin_socket.cc
@@ -346,25 +346,33 @@ bool AdminSocket::do_accept()
     }
   }
 
-  bool rval;
   bufferlist out;
   std::vector<std::string> cmdvec = { c };
-  rval = execute_command(cmdvec, out);
-  if (rval) {
+  int rval = execute_command(cmdvec, out);
+  // Unfortunately, the asok wire protocol does not let us pass an error code,
+  // and many asok command implementations return helpful error strings.  So,
+  // let's interpret all but -ENOSYS as a "success" so that the user can still
+  // see those messages.  This provides the same behavior as what users saw
+  // pre-octopus; the only drawback is that net new 'tell-style' commands that
+  // return error codes will also be seen as "success" via asok unless/until
+  // we extend the socket protocol.
+  if (rval != -ENOSYS) {
+    rval = 0; // sigh.. fixme someday!
     uint32_t len = htonl(out.length());
     int ret = safe_write(connection_fd, &len, sizeof(len));
     if (ret < 0) {
       lderr(m_cct) << "AdminSocket: error writing response length "
           << cpp_strerror(ret) << dendl;
-      rval = false;
+      rval = -EIO;
     } else {
-      if (out.write_fd(connection_fd) >= 0)
-        rval = true;
+      if (out.write_fd(connection_fd) < 0) {
+       rval = -EIO;
+      }
     }
   }
 
   retry_sys_call(::close, connection_fd);
-  return rval;
+  return rval >= 0;
 }
 
 void AdminSocket::do_tell_queue()
@@ -377,8 +385,7 @@ void AdminSocket::do_tell_queue()
   }
   for (auto& m : q) {
     bufferlist outbl;
-    bool success = execute_command(m->cmd, outbl);
-    int r = success ? 0 : -1;  // FIXME!
+    int r = execute_command(m->cmd, outbl);
     auto reply = new MCommandReply(r, "");
     reply->set_tid(m->get_tid());
     reply->set_data(outbl);
@@ -395,14 +402,14 @@ int AdminSocket::execute_command(const std::vector<std::string>& cmdvec,
   ldout(m_cct,10) << __func__ << " cmdvec='" << cmdvec << "'" << dendl;
   if (!cmdmap_from_json(cmdvec, &cmdmap, errss)) {
     ldout(m_cct, 0) << "AdminSocket: " << errss.str() << dendl;
-    return false;
+    return -EINVAL;
   }
   string prefix;
   try {
     cmd_getval(m_cct, cmdmap, "format", format);
     cmd_getval(m_cct, cmdmap, "prefix", prefix);
   } catch (const bad_cmd_get& e) {
-    return false;
+    return -EINVAL;
   }
   if (format != "json" && format != "json-pretty" &&
       format != "xml" && format != "xml-pretty")
@@ -414,7 +421,7 @@ int AdminSocket::execute_command(const std::vector<std::string>& cmdvec,
   if (p == hooks.cend()) {
     lderr(m_cct) << "AdminSocket: request '" << cmdvec
                 << "' not defined" << dendl;
-    return false;
+    return -ENOSYS;
   }
 
   // Drop lock to avoid cycles in cases where the hook takes
@@ -424,21 +431,27 @@ int AdminSocket::execute_command(const std::vector<std::string>& cmdvec,
   in_hook = true;
   auto hook = p->second.hook;
   l.unlock();
-  bool success = (validate(prefix, cmdmap, out) &&
-      hook->call(prefix, cmdmap, format, out));
+  int r;
+  if (!validate(prefix, cmdmap, out)) {
+    r = -EINVAL;
+  } else {
+    r = hook->call(prefix, cmdmap, format, out);
+  }
   l.lock();
   in_hook = false;
   in_hook_cond.notify_all();
-  if (!success) {
+  if (r < 0) {
     ldout(m_cct, 0) << "AdminSocket: request '" << prefix
-                   << "' to " << hook << " failed" << dendl;
+                   << "' to " << hook << " failed, " << cpp_strerror(r)
+                   << dendl;
     out.append("failed");
   } else {
     ldout(m_cct, 5) << "AdminSocket: request '" << prefix
-        << "' to " << hook
-        << " returned " << out.length() << " bytes" << dendl;
+                   << "' to " << hook
+                   << " returned " << r << " and " << out.length() << " bytes"
+                   << dendl;
   }
-  return true;
+  return r;
 }
 
 void AdminSocket::queue_tell_command(ref_t<MCommand> m)
@@ -508,8 +521,8 @@ void AdminSocket::unregister_commands(const AdminSocketHook *hook)
 
 class VersionHook : public AdminSocketHook {
 public:
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     if (command == "0"sv) {
       out.append(CEPH_ADMIN_SOCK_VERSION);
     } else {
@@ -528,7 +541,7 @@ public:
       jf.flush(ss);
       out.append(ss.str());
     }
-    return true;
+    return 0;
   }
 };
 
@@ -536,9 +549,9 @@ class HelpHook : public AdminSocketHook {
   AdminSocket *m_as;
 public:
   explicit HelpHook(AdminSocket *as) : m_as(as) {}
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format,
-           bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format,
+          bufferlist& out) override {
     std::unique_ptr<Formatter> f(Formatter::create(format, "json-pretty"sv,
                                                   "json-pretty"sv));
     f->open_object_section("help");
@@ -550,7 +563,7 @@ public:
     ostringstream ss;
     f->flush(ss);
     out.append(ss.str());
-    return true;
+    return 0;
   }
 };
 
@@ -558,8 +571,8 @@ class GetdescsHook : public AdminSocketHook {
   AdminSocket *m_as;
 public:
   explicit GetdescsHook(AdminSocket *as) : m_as(as) {}
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     int cmdnum = 0;
     JSONFormatter jf;
     jf.open_object_section("command_descriptions");
@@ -581,7 +594,7 @@ public:
     ostringstream ss;
     jf.flush(ss);
     out.append(ss.str());
-    return true;
+    return 0;
   }
 };
 

diff --git a/src/common/admin_socket.h b/src/common/admin_socket.h
index 2249ef852e555bfa3e8e2ae14a46f87c194c2ace..efa222ddedc9a63b347ad9f24e7fccc2538ebe5a 100644 (file)
--- a/src/common/admin_socket.h
+++ b/src/common/admin_socket.h
@@ -35,8 +35,8 @@ inline constexpr auto CEPH_ADMIN_SOCK_VERSION = "2"sv;
 
 class AdminSocketHook {
 public:
-  virtual bool call(std::string_view command, const cmdmap_t& cmdmap,
-                   std::string_view format, ceph::buffer::list& out) = 0;
+  virtual int call(std::string_view command, const cmdmap_t& cmdmap,
+                  std::string_view format, ceph::buffer::list& out) = 0;
   virtual ~AdminSocketHook() {}
 };
 

diff --git a/src/common/ceph_context.cc b/src/common/ceph_context.cc
index ee5b44b81cb7b66f41d903e87cef4f74eb296ab3..1cbc2aed5d8329333fb5116dc7104b130d019c09 100644 (file)
--- a/src/common/ceph_context.cc
+++ b/src/common/ceph_context.cc
@@ -166,17 +166,17 @@ public:
   }
 
   // AdminSocketHook
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     if (command == "dump_mempools") {
       std::unique_ptr<Formatter> f(Formatter::create(format));
       f->open_object_section("mempools");
       mempool::dump(f.get());
       f->close_section();
       f->flush(out);
-      return true;
+      return 0;
     }
-    return false;
+    return -ENOSYS;
   }
 };
 
@@ -437,14 +437,14 @@ class CephContextHook : public AdminSocketHook {
 public:
   explicit CephContextHook(CephContext *cct) : m_cct(cct) {}
 
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     try {
       m_cct->do_command(command, cmdmap, format, &out);
     } catch (const bad_cmd_get& e) {
-      return false;
+      return -EINVAL;
     }
-    return true;
+    return 0;
   }
 };
 

diff --git a/src/librbd/LibrbdAdminSocketHook.cc b/src/librbd/LibrbdAdminSocketHook.cc
index 7f713a67c96202943f70707ac012a9a3c721bbc9..35b7e3c16ad585942e87e8c9c9702fd51fec021f 100644 (file)
--- a/src/librbd/LibrbdAdminSocketHook.cc
+++ b/src/librbd/LibrbdAdminSocketHook.cc
@@ -88,14 +88,14 @@ LibrbdAdminSocketHook::~LibrbdAdminSocketHook() {
   }
 }
 
-bool LibrbdAdminSocketHook::call(std::string_view command,
-                                const cmdmap_t& cmdmap,
-                                std::string_view format,
-                                bufferlist& out) {
+int LibrbdAdminSocketHook::call(std::string_view command,
+                               const cmdmap_t& cmdmap,
+                               std::string_view format,
+                               bufferlist& out) {
   Commands::const_iterator i = commands.find(command);
   ceph_assert(i != commands.end());
   stringstream ss;
-  bool r = i->second->call(&ss);
+  int r = i->second->call(&ss);
   out.append(ss);
   return r;
 }

diff --git a/src/librbd/LibrbdAdminSocketHook.h b/src/librbd/LibrbdAdminSocketHook.h
index 8b1b5b9422f637c6e382e70fc53acb94728ed2d6..a06bcb11918e5bba8f4f0f2978d086adee080a9c 100644 (file)
--- a/src/librbd/LibrbdAdminSocketHook.h
+++ b/src/librbd/LibrbdAdminSocketHook.h
@@ -17,8 +17,8 @@ namespace librbd {
     LibrbdAdminSocketHook(ImageCtx *ictx);
     ~LibrbdAdminSocketHook() override;
 
-    bool call(std::string_view command, const cmdmap_t& cmdmap,
-             std::string_view format, bufferlist& out) override;
+    int call(std::string_view command, const cmdmap_t& cmdmap,
+            std::string_view format, bufferlist& out) override;
 
   private:
     typedef std::map<std::string,LibrbdAdminSocketCommand*,

diff --git a/src/mds/MDSDaemon.cc b/src/mds/MDSDaemon.cc
index 21344b6bd3a1abcf7bd7c9d950f3467dd2daa106..e0c5570cac2eaab48293ad72c3c4d10011cb199c 100644 (file)
--- a/src/mds/MDSDaemon.cc
+++ b/src/mds/MDSDaemon.cc
@@ -113,34 +113,35 @@ class MDSSocketHook : public AdminSocketHook {
   MDSDaemon *mds;
 public:
   explicit MDSSocketHook(MDSDaemon *m) : mds(m) {}
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
+  int call(std::string_view command, const cmdmap_t& cmdmap,
            std::string_view format, bufferlist& out) override {
     stringstream ss;
-    bool r = mds->asok_command(command, cmdmap, format, ss);
+    int r = mds->asok_command(command, cmdmap, format, ss);
     out.append(ss);
     return r;
   }
 };
 
-bool MDSDaemon::asok_command(std::string_view command, const cmdmap_t& cmdmap,
-                            std::string_view format, std::ostream& ss)
+int MDSDaemon::asok_command(std::string_view command, const cmdmap_t& cmdmap,
+                           std::string_view format, std::ostream& ss)
 {
   dout(1) << "asok_command: " << command << " (starting...)" << dendl;
 
   Formatter *f = Formatter::create(format, "json-pretty", "json-pretty");
-  bool handled = false;
+  int r = -ENOSYS;
   if (command == "status") {
     dump_status(f);
-    handled = true;
+    r = 0;
   } else {
     if (mds_rank == NULL) {
       dout(1) << "Can't run that command on an inactive MDS!" << dendl;
       f->dump_string("error", "mds_not_active");
     } else {
       try {
-       handled = mds_rank->handle_asok_command(command, cmdmap, f, ss);
+       r = mds_rank->handle_asok_command(command, cmdmap, f, ss);
       } catch (const bad_cmd_get& e) {
        ss << e.what();
+       r = -EINVAL;
       }
     }
   }
@@ -149,7 +150,7 @@ bool MDSDaemon::asok_command(std::string_view command, const cmdmap_t& cmdmap,
 
   dout(1) << "asok_command: " << command << " (complete)" << dendl;
 
-  return handled;
+  return r;
 }
 
 void MDSDaemon::dump_status(Formatter *f)

diff --git a/src/mds/MDSDaemon.h b/src/mds/MDSDaemon.h
index 0b9abede8efc454f35e2af20e65fd1cd45e55162..7448eed3d95585e18b0f513f4a3f9a70369de63f 100644 (file)
--- a/src/mds/MDSDaemon.h
+++ b/src/mds/MDSDaemon.h
@@ -115,8 +115,8 @@ class MDSDaemon : public Dispatcher {
   void set_up_admin_socket();
   void clean_up_admin_socket();
   void check_ops_in_flight(); // send off any slow ops to monitor
-  bool asok_command(std::string_view command, const cmdmap_t& cmdmap,
-                   std::string_view format, ostream& ss);
+  int asok_command(std::string_view command, const cmdmap_t& cmdmap,
+                  std::string_view format, ostream& ss);
 
   void dump_status(Formatter *f);
 

diff --git a/src/mds/MDSRank.cc b/src/mds/MDSRank.cc
index c61ab5e408f01d40dd08a69e70f7f6031cd34459..e77c765ddd65075919d87579247482a49ccb7a63 100644 (file)
--- a/src/mds/MDSRank.cc
+++ b/src/mds/MDSRank.cc
@@ -2433,13 +2433,13 @@ void MDSRank::handle_mds_failure(mds_rank_t who)
   snapclient->handle_mds_failure(who);
 }
 
-bool MDSRankDispatcher::handle_asok_command(std::string_view command,
-                                           const cmdmap_t& cmdmap,
-                                           Formatter *f,
-                                           std::ostream& ss)
+int MDSRankDispatcher::handle_asok_command(std::string_view command,
+                                          const cmdmap_t& cmdmap,
+                                          Formatter *f,
+                                          std::ostream& ss)
 {
   if (command == "dump_ops_in_flight" ||
-             command == "ops") {
+      command == "ops") {
     if (!op_tracker.dump_ops_in_flight(f)) {
       ss << "op_tracker tracking is not enabled now, so no ops are tracked currently, even those get stuck. \
          please enable \"mds_enable_op_tracker\", and the tracker will start to track new ops received afterwards.";
@@ -2465,7 +2465,7 @@ bool MDSRankDispatcher::handle_asok_command(std::string_view command,
 
     if (!got_val) {
       ss << "no target epoch given";
-      return true;
+      return -EINVAL;
     }
     {
       std::lock_guard l(mds_lock);
@@ -2488,7 +2488,7 @@ bool MDSRankDispatcher::handle_asok_command(std::string_view command,
     const bool got_arg = cmd_getval(g_ceph_context, cmdmap, "client_id", client_id);
     if(!got_arg) {
       ss << "Invalid client_id specified";
-      return true;
+      return -ENOENT;
     }
     std::lock_guard l(mds_lock);
     std::stringstream dss;
@@ -2536,12 +2536,12 @@ bool MDSRankDispatcher::handle_asok_command(std::string_view command,
     string path;
     if(!cmd_getval(g_ceph_context, cmdmap, "path", path)) {
       ss << "malformed path";
-      return true;
+      return -EINVAL;
     }
     int64_t rank;
     if(!cmd_getval(g_ceph_context, cmdmap, "rank", rank)) {
       ss << "malformed rank";
-      return true;
+      return -EINVAL;
     }
     command_export_dir(f, path, (mds_rank_t)rank);
   } else if (command == "dump cache") {
@@ -2601,10 +2601,10 @@ bool MDSRankDispatcher::handle_asok_command(std::string_view command,
   } else if (command == "dump inode") {
     command_dump_inode(f, cmdmap, ss);
   } else {
-    return false;
+    return -ENOSYS;
   }
 
-  return true;
+  return 0;
 }
 
 class C_MDS_Send_Command_Reply : public MDSInternalContext {

diff --git a/src/mds/MDSRank.h b/src/mds/MDSRank.h
index 4a708894cdd209deaf8c1db2a735e695488b1b44..a205ccb7661787322340ee64d503147dcdc65357 100644 (file)
--- a/src/mds/MDSRank.h
+++ b/src/mds/MDSRank.h
@@ -627,8 +627,8 @@ public:
   void init();
   void tick();
   void shutdown();
-  bool handle_asok_command(std::string_view command, const cmdmap_t& cmdmap,
-                           Formatter *f, std::ostream& ss);
+  int handle_asok_command(std::string_view command, const cmdmap_t& cmdmap,
+                         Formatter *f, std::ostream& ss);
   void handle_mds_map(const cref_t<MMDSMap> &m, const MDSMap &oldmap);
   void handle_osd_map();
   void update_log_config();

diff --git a/src/mgr/ClusterState.cc b/src/mgr/ClusterState.cc
index 12b30adc0fffeeefbb0a866f793f014d96a69ec5..9c95bbb1661f6b6b8a2387eb5de4d548e328151f 100644 (file)
--- a/src/mgr/ClusterState.cc
+++ b/src/mgr/ClusterState.cc
@@ -181,15 +181,15 @@ class ClusterSocketHook : public AdminSocketHook {
   ClusterState *cluster_state;
 public:
   explicit ClusterSocketHook(ClusterState *o) : cluster_state(o) {}
-  bool call(std::string_view admin_command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& out) override {
+  int call(std::string_view admin_command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     stringstream ss;
-    bool r = true;
+    int r = 0;
     try {
       r = cluster_state->asok_command(admin_command, cmdmap, format, ss);
     } catch (const bad_cmd_get& e) {
       ss << e.what();
-      r = true;
+      r = -EINVAL;
     }
     out.append(ss);
     return r;

diff --git a/src/mon/Monitor.cc b/src/mon/Monitor.cc
index 946fcdd727924bbaee6a65dbe1735f2bece4152e..01d945a4667875a5424ec7af89d3622185903ca1 100644 (file)
--- a/src/mon/Monitor.cc
+++ b/src/mon/Monitor.cc
@@ -263,12 +263,12 @@ class AdminHook : public AdminSocketHook {
   Monitor *mon;
 public:
   explicit AdminHook(Monitor *m) : mon(m) {}
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
+  int call(std::string_view command, const cmdmap_t& cmdmap,
            std::string_view format, bufferlist& out) override {
     stringstream ss;
     mon->do_admin_command(command, cmdmap, format, ss);
     out.append(ss);
-    return true;
+    return 0;
   }
 };
 

diff --git a/src/os/bluestore/Allocator.cc b/src/os/bluestore/Allocator.cc
index 8e5b1b6f4f34613a2cde6dd3f9138be09fd4b20b..7ec94186c5a5b530a379ea3faa494921f05bdabc 100644 (file)
--- a/src/os/bluestore/Allocator.cc
+++ b/src/os/bluestore/Allocator.cc
@@ -50,10 +50,10 @@ public:
     }
   }
 
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-            std::string_view format, bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     stringstream ss;
-    bool r = true;
+    bool r = 0;
     if (command == "bluestore allocator dump " + name) {
       Formatter *f = Formatter::create(format, "json-pretty", "json-pretty");
       f->open_array_section("free_regions");
@@ -89,7 +89,7 @@ public:
       delete f;
     } else {
       ss << "Invalid command" << std::endl;
-      r = false;
+      r = -ENOSYS;
     }
     out.append(ss);
     return r;

diff --git a/src/os/bluestore/BlueFS.cc b/src/os/bluestore/BlueFS.cc
index 06a574232c570dab4b71a1aa45d172252016c56a..e1c47d61304045f79ac71e2b270c69573f9d5e88 100644 (file)
--- a/src/os/bluestore/BlueFS.cc
+++ b/src/os/bluestore/BlueFS.cc
@@ -73,10 +73,10 @@ public:
 private:
   SocketHook(BlueFS* bluefs) :
     bluefs(bluefs) {}
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-              std::string_view format, bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
       stringstream ss;
-      bool r = true;
+      bool r = 0;
       if (command == "bluestore bluefs available") {
         int64_t alloc_size = 0;
         cmd_getval(bluefs->cct, cmdmap, "alloc_size", alloc_size);
@@ -106,7 +106,7 @@ private:
         delete f;
       } else {
         ss << "Invalid command" << std::endl;
-        r = false;
+        r = -ENOSYS;
       }
       out.append(ss);
       return r;

diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc
index e0bdbfd97e75724295ce7764a8a6f5c5e7c0f35f..4c1812aead3bf370cb61294795b44cd11e93712d 100644 (file)
--- a/src/osd/OSD.cc
+++ b/src/osd/OSD.cc
@@ -2330,15 +2330,15 @@ class OSDSocketHook : public AdminSocketHook {
   OSD *osd;
 public:
   explicit OSDSocketHook(OSD *o) : osd(o) {}
-  bool call(std::string_view admin_command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& out) override {
+  int call(std::string_view admin_command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     stringstream ss;
-    bool r = true;
+    int r;
     try {
       r = osd->asok_command(admin_command, cmdmap, format, ss);
     } catch (const bad_cmd_get& e) {
       ss << e.what();
-      r = true;
+      r = -EINVAL;
     }
     out.append(ss);
     return r;
@@ -2740,16 +2740,18 @@ class TestOpsSocketHook : public AdminSocketHook {
   ObjectStore *store;
 public:
   TestOpsSocketHook(OSDService *s, ObjectStore *st) : service(s), store(st) {}
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     stringstream ss;
+    int r = 0;
     try {
       test_ops(service, store, command, cmdmap, ss);
     } catch (const bad_cmd_get& e) {
       ss << e.what();
+      r = -EINVAL;
     }
     out.append(ss);
-    return true;
+    return r;
   }
   void test_ops(OSDService *service, ObjectStore *store,
                std::string_view command, const cmdmap_t& cmdmap, ostream &ss);

diff --git a/src/osdc/Objecter.cc b/src/osdc/Objecter.cc
index 3799ece8572a5a6e0d1624093635e47739cc6d5f..a6db93d3dc6e5d16af849401faadb43fc9813ff8 100644 (file)
--- a/src/osdc/Objecter.cc
+++ b/src/osdc/Objecter.cc
@@ -176,8 +176,8 @@ class Objecter::RequestStateHook : public AdminSocketHook {
   Objecter *m_objecter;
 public:
   explicit RequestStateHook(Objecter *objecter);
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, ceph::buffer::list& out) override;
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, ceph::buffer::list& out) override;
 };
 
 /**
@@ -4707,17 +4707,17 @@ Objecter::RequestStateHook::RequestStateHook(Objecter *objecter) :
 {
 }
 
-bool Objecter::RequestStateHook::call(std::string_view command,
-                                     const cmdmap_t& cmdmap,
-                                     std::string_view format,
-                                     ceph::buffer::list& out)
+int Objecter::RequestStateHook::call(std::string_view command,
+                                    const cmdmap_t& cmdmap,
+                                    std::string_view format,
+                                    ceph::buffer::list& out)
 {
   Formatter *f = Formatter::create(format, "json-pretty", "json-pretty");
   shared_lock rl(m_objecter->rwlock);
   m_objecter->dump_requests(f);
   f->flush(out);
   delete f;
-  return true;
+  return 0;
 }
 
 void Objecter::blacklist_self(bool set)

diff --git a/src/rgw/rgw_coroutine.cc b/src/rgw/rgw_coroutine.cc
index fbaa6ecf796d6928f04176468c3fe79c3edac8de..60d29bde9d0fa0daa3bf384bf745efc78645f1bf 100644 (file)
--- a/src/rgw/rgw_coroutine.cc
+++ b/src/rgw/rgw_coroutine.cc
@@ -852,7 +852,7 @@ int RGWCoroutinesManagerRegistry::hook_to_admin_command(const string& command)
   return 0;
 }
 
-bool RGWCoroutinesManagerRegistry::call(std::string_view command,
+int RGWCoroutinesManagerRegistry::call(std::string_view command,
                                         const cmdmap_t& cmdmap,
                                         std::string_view format,
                                         bufferlist& out) {
@@ -862,7 +862,7 @@ bool RGWCoroutinesManagerRegistry::call(std::string_view command,
   ::encode_json("cr_managers", *this, &f);
   f.flush(ss);
   out.append(ss);
-  return true;
+  return 0;
 }
 
 void RGWCoroutinesManagerRegistry::dump(Formatter *f) const {

diff --git a/src/rgw/rgw_coroutine.h b/src/rgw/rgw_coroutine.h
index 5c41133263a17f979a5b8bb496ce4a3f994bd197..9e7ac5673e5aa4728fa6d8c73d588557e97be0b0 100644 (file)
--- a/src/rgw/rgw_coroutine.h
+++ b/src/rgw/rgw_coroutine.h
@@ -559,8 +559,8 @@ public:
   void remove(RGWCoroutinesManager *mgr);
 
   int hook_to_admin_command(const string& command);
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-            std::string_view format, bufferlist& out) override;
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override;
 
   void dump(Formatter *f) const;
 };

diff --git a/src/rgw/rgw_sync_trace.cc b/src/rgw/rgw_sync_trace.cc
index 02f3ca178aa8a39634dd5942f19e549ee9176da2..d086c06e9872535632198b32d321263cf06fd73a 100644 (file)
--- a/src/rgw/rgw_sync_trace.cc
+++ b/src/rgw/rgw_sync_trace.cc
@@ -195,8 +195,8 @@ string RGWSyncTraceManager::get_active_names()
   return ss.str();
 }
 
-bool RGWSyncTraceManager::call(std::string_view command, const cmdmap_t& cmdmap,
-                               std::string_view format, bufferlist& out) {
+int RGWSyncTraceManager::call(std::string_view command, const cmdmap_t& cmdmap,
+                             std::string_view format, bufferlist& out) {
 
   bool show_history = (command == "sync trace history");
   bool show_short = (command == "sync trace active_short");
@@ -254,7 +254,7 @@ bool RGWSyncTraceManager::call(std::string_view command, const cmdmap_t& cmdmap,
   f.flush(ss);
   out.append(ss);
 
-  return true;
+  return 0;
 }
 
 void RGWSyncTraceManager::finish_node(RGWSyncTraceNode *node)

diff --git a/src/rgw/rgw_sync_trace.h b/src/rgw/rgw_sync_trace.h
index 6db579ac4ceb46a0c0bea4a30d005672a80e974a..9d5fb51b617f40eca07b889fe9175a8cf1f1e0b6 100644 (file)
--- a/src/rgw/rgw_sync_trace.h
+++ b/src/rgw/rgw_sync_trace.h
@@ -133,8 +133,8 @@ public:
                                const std::string& id = "");
 
   int hook_to_admin_command();
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-            std::string_view format, bufferlist& out) override;
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override;
   string get_active_names();
 };
 

diff --git a/src/rgw/services/svc_sys_obj_cache.cc b/src/rgw/services/svc_sys_obj_cache.cc
index 6865eb70c45ff7170d5694a37cceb60febbd61a0..bdbb67812aaca72357f7871b07e3e947512f35b7 100644 (file)
--- a/src/rgw/services/svc_sys_obj_cache.cc
+++ b/src/rgw/services/svc_sys_obj_cache.cc
@@ -517,8 +517,8 @@ public:
     int start();
     void shutdown();
 
-    bool call(std::string_view command, const cmdmap_t& cmdmap,
-              std::string_view format, bufferlist& out) override;
+    int call(std::string_view command, const cmdmap_t& cmdmap,
+            std::string_view format, bufferlist& out) override;
 };
 
 int RGWSI_SysObj_Cache_ASocketHook::start()
@@ -541,8 +541,9 @@ void RGWSI_SysObj_Cache_ASocketHook::shutdown()
   admin_socket->unregister_commands(this);
 }
 
-bool RGWSI_SysObj_Cache_ASocketHook::call(std::string_view command, const cmdmap_t& cmdmap,
-                                          std::string_view format, bufferlist& out)
+int RGWSI_SysObj_Cache_ASocketHook::call(
+  std::string_view command, const cmdmap_t& cmdmap,
+  std::string_view format, bufferlist& out)
 {
   if (command == "cache list"sv) {
     std::optional<std::string> filter;
@@ -555,10 +556,10 @@ bool RGWSI_SysObj_Cache_ASocketHook::call(std::string_view command, const cmdmap
       svc->asocket.call_list(filter, f.get());
       f->close_section();
       f->flush(out);
-      return true;
+      return 0;
     } else {
       out.append("Unable to create Formatter.\n");
-      return false;
+      return -EINVAL;
     }
   } else if (command == "cache inspect"sv) {
     std::unique_ptr<Formatter> f(ceph::Formatter::create(format, "json-pretty"));
@@ -566,28 +567,28 @@ bool RGWSI_SysObj_Cache_ASocketHook::call(std::string_view command, const cmdmap
       const auto& target = boost::get<std::string>(cmdmap.at("target"));
       if (svc->asocket.call_inspect(target, f.get())) {
         f->flush(out);
-        return true;
+        return 0;
       } else {
         out.append("Unable to find entry "s + target + ".\n");
-        return false;
+        return -ENOENT;
       }
     } else {
       out.append("Unable to create Formatter.\n");
-      return false;
+      return -EINVAL;
     }
   } else if (command == "cache erase"sv) {
     const auto& target = boost::get<std::string>(cmdmap.at("target"));
     if (svc->asocket.call_erase(target)) {
-      return true;
+      return 0;
     } else {
       out.append("Unable to find entry "s + target + ".\n");
-      return false;
+      return -ENOENT;
     }
   } else if (command == "cache zap"sv) {
     svc->asocket.call_zap();
     return true;
   }
-  return false;
+  return -ENOSYS;
 }
 
 RGWSI_SysObj_Cache::ASocketHandler::ASocketHandler(RGWSI_SysObj_Cache *_svc) : svc(_svc)

diff --git a/src/test/admin_socket.cc b/src/test/admin_socket.cc
index e213417589945bacaa62792f6d09176168784ecf..dfca141964e19f23aa53b0df8b4e261b6526735f 100644 (file)
--- a/src/test/admin_socket.cc
+++ b/src/test/admin_socket.cc
@@ -115,8 +115,8 @@ TEST(AdminSocket, SendTooLongRequest) {
 }
 
 class MyTest : public AdminSocketHook {
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& result) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& result) override {
     std::vector<std::string> args;
     cmd_getval(g_ceph_context, cmdmap, "args", args);
     result.append(command);
@@ -129,7 +129,7 @@ class MyTest : public AdminSocketHook {
       resultstr += *it;
     }
     result.append(resultstr);
-    return true;
+    return 0;
   }
 };
 
@@ -148,8 +148,8 @@ TEST(AdminSocket, RegisterCommand) {
 }
 
 class MyTest2 : public AdminSocketHook {
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& result) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& result) override {
     std::vector<std::string> args;
     cmd_getval(g_ceph_context, cmdmap, "args", args);
     result.append(command);
@@ -162,7 +162,7 @@ class MyTest2 : public AdminSocketHook {
       resultstr += *it;
     }
     result.append(resultstr);
-    return true;
+    return 0;
   }
 };
 
@@ -202,11 +202,11 @@ public:
 
   BlockingHook() = default;
 
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& result) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& result) override {
     std::unique_lock l{_lock};
     _cond.wait(l);
-    return true;
+    return 0;
   }
 };
 

diff --git a/src/tools/rbd_mirror/ImageDeleter.cc b/src/tools/rbd_mirror/ImageDeleter.cc
index 854769ebfe4760f6a37e3b92b6b7dfccf267f916..aa49e24aadc91d366568014a0806b18e2d2d6fc2 100644 (file)
--- a/src/tools/rbd_mirror/ImageDeleter.cc
+++ b/src/tools/rbd_mirror/ImageDeleter.cc
@@ -105,13 +105,13 @@ public:
     }
   }
 
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     Commands::const_iterator i = commands.find(command);
     ceph_assert(i != commands.end());
     Formatter *f = Formatter::create(format);
     stringstream ss;
-    bool r = i->second->call(f, &ss);
+    int r = i->second->call(f, &ss);
     delete f;
     out.append(ss);
     return r;

diff --git a/src/tools/rbd_mirror/ImageReplayer.cc b/src/tools/rbd_mirror/ImageReplayer.cc
index e1a2551f42807abb7200dcb1ce365d5c8ddcefa8..d87cb20f030bab870571f6c89a11afcdcb8ffe83 100644 (file)
--- a/src/tools/rbd_mirror/ImageReplayer.cc
+++ b/src/tools/rbd_mirror/ImageReplayer.cc
@@ -195,13 +195,13 @@ public:
     commands.clear();
   }
 
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     auto i = commands.find(command);
     ceph_assert(i != commands.end());
     Formatter *f = Formatter::create(format);
     stringstream ss;
-    bool r = i->second->call(f, &ss);
+    int r = i->second->call(f, &ss);
     delete f;
     out.append(ss);
     return r;

diff --git a/src/tools/rbd_mirror/Mirror.cc b/src/tools/rbd_mirror/Mirror.cc
index 2b580ffd157ce5c3f16e7bcca452cb0d039a34c4..980c6c713dbb584273aa82feae73dd145f02dd8d 100644 (file)
--- a/src/tools/rbd_mirror/Mirror.cc
+++ b/src/tools/rbd_mirror/Mirror.cc
@@ -321,13 +321,13 @@ public:
     }
   }
 
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     Commands::const_iterator i = commands.find(command);
     ceph_assert(i != commands.end());
     Formatter *f = Formatter::create(format);
     stringstream ss;
-    bool r = i->second->call(f, &ss);
+    int r = i->second->call(f, &ss);
     delete f;
     out.append(ss);
     return r;

diff --git a/src/tools/rbd_mirror/PoolReplayer.cc b/src/tools/rbd_mirror/PoolReplayer.cc
index 6f6c80814d31286addc85a2e8653d4961c455e1c..85afd0f0d1d074df07a3925d22cc926cb3f36478 100644 (file)
--- a/src/tools/rbd_mirror/PoolReplayer.cc
+++ b/src/tools/rbd_mirror/PoolReplayer.cc
@@ -185,13 +185,13 @@ public:
     }
   }
 
-  bool call(std::string_view command, const cmdmap_t& cmdmap,
-           std::string_view format, bufferlist& out) override {
+  int call(std::string_view command, const cmdmap_t& cmdmap,
+          std::string_view format, bufferlist& out) override {
     auto i = commands.find(command);
     ceph_assert(i != commands.end());
     Formatter *f = Formatter::create(format);
     stringstream ss;
-    bool r = i->second->call(f, &ss);
+    int r = i->second->call(f, &ss);
     delete f;
     out.append(ss);
     return r;