Fix "was hidden" compilation warnings

Signed-off-by: Orit Wasserman <owasserm@redhat.com>

diff --git a/src/common/WorkQueue.h b/src/common/WorkQueue.h
index 7c50aae670bce8f84f79ffd4a9e0c6cab7ee2559..cf48b81992b2252a6d98d676b31cc18e255d7795 100644 (file)
--- a/src/common/WorkQueue.h
+++ b/src/common/WorkQueue.h
@@ -102,10 +102,6 @@ public:
     virtual bool _enqueue(T *) = 0;
     virtual void _dequeue(T *) = 0;
     virtual void _dequeue(list<T*> *) = 0;
-    virtual void _process(const list<T*> &) { assert(0); }
-    virtual void _process(const list<T*> &items, TPHandle &handle) {
-      _process(items);
-    }
     virtual void _process_finish(const list<T*> &) {}
 
     // virtual methods from WorkQueue_ below
@@ -127,6 +123,12 @@ public:
       delete (list<T*> *)p;
     }
 
+  protected:
+    virtual void _process(const list<T*> &) { assert(0); }
+    virtual void _process(const list<T*> &items, TPHandle &handle) {
+      _process(items);
+    }
+
   public:
     BatchWorkQueue(string n, time_t ti, time_t sti, ThreadPool* p)
       : WorkQueue_(n, ti, sti), pool(p) {
@@ -187,10 +189,6 @@ public:
     virtual void _enqueue_front(T) = 0;
     virtual bool _empty() = 0;
     virtual U _dequeue() = 0;
-    virtual void _process(U) { assert(0); }
-    virtual void _process(U u, TPHandle &) {
-      _process(u);
-    }
     virtual void _process_finish(U) {}
 
     void *_void_dequeue() {
@@ -257,6 +255,10 @@ public:
     void unlock() {
       pool->unlock();
     }
+    virtual void _process(U) { assert(0); }
+    virtual void _process(U u, TPHandle &) {
+      _process(u);
+    }
   };
 
   /** @brief Template by-pointer work queue.
@@ -274,11 +276,6 @@ public:
     virtual void _dequeue(T *) = 0;
     /// Dequeue a work item and return the original submitted pointer.
     virtual T *_dequeue() = 0;
-    /// Process a work item. Called from the worker threads.
-    virtual void _process(T *t) { assert(0); }
-    virtual void _process(T *t, TPHandle &) {
-      _process(t);
-    }
     virtual void _process_finish(T *) {}
 
     // implementation of virtual methods from WorkQueue_
@@ -292,6 +289,13 @@ public:
       _process_finish(static_cast<T *>(p));
     }
 
+  protected:
+    /// Process a work item. Called from the worker threads.
+    virtual void _process(T *t) { assert(0); }
+    virtual void _process(T *t, TPHandle &) {
+      _process(t);
+    }
+
   public:
     WorkQueue(string n, time_t ti, time_t sti, ThreadPool* p) : WorkQueue_(n, ti, sti), pool(p) {
       pool->add_work_queue(this);
@@ -453,6 +457,7 @@ public:
     _queue.pop_front();
     return c;
   }
+  using WorkQueueVal<GenContext<ThreadPool::TPHandle&>*>::_process;
   void _process(GenContext<ThreadPool::TPHandle&> *c, ThreadPool::TPHandle &tp) {
     c->complete(tp);
   }
@@ -499,6 +504,7 @@ protected:
   virtual void _process(std::pair<Context *, int> item) {
     item.first->complete(item.second);
   }
+  using ThreadPool::WorkQueueVal<std::pair<Context *, int> >::_process;
 private:
   list<std::pair<Context *, int> > _queue;
 };

diff --git a/src/mon/OSDMonitor.cc b/src/mon/OSDMonitor.cc
index 6d35f97fc533caa00f9d684f2c5ff6e3864aaf05..322b98c79eca90ff29e1c9df0dbe83657d7db71a 100644 (file)
--- a/src/mon/OSDMonitor.cc
+++ b/src/mon/OSDMonitor.cc
@@ -779,6 +779,7 @@ protected:
   };
   friend std::ostream &operator<<(ostream& out, const lowprecision_t& v);
 
+  using OSDUtilizationDumper<TextTable>::dump_item;
   virtual void dump_item(const CrushTreeDumper::Item &qi,
                         float &reweight,
                         int64_t kb,
@@ -857,6 +858,7 @@ public:
   }
 
 protected:
+  using OSDUtilizationDumper<Formatter>::dump_item;
   virtual void dump_item(const CrushTreeDumper::Item &qi,
                         float &reweight,
                         int64_t kb,

diff --git a/src/os/FileStore.h b/src/os/FileStore.h
index d81e96794a1449aba979522eab47bf4704c48892..2eb58fc393727bba470b0e11c5edd0fae2ae2f68 100644 (file)
--- a/src/os/FileStore.h
+++ b/src/os/FileStore.h
@@ -363,6 +363,7 @@ private:
     void _process(OpSequencer *osr, ThreadPool::TPHandle &handle) {
       store->_do_op(osr, handle);
     }
+    using ThreadPool::WorkQueue<OpSequencer>::_process;
     void _process_finish(OpSequencer *osr) {
       store->_finish_op(osr);
     }
@@ -570,6 +571,7 @@ public:
   void do_force_sync();
   void start_sync(Context *onsafe);
   void sync();
+  using JournalingObjectStore::sync;
   void _flush_op_queue();
   void flush();
   void sync_and_flush();

diff --git a/src/os/KeyValueStore.h b/src/os/KeyValueStore.h
index 94a1408f7f2b4ce7e79d9dff34f83edd198599eb..3c857420b5dd5dfe73325beb042935a2b45b1558 100644 (file)
--- a/src/os/KeyValueStore.h
+++ b/src/os/KeyValueStore.h
@@ -447,6 +447,7 @@ class KeyValueStore : public ObjectStore,
       store->op_queue.pop_front();
       return osr;
     }
+    using ThreadPool::WorkQueue<OpSequencer>::_process;
     void _process(OpSequencer *osr, ThreadPool::TPHandle &handle) {
       store->_do_op(osr, handle);
     }
@@ -578,6 +579,7 @@ class KeyValueStore : public ObjectStore,
 
   void start_sync() {}
   void sync() {}
+  using ObjectStore::sync;
   void flush() {}
   void sync_and_flush() {}
 

diff --git a/src/osd/OSD.h b/src/osd/OSD.h
index e568505afc045437540e98ccd21c138156e69c60..a5d429fabb44c2035c6fbd36c444d5d41fee9ff2 100644 (file)
--- a/src/osd/OSD.h
+++ b/src/osd/OSD.h
@@ -1748,6 +1748,7 @@ private:
        (*i)->put("PeeringWQ");
       }
     }
+    using ThreadPool::BatchWorkQueue<PG>::_process;
     void _process_finish(const list<PG *> &pgs) {
       for (list<PG*>::const_iterator i = pgs.begin();
           i != pgs.end();
@@ -2124,6 +2125,9 @@ protected:
       osd->osd_lock.Unlock();
       delete c;
     }
+    void _process(Command *c, ThreadPool::TPHandle &tp) {
+      _process(c);
+    }
     void _clear() {
       while (!osd->command_queue.empty()) {
        Command *c = osd->command_queue.front();
@@ -2179,6 +2183,7 @@ protected:
       osd->do_recovery(pg, handle);
       pg->put("RecoveryWQ");
     }
+    using ThreadPool::WorkQueue<PG>::_process;
     void _clear() {
       while (!osd->recovery_queue.empty()) {
        PG *pg = osd->recovery_queue.front();
@@ -2233,6 +2238,7 @@ protected:
       remove_queue.pop_front();
       return item;
     }
+    using ThreadPool::WorkQueueVal<pair<PGRef, DeletingStateRef> >::_process;
     void _process(pair<PGRef, DeletingStateRef>, ThreadPool::TPHandle &);
     void _clear() {
       remove_queue.clear();

diff --git a/src/osd/ReplicatedBackend.cc b/src/osd/ReplicatedBackend.cc
index 5e03aa78f3580eb5f94a6948a3f0faf80ce8c305..2015dd0b6f5e08ee820fd975ff564e3ce34e3a5b 100644 (file)
--- a/src/osd/ReplicatedBackend.cc
+++ b/src/osd/ReplicatedBackend.cc
@@ -469,6 +469,7 @@ public:
                       expected_write_size);
   }
 
+  using PGBackend::PGTransaction::append;
   void append(
     PGTransaction *_to_append
     ) {

diff --git a/src/osd/ReplicatedPG.h b/src/osd/ReplicatedPG.h
index 2dbda17eac0590dc4bb514ff21bd219d8e725dbd..9c280365da27f7f6b8053a138c0fd8a2ce1d202e 100644 (file)
--- a/src/osd/ReplicatedPG.h
+++ b/src/osd/ReplicatedPG.h
@@ -360,9 +360,11 @@ public:
   const map<pg_shard_t, pg_missing_t> &get_shard_missing() const {
     return peer_missing;
   }
+  using PGBackend::Listener::get_shard_missing;
   const map<pg_shard_t, pg_info_t> &get_shard_info() const {
     return peer_info;
   }
+  using PGBackend::Listener::get_shard_info;  
   const pg_missing_t &get_local_missing() const {
     return pg_log.get_missing();
   }

diff --git a/src/rgw/rgw_main.cc b/src/rgw/rgw_main.cc
index caab642327c5ed2d08d4309de796cc3cab016e7b..7e83404e49fb6a23012176277255e898c335ac9b 100644 (file)
--- a/src/rgw/rgw_main.cc
+++ b/src/rgw/rgw_main.cc
@@ -214,6 +214,7 @@ protected:
       perfcounter->inc(l_rgw_qlen, -1);
       return req;
     }
+    using ThreadPool::WorkQueue<RGWRequest>::_process;
     void _process(RGWRequest *req) {
       perfcounter->inc(l_rgw_qactive);
       process->handle_request(req);

diff --git a/src/rgw/rgw_rest_s3.h b/src/rgw/rgw_rest_s3.h
index 1a92a8c2257f75aedc2ebf98917dbe8e99f26495..5db03dadc95038ddefd621bb7b816f03cc64a65b 100644 (file)
--- a/src/rgw/rgw_rest_s3.h
+++ b/src/rgw/rgw_rest_s3.h
@@ -372,7 +372,8 @@ public:
   virtual ~RGWHandler_ObjStore_S3() {}
 
   int validate_bucket_name(const string& bucket, bool relaxed_names);
-
+  using RGWHandler_ObjStore::validate_bucket_name;
+  
   virtual int init(RGWRados *store, struct req_state *state, RGWClientIO *cio);
   virtual int authorize() {
     return RGW_Auth_S3::authorize(store, s);
@@ -441,9 +442,6 @@ public:
   RGWRESTMgr_S3() {}
   virtual ~RGWRESTMgr_S3() {}
 
-  virtual RGWRESTMgr *get_resource_mgr(struct req_state *s, const string& uri) {
-    return this;
-  }
   virtual RGWHandler *get_handler(struct req_state *s);
 };
 

diff --git a/src/rgw/rgw_rest_swift.h b/src/rgw/rgw_rest_swift.h
index 20c742a828064bf237db9f32d7a715bba36047c8..22283e468a0d2426c46672949c2f4d7244994085 100644 (file)
--- a/src/rgw/rgw_rest_swift.h
+++ b/src/rgw/rgw_rest_swift.h
@@ -235,9 +235,6 @@ public:
   RGWRESTMgr_SWIFT() {}
   virtual ~RGWRESTMgr_SWIFT() {}
 
-  virtual RGWRESTMgr *get_resource_mgr(struct req_state *s, const string& uri) {
-    return this;
-  }
   virtual RGWHandler *get_handler(struct req_state *s);
 };
 

diff --git a/src/test/bench/dumb_backend.h b/src/test/bench/dumb_backend.h
index 218e46c2fe8b5f28acb26e252f7a6eaed024d5ac..b3a19a7b9367563240b1374810e62e5b772d51fb 100644 (file)
--- a/src/test/bench/dumb_backend.h
+++ b/src/test/bench/dumb_backend.h
@@ -84,6 +84,7 @@ class DumbBackend : public Backend {
     bool _empty() {
       return item_queue.empty();
     }
+    using ThreadPool::WorkQueue<write_item>::_process;
     void _process(write_item *item) {
       return backend->_write(
        item->oid,

diff --git a/src/test/bench/tp_bench.cc b/src/test/bench/tp_bench.cc
index b9d5ff17c8f85777728d22700fcd03355fb6d84d..23185a769777c527c19e4b891ba74a59450bc596 100644 (file)
--- a/src/test/bench/tp_bench.cc
+++ b/src/test/bench/tp_bench.cc
@@ -93,6 +93,7 @@ class PassAlong : public ThreadPool::WorkQueue<unsigned> {
     q.pop_front();
     return val;
   }
+  using ThreadPool::WorkQueue<unsigned>::_process;
   void _process(unsigned *item) {
     next->queue(item);
   }