Bug#22841977 X PLUGIN BREAKS BUILD ON ARM64 (AARCH64)

lkotula · lkotula · commit 9e3d5f1ab454 · 2016-03-02T05:44:36.000+01:00
Description: On arm64 there are multiple definitions for syscalls deprecated

Solution: Application instead using deprecated __NR_epoll_wait will use
__NR_epoll_pwait (if its defined in unistd.h).

Reviewed-by: Andrzej Religa &lt;andrzej.religa@oracle.org&gt;
Reviewed-by: Tor Didriksen &lt;tor.didriksen@oracle.com&gt;

RB: 11970
diff --git a/libevent/epoll_sub.c b/libevent/epoll_sub.c
@@ -1,6 +1,6 @@
 /*
- * Copyright 2003 Niels Provos <provos@citi.umich.edu>
- * All rights reserved.
+ * Copyright 2003-2009 Niels Provos <provos@citi.umich.edu>
+ * Copyright 2009-2012 Niels Provos and Nick Mathewson
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -31,11 +31,20 @@
 #include <sys/syscall.h>
 #include <sys/epoll.h>
 #include <unistd.h>
+#include <errno.h>
 
 int
 epoll_create(int size)
 {
+#if !defined(__NR_epoll_create) && defined(__NR_epoll_create1)
+	if (size <= 0) {
+		errno = EINVAL;
+		return -1;
+	}
+	return (syscall(__NR_epoll_create1, 0));
+#else
 	return (syscall(__NR_epoll_create, size));
+#endif
 }
 
 int
@@ -48,5 +57,9 @@ epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
 int
 epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
 {
+#if !defined(__NR_epoll_wait) && defined(__NR_epoll_pwait)
+	return (syscall(__NR_epoll_pwait, epfd, events, maxevents, timeout, NULL, 0));
+#else
 	return (syscall(__NR_epoll_wait, epfd, events, maxevents, timeout));
-}
+#endif
+}
diff --git a/rapid/plugin/x/ngs/include/ngs/client.h b/rapid/plugin/x/ngs/include/ngs/client.h
@@ -146,7 +146,7 @@ namespace ngs
 
     void remove_client_from_server();
 
-    void handle_message(Request_unique_ptr &message);
+    void handle_message(Request &message);
     virtual bool is_localhost(const char *) = 0;
 
   private:
diff --git a/rapid/plugin/x/ngs/include/ngs/client_session.h b/rapid/plugin/x/ngs/include/ngs/client_session.h
@@ -58,16 +58,16 @@ namespace ngs
     virtual void on_auth_failure(const Authentication_handler::Response &response);
 
     // handle a single message, returns true if message was handled false if not
-    virtual bool handle_message(Request_unique_ptr &command);
+    virtual bool handle_message(ngs::Request &command);
 
     Client &client() const { return m_client; }
 
     Protocol_encoder &proto() { return *m_encoder; }
     virtual Error_code init() = 0;
 
   protected:
-    virtual bool handle_auth_message(Request_unique_ptr &command);
-    virtual bool handle_ready_message(Request_unique_ptr &command);
+    virtual bool handle_auth_message(ngs::Request &command);
+    virtual bool handle_ready_message(ngs::Request &command);
 
     void stop_auth();
 
diff --git a/rapid/plugin/x/ngs/include/ngs/protocol_encoder.h b/rapid/plugin/x/ngs/include/ngs/protocol_encoder.h
@@ -107,7 +107,7 @@ namespace ngs
 
     virtual IProtocol_monitor &get_protocol_monitor();
 
-    static void log_protobuf(const char *direction_name, Request_unique_ptr &request);
+    static void log_protobuf(const char *direction_name, Request &request);
     static void log_protobuf(const char *direction_name, const Message *request);
     static void log_protobuf(int8_t type);
 
diff --git a/rapid/plugin/x/ngs/src/client.cc b/rapid/plugin/x/ngs/src/client.cc
@@ -149,16 +149,16 @@ void Client::set_capabilities(const Mysqlx::Connection::CapabilitiesSet &setcap)
 }
 
 
-void Client::handle_message(Request_unique_ptr &request)
+void Client::handle_message(Request &request)
 {
   log_message_recv(request);
 
   Client_state expected_state = Client_accepted;
 
   // there is no session before authentication, so we handle the messages ourselves
-  log_debug("%s: Client got message %i", client_id(), request->get_type());
+  log_debug("%s: Client got message %i", client_id(), request.get_type());
 
-  switch (request->get_type())
+  switch (request.get_type())
   {
     case Mysqlx::ClientMessages::CON_CLOSE:
       m_encoder->send_ok("bye!");
@@ -171,11 +171,11 @@ void Client::handle_message(Request_unique_ptr &request)
       break;
 
     case Mysqlx::ClientMessages::CON_CAPABILITIES_GET:
-      get_capabilities(static_cast<const Mysqlx::Connection::CapabilitiesGet&>(*request->message()));
+      get_capabilities(static_cast<const Mysqlx::Connection::CapabilitiesGet&>(*request.message()));
       break;
 
     case Mysqlx::ClientMessages::CON_CAPABILITIES_SET:
-      set_capabilities(static_cast<const Mysqlx::Connection::CapabilitiesSet&>(*request->message()));
+      set_capabilities(static_cast<const Mysqlx::Connection::CapabilitiesSet&>(*request.message()));
       break;
 
     case Mysqlx::ClientMessages::SESS_AUTHENTICATE_START:
@@ -189,15 +189,15 @@ void Client::handle_message(Request_unique_ptr &request)
         if (s)
         {
           // forward the message to the pre-allocated session, rest of auth will be handled by the session
-          s->handle_message(boost::move(request));
+          s->handle_message(request);
         }
         break;
       }
       /* no break */
 
     default:
       // invalid message at this time
-      log_info("%s: Invalid message %i received during client initialization", client_id(), request->get_type());
+      log_info("%s: Invalid message %i received during client initialization", client_id(), request.get_type());
       m_encoder->send_result(ngs::Fatal(ER_X_BAD_MESSAGE, "Invalid message"));
 
       m_close_reason = Close_error;
@@ -512,10 +512,10 @@ void Client::run(bool skip_name_resolve, struct sockaddr_in client_addr)
       if (m_state != Client_accepted && s)
       {
         // pass the message to the session
-        s->handle_message(message);
+        s->handle_message(*message);
       }
       else
-        handle_message(message);
+        handle_message(*message);
     }
     catch (std::exception &e)
     {
diff --git a/rapid/plugin/x/ngs/src/client_session.cc b/rapid/plugin/x/ngs/src/client_session.cc
@@ -98,7 +98,7 @@ void Session::on_kill()
 
 // Return value means true if message was handled, false if not.
 // If message is handled, ownership of the object is passed on (and should be deleted by the callee)
-bool Session::handle_message(Request_unique_ptr &command)
+bool Session::handle_message(ngs::Request &command)
 {
   log_message_recv(command);
 
@@ -116,9 +116,9 @@ bool Session::handle_message(Request_unique_ptr &command)
 }
 
 
-bool Session::handle_ready_message(Request_unique_ptr &command)
+bool Session::handle_ready_message(ngs::Request &command)
 {
-  switch (command->get_type())
+  switch (command.get_type())
   {
     case Mysqlx::ClientMessages::SESS_CLOSE:
       m_encoder->send_ok("bye!");
@@ -149,14 +149,14 @@ void Session::stop_auth()
 }
 
 
-bool Session::handle_auth_message(Request_unique_ptr &command)
+bool Session::handle_auth_message(ngs::Request &command)
 {
   Authentication_handler::Response r;
-  int8_t type = command->get_type();
+  int8_t type = command.get_type();
 
   if (type == Mysqlx::ClientMessages::SESS_AUTHENTICATE_START && m_auth_handler.get() == NULL)
   {
-    const Mysqlx::Session::AuthenticateStart &authm = static_cast<const Mysqlx::Session::AuthenticateStart&>(*command->message());
+    const Mysqlx::Session::AuthenticateStart &authm = static_cast<const Mysqlx::Session::AuthenticateStart&>(*command.message());
 
     log_debug("%s.%u: Login attempt: mechanism=%s auth_data=%s",
              m_client.client_id(), m_id, authm.mech_name().c_str(),
@@ -179,7 +179,7 @@ bool Session::handle_auth_message(Request_unique_ptr &command)
   }
   else if (type == Mysqlx::ClientMessages::SESS_AUTHENTICATE_CONTINUE && m_auth_handler.get())
   {
-    const Mysqlx::Session::AuthenticateContinue &authm = static_cast<const Mysqlx::Session::AuthenticateContinue&>(*command->message());
+    const Mysqlx::Session::AuthenticateContinue &authm = static_cast<const Mysqlx::Session::AuthenticateContinue&>(*command.message());
 
     r = m_auth_handler->handle_continue(authm.auth_data());
   }
diff --git a/rapid/plugin/x/ngs/src/protocol_encoder.cc b/rapid/plugin/x/ngs/src/protocol_encoder.cc
@@ -237,13 +237,13 @@ void Protocol_encoder::on_error(int error)
 }
 
 
-void Protocol_encoder::log_protobuf(const char *direction_name, Request_unique_ptr &request)
+void Protocol_encoder::log_protobuf(const char *direction_name, Request &request)
 {
-  const Message *message = request->message();
+  const Message *message = request.message();
 
   if (NULL == message)
   {
-    log_protobuf(request->get_type());
+    log_protobuf(request.get_type());
     return;
   }
 
diff --git a/rapid/plugin/x/src/xpl_dispatcher.cc b/rapid/plugin/x/src/xpl_dispatcher.cc
@@ -160,30 +160,30 @@ static ngs::Error_code do_dispatch_command(Session &session,
                                            Sql_data_context &da, ngs::Protocol_encoder &proto,
                                            Crud_command_handler &crudh, Expectation_stack &expect,
                                            Session_options &options,
-                                           ngs::Request_unique_ptr &command)
+                                           ngs::Request &command)
 {
-  switch (command->get_type())
+  switch (command.get_type())
   {
     case Mysqlx::ClientMessages::SQL_STMT_EXECUTE:
-      return on_stmt_execute(session, da, options, proto, static_cast<const Mysqlx::Sql::StmtExecute&>(*command->message()));
+      return on_stmt_execute(session, da, options, proto, static_cast<const Mysqlx::Sql::StmtExecute&>(*command.message()));
 
     case Mysqlx::ClientMessages::CRUD_FIND:
-      return crudh.execute_crud_find(proto, static_cast<const Mysqlx::Crud::Find&>(*command->message()));
+      return crudh.execute_crud_find(proto, static_cast<const Mysqlx::Crud::Find&>(*command.message()));
 
     case Mysqlx::ClientMessages::CRUD_INSERT:
-      return crudh.execute_crud_insert(proto, static_cast<const Mysqlx::Crud::Insert&>(*command->message()));
+      return crudh.execute_crud_insert(proto, static_cast<const Mysqlx::Crud::Insert&>(*command.message()));
 
     case Mysqlx::ClientMessages::CRUD_UPDATE:
-      return crudh.execute_crud_update(proto, static_cast<const Mysqlx::Crud::Update&>(*command->message()));
+      return crudh.execute_crud_update(proto, static_cast<const Mysqlx::Crud::Update&>(*command.message()));
 
     case Mysqlx::ClientMessages::CRUD_DELETE:
-      return crudh.execute_crud_delete(proto, static_cast<const Mysqlx::Crud::Delete&>(*command->message()));
+      return crudh.execute_crud_delete(proto, static_cast<const Mysqlx::Crud::Delete&>(*command.message()));
 
     case Mysqlx::ClientMessages::EXPECT_OPEN:
-      return on_expect_open(session, proto, expect, options, static_cast<const Mysqlx::Expect::Open&>(*command->message()));
+      return on_expect_open(session, proto, expect, options, static_cast<const Mysqlx::Expect::Open&>(*command.message()));
 
     case Mysqlx::ClientMessages::EXPECT_CLOSE:
-      return on_expect_close(session, proto, expect, options, static_cast<const Mysqlx::Expect::Close&>(*command->message()));
+      return on_expect_close(session, proto, expect, options, static_cast<const Mysqlx::Expect::Close&>(*command.message()));
   }
   return ngs::Error(ER_UNKNOWN_COM_ERROR, "Unexpected message received");
 }
@@ -193,15 +193,15 @@ bool dispatcher::dispatch_command(Session &session,
                                   Sql_data_context &da, ngs::Protocol_encoder &proto,
                                   Crud_command_handler &crudh, Expectation_stack &expect,
                                   Session_options &options,
-                                  ngs::Request_unique_ptr command)
+                                  ngs::Request &command)
 {
-  ngs::Error_code error = expect.pre_client_stmt(command->get_type());
+  ngs::Error_code error = expect.pre_client_stmt(command.get_type());
   if (!error)
   {
     error = do_dispatch_command(session, da, proto, crudh, expect, options, command);
     if (error)
       proto.send_result(error);
-    expect.post_client_stmt(command->get_type(), error);
+    expect.post_client_stmt(command.get_type(), error);
   }
   else
     proto.send_result(error);
diff --git a/rapid/plugin/x/src/xpl_dispatcher.h b/rapid/plugin/x/src/xpl_dispatcher.h
@@ -43,7 +43,7 @@ namespace xpl
                           Crud_command_handler &crudh,
                           Expectation_stack &expect,
                           Session_options &options,
-                          ngs::Request_unique_ptr command);
+                          ngs::Request &command);
   };
 
   ngs::Error_code show_warnings_and_send(Sql_data_context &da, ngs::Protocol_encoder &proto);
diff --git a/rapid/plugin/x/src/xpl_session.cc b/rapid/plugin/x/src/xpl_session.cc
@@ -55,7 +55,7 @@ xpl::Session::~Session()
 
 
 // handle a message while in Ready state
-bool xpl::Session::handle_ready_message(ngs::Request_unique_ptr &command)
+bool xpl::Session::handle_ready_message(ngs::Request &command)
 {
   DBUG_ASSERT(m_crud_handler != NULL);
 
@@ -74,7 +74,7 @@ bool xpl::Session::handle_ready_message(ngs::Request_unique_ptr &command)
   try
   {
     return dispatcher::dispatch_command(*this, *m_sql, *m_encoder, *m_crud_handler, m_expect_stack,
-                                            m_options, boost::move(command));
+                                            m_options, command);
   }
   catch (ngs::Error_code &err)
   {
diff --git a/rapid/plugin/x/src/xpl_session.h b/rapid/plugin/x/src/xpl_session.h
@@ -82,7 +82,7 @@ class Session : public ngs::Session
 
   bool can_see_user(const char *user) const;
 protected:
-  virtual bool handle_ready_message(ngs::Request_unique_ptr &command);
+  virtual bool handle_ready_message(ngs::Request &command);
 
   Sql_data_context *m_sql;
   Crud_command_handler *m_crud_handler;

Original file line number	Diff line number	Diff line change
`@@ -149,16 +149,16 @@ void Client::set_capabilities(const Mysqlx::Connection::CapabilitiesSet &setcap)`
`149`	`149`	`}`
`150`	`150`
`151`	`151`
`152`		`-void Client::handle_message(Request_unique_ptr &request)`
	`152`	`+void Client::handle_message(Request &request)`
`153`	`153`	`{`
`154`	`154`	`log_message_recv(request);`
`155`	`155`
`156`	`156`	`Client_state expected_state = Client_accepted;`
`157`	`157`
`158`	`158`	`// there is no session before authentication, so we handle the messages ourselves`
`159`		`- log_debug("%s: Client got message %i", client_id(), request->get_type());`
	`159`	`+ log_debug("%s: Client got message %i", client_id(), request.get_type());`
`160`	`160`
`161`		`- switch (request->get_type())`
	`161`	`+ switch (request.get_type())`
`162`	`162`	`{`
`163`	`163`	`case Mysqlx::ClientMessages::CON_CLOSE:`
`164`	`164`	`m_encoder->send_ok("bye!");`
`@@ -171,11 +171,11 @@ void Client::handle_message(Request_unique_ptr &request)`
`171`	`171`	`break;`
`172`	`172`
`173`	`173`	`case Mysqlx::ClientMessages::CON_CAPABILITIES_GET:`
`174`		`- get_capabilities(static_cast<const Mysqlx::Connection::CapabilitiesGet&>(*request->message()));`
	`174`	`+ get_capabilities(static_cast<const Mysqlx::Connection::CapabilitiesGet&>(*request.message()));`
`175`	`175`	`break;`
`176`	`176`
`177`	`177`	`case Mysqlx::ClientMessages::CON_CAPABILITIES_SET:`
`178`		`- set_capabilities(static_cast<const Mysqlx::Connection::CapabilitiesSet&>(*request->message()));`
	`178`	`+ set_capabilities(static_cast<const Mysqlx::Connection::CapabilitiesSet&>(*request.message()));`
`179`	`179`	`break;`
`180`	`180`
`181`	`181`	`case Mysqlx::ClientMessages::SESS_AUTHENTICATE_START:`
`@@ -189,15 +189,15 @@ void Client::handle_message(Request_unique_ptr &request)`
`189`	`189`	`if (s)`
`190`	`190`	`{`
`191`	`191`	`// forward the message to the pre-allocated session, rest of auth will be handled by the session`
`192`		`- s->handle_message(boost::move(request));`
	`192`	`+ s->handle_message(request);`
`193`	`193`	`}`
`194`	`194`	`break;`
`195`	`195`	`}`
`196`	`196`	`/* no break */`
`197`	`197`
`198`	`198`	`default:`
`199`	`199`	`// invalid message at this time`
`200`		`- log_info("%s: Invalid message %i received during client initialization", client_id(), request->get_type());`
	`200`	`+ log_info("%s: Invalid message %i received during client initialization", client_id(), request.get_type());`
`201`	`201`	`m_encoder->send_result(ngs::Fatal(ER_X_BAD_MESSAGE, "Invalid message"));`
`202`	`202`
`203`	`203`	`m_close_reason = Close_error;`
`@@ -512,10 +512,10 @@ void Client::run(bool skip_name_resolve, struct sockaddr_in client_addr)`
`512`	`512`	`if (m_state != Client_accepted && s)`
`513`	`513`	`{`
`514`	`514`	`// pass the message to the session`
`515`		`- s->handle_message(message);`
	`515`	`+ s->handle_message(*message);`
`516`	`516`	`}`
`517`	`517`	`else`
`518`		`- handle_message(message);`
	`518`	`+ handle_message(*message);`
`519`	`519`	`}`
`520`	`520`	`catch (std::exception &e)`
`521`	`521`	`{`
Original file line number	Diff line number	Diff line change
`@@ -98,7 +98,7 @@ void Session::on_kill()`
`98`	`98`
`99`	`99`	`// Return value means true if message was handled, false if not.`
`100`	`100`	`// If message is handled, ownership of the object is passed on (and should be deleted by the callee)`
`101`		`-bool Session::handle_message(Request_unique_ptr &command)`
	`101`	`+bool Session::handle_message(ngs::Request &command)`
`102`	`102`	`{`
`103`	`103`	`log_message_recv(command);`
`104`	`104`
`@@ -116,9 +116,9 @@ bool Session::handle_message(Request_unique_ptr &command)`
`116`	`116`	`}`
`117`	`117`
`118`	`118`
`119`		`-bool Session::handle_ready_message(Request_unique_ptr &command)`
	`119`	`+bool Session::handle_ready_message(ngs::Request &command)`
`120`	`120`	`{`
`121`		`- switch (command->get_type())`
	`121`	`+ switch (command.get_type())`
`122`	`122`	`{`
`123`	`123`	`case Mysqlx::ClientMessages::SESS_CLOSE:`
`124`	`124`	`m_encoder->send_ok("bye!");`
`@@ -149,14 +149,14 @@ void Session::stop_auth()`
`149`	`149`	`}`
`150`	`150`
`151`	`151`
`152`		`-bool Session::handle_auth_message(Request_unique_ptr &command)`
	`152`	`+bool Session::handle_auth_message(ngs::Request &command)`
`153`	`153`	`{`
`154`	`154`	`Authentication_handler::Response r;`
`155`		`- int8_t type = command->get_type();`
	`155`	`+ int8_t type = command.get_type();`
`156`	`156`
`157`	`157`	`if (type == Mysqlx::ClientMessages::SESS_AUTHENTICATE_START && m_auth_handler.get() == NULL)`
`158`	`158`	`{`
`159`		`- const Mysqlx::Session::AuthenticateStart &authm = static_cast<const Mysqlx::Session::AuthenticateStart&>(*command->message());`
	`159`	`+ const Mysqlx::Session::AuthenticateStart &authm = static_cast<const Mysqlx::Session::AuthenticateStart&>(*command.message());`
`160`	`160`
`161`	`161`	`log_debug("%s.%u: Login attempt: mechanism=%s auth_data=%s",`
`162`	`162`	`m_client.client_id(), m_id, authm.mech_name().c_str(),`
`@@ -179,7 +179,7 @@ bool Session::handle_auth_message(Request_unique_ptr &command)`
`179`	`179`	`}`
`180`	`180`	`else if (type == Mysqlx::ClientMessages::SESS_AUTHENTICATE_CONTINUE && m_auth_handler.get())`
`181`	`181`	`{`
`182`		`- const Mysqlx::Session::AuthenticateContinue &authm = static_cast<const Mysqlx::Session::AuthenticateContinue&>(*command->message());`
	`182`	`+ const Mysqlx::Session::AuthenticateContinue &authm = static_cast<const Mysqlx::Session::AuthenticateContinue&>(*command.message());`
`183`	`183`
`184`	`184`	`r = m_auth_handler->handle_continue(authm.auth_data());`
`185`	`185`	`}`
Original file line number	Diff line number	Diff line change
`@@ -237,13 +237,13 @@ void Protocol_encoder::on_error(int error)`
`237`	`237`	`}`
`238`	`238`
`239`	`239`
`240`		`-void Protocol_encoder::log_protobuf(const char *direction_name, Request_unique_ptr &request)`
	`240`	`+void Protocol_encoder::log_protobuf(const char *direction_name, Request &request)`
`241`	`241`	`{`
`242`		`- const Message *message = request->message();`
	`242`	`+ const Message *message = request.message();`
`243`	`243`
`244`	`244`	`if (NULL == message)`
`245`	`245`	`{`
`246`		`- log_protobuf(request->get_type());`
	`246`	`+ log_protobuf(request.get_type());`
`247`	`247`	`return;`
`248`	`248`	`}`
`249`	`249`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ xpl::Session::~Session()`
`55`	`55`
`56`	`56`
`57`	`57`	`// handle a message while in Ready state`
`58`		`-bool xpl::Session::handle_ready_message(ngs::Request_unique_ptr &command)`
	`58`	`+bool xpl::Session::handle_ready_message(ngs::Request &command)`
`59`	`59`	`{`
`60`	`60`	`DBUG_ASSERT(m_crud_handler != NULL);`
`61`	`61`
`@@ -74,7 +74,7 @@ bool xpl::Session::handle_ready_message(ngs::Request_unique_ptr &command)`
`74`	`74`	`try`
`75`	`75`	`{`
`76`	`76`	`return dispatcher::dispatch_command(this, m_sql, m_encoder, m_crud_handler, m_expect_stack,`
`77`		`- m_options, boost::move(command));`
	`77`	`+ m_options, command);`
`78`	`78`	`}`
`79`	`79`	`catch (ngs::Error_code &err)`
`80`	`80`	`{`