rgw: buckets within tenant namespacewip-5073-2

Signed-off-by: Yehuda Sadeh <yehuda@inktank.com>

9 files changed, 123 insertions, 55 deletions

diff --git a/src/rgw/rgw_admin.cc b/src/rgw/rgw_admin.cc
index 71acb8a7f6f..0046b1f121a 100644
--- a/src/rgw/rgw_admin.cc
+++ b/src/rgw/rgw_admin.cc
@@ -339,7 +339,7 @@ static void dump_bucket_usage(map<RGWObjCategory, RGWBucketStats>& stats, Format
 int bucket_stats(rgw_bucket& bucket, Formatter *formatter)
 {
   RGWBucketInfo bucket_info;
-  int r = store->get_bucket_info(NULL, bucket.name, bucket_info);
+  int r = store->get_bucket_info(NULL, bucket.tenant, bucket.name, bucket_info);
   if (r < 0)
     return r;
 
@@ -371,11 +371,11 @@ public:
   }
 };
 
-static int init_bucket(string& bucket_name, rgw_bucket& bucket)
+static int init_bucket(string& tenant, string& bucket_name, rgw_bucket& bucket)
 {
   if (!bucket_name.empty()) {
     RGWBucketInfo bucket_info;
-    int r = store->get_bucket_info(NULL, bucket_name, bucket_info);
+    int r = store->get_bucket_info(NULL, tenant, bucket_name, bucket_info);
     if (r < 0) {
       cerr << "could not get bucket info for bucket=" << bucket_name << std::endl;
       return r;
@@ -455,6 +455,7 @@ int main(int argc, char **argv)
   common_init_finish(g_ceph_context);
 
   rgw_user user_id;
+  string tenant;
   std::string access_key, secret_key, user_email, display_name;
   std::string bucket_name, pool_name, object;
   std::string date, subuser, access, format;
@@ -500,7 +501,14 @@ int main(int argc, char **argv)
       usage();
       return 0;
     } else if (ceph_argparse_witharg(args, i, &val, "-i", "--uid", (char*)NULL)) {
-      user_id.from_str(val);
+      string s = val;
+      if (!tenant.empty()) {
+        s = tenant + ":" + val;
+      }
+      user_id.from_str(s);
+      tenant = user_id.tenant;
+    } else if (ceph_argparse_witharg(args, i, &val, "--tenant", (char*)NULL)) {
+      tenant = val;
     } else if (ceph_argparse_witharg(args, i, &val, "--access-key", (char*)NULL)) {
       access_key = val;
     } else if (ceph_argparse_witharg(args, i, &val, "--subuser", (char*)NULL)) {
@@ -716,6 +724,7 @@ int main(int argc, char **argv)
 
   /* populate bucket operation */
   bucket_op.set_bucket_name(bucket_name);
+  bucket_op.set_tenant(tenant);
   bucket_op.set_object(object);
   bucket_op.set_check_objects(check_objects);
   bucket_op.set_delete_children(delete_child_objects);
@@ -1115,7 +1124,7 @@ next:
   }
 
   if (opt_cmd == OPT_OBJECT_RM) {
-    int ret = init_bucket(bucket_name, bucket);
+    int ret = init_bucket(tenant, bucket_name, bucket);
     if (ret < 0) {
       cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
       return -ret;
@@ -1129,7 +1138,7 @@ next:
   }
 
   if (opt_cmd == OPT_OBJECT_UNLINK) {
-    int ret = init_bucket(bucket_name, bucket);
+    int ret = init_bucket(tenant, bucket_name, bucket);
     if (ret < 0) {
       cerr << "ERROR: could not init bucket: " << cpp_strerror(-ret) << std::endl;
       return -ret;
diff --git a/src/rgw/rgw_bucket.cc b/src/rgw/rgw_bucket.cc
index cc0ad0d2eb1..2a6261cc018 100644
--- a/src/rgw/rgw_bucket.cc
+++ b/src/rgw/rgw_bucket.cc
@@ -135,7 +135,7 @@ int rgw_remove_user_bucket_info(RGWRados *store, rgw_user& user_id, rgw_bucket&
   return ret;
 }
 
-int RGWBucket::create_bucket(string bucket_str, rgw_user& user_id, string& display_name)
+int RGWBucket::create_bucket(string& bucket_str, rgw_user& user_id, string& display_name)
 {
   RGWAccessControlPolicy policy, old_policy;
   map<string, bufferlist> attrs;
@@ -146,11 +146,11 @@ int RGWBucket::create_bucket(string bucket_str, rgw_user& user_id, string& displ
 
   int ret;
 
-  // defaule policy (private)
+  // default policy (private)
   policy.create_default(user_id, display_name);
   policy.encode(aclbl);
 
-  ret = store->get_bucket_info(NULL, bucket_str, bucket_info);
+  ret = store->get_bucket_info(NULL, user_id.tenant, bucket_str, bucket_info);
   if (ret < 0)
     return ret;
 
@@ -218,7 +218,7 @@ void check_bad_user_bucket_mapping(RGWRados *store, const rgw_user& user_id, boo
       rgw_bucket& bucket = bucket_ent.bucket;
 
       RGWBucketInfo bucket_info;
-      int r = store->get_bucket_info(NULL, bucket.name, bucket_info);
+      int r = store->get_bucket_info(NULL, user_id.tenant, bucket.name, bucket_info);
       if (r < 0) {
         ldout(store->ctx(), 0) << "could not get bucket info for bucket=" << bucket << dendl;
         continue;
@@ -227,6 +227,7 @@ void check_bad_user_bucket_mapping(RGWRados *store, const rgw_user& user_id, boo
       rgw_bucket& actual_bucket = bucket_info.bucket;
 
       if (actual_bucket.name.compare(bucket.name) != 0 ||
+          actual_bucket.tenant.compare(bucket.tenant) != 0 ||
           actual_bucket.pool.compare(bucket.pool) != 0 ||
           actual_bucket.marker.compare(bucket.marker) != 0 ||
           actual_bucket.bucket_id.compare(bucket.bucket_id) != 0) {
@@ -347,13 +348,14 @@ int RGWBucket::init(RGWRados *storage, RGWBucketAdminOpState& op_state)
 
   user_id = op_state.get_user_id();
   bucket_name = op_state.get_bucket_name();
+  tenant = op_state.get_tenant();
   RGWUserBuckets user_buckets;
 
   if (bucket_name.empty() && user_id.empty())
     return -EINVAL;
 
   if (!bucket_name.empty()) {
-    int r = store->get_bucket_info(NULL, bucket_name, bucket_info);
+    int r = store->get_bucket_info(NULL, tenant, bucket_name, bucket_info);
     if (r < 0) {
       ldout(store->ctx(), 0) << "could not get bucket info for bucket=" << bucket_name << dendl;
       return r;
@@ -434,7 +436,7 @@ int RGWBucket::link(RGWBucketAdminOpState& op_state, std::string *err_msg)
       return r;
   } else {
     // the bucket seems not to exist, so we should probably create it...
-    r = create_bucket(bucket_name.c_str(), user_id, display_name);
+    r = create_bucket(bucket_name, user_id, display_name);
     if (r < 0) {
       set_err_msg(err_msg, "error linking bucket to user r=" + cpp_strerror(-r));
     }
@@ -829,13 +831,13 @@ int RGWBucketAdminOp::remove_object(RGWRados *store, RGWBucketAdminOpState& op_s
   return bucket.remove_object(op_state);
 }
 
-static int bucket_stats(RGWRados *store, std::string&  bucket_name, Formatter *formatter)
+static int bucket_stats(RGWRados *store, std::string& tenant, std::string&  bucket_name, Formatter *formatter)
 {
   RGWBucketInfo bucket_info;
   rgw_bucket bucket;
   map<RGWObjCategory, RGWBucketStats> stats;
 
-  int r = store->get_bucket_info(NULL, bucket_name, bucket_info);
+  int r = store->get_bucket_info(NULL, tenant, bucket_name, bucket_info);
   if (r < 0)
     return r;
 
@@ -878,6 +880,7 @@ int RGWBucketAdminOp::info(RGWRados *store, RGWBucketAdminOpState& op_state,
   size_t max_entries = cct->_conf->rgw_list_buckets_max_chunk;
 
   bool show_stats = op_state.will_fetch_stats();
+  string tenant = op_state.get_tenant();
   if (op_state.is_user_op()) {
     formatter->open_array_section("buckets");
 
@@ -896,7 +899,7 @@ int RGWBucketAdminOp::info(RGWRados *store, RGWBucketAdminOpState& op_state,
       for (iter = m.begin(); iter != m.end(); ++iter) {
         std::string  obj_name = iter->first;
         if (show_stats)
-          bucket_stats(store, obj_name, formatter);
+          bucket_stats(store, tenant, obj_name, formatter);
         else
           formatter->dump_string("bucket", obj_name);
 
@@ -909,7 +912,7 @@ int RGWBucketAdminOp::info(RGWRados *store, RGWBucketAdminOpState& op_state,
 
     formatter->close_section();
   } else if (!bucket_name.empty()) {
-    bucket_stats(store, bucket_name, formatter);
+    bucket_stats(store, tenant, bucket_name, formatter);
   } else {
     RGWAccessHandle handle;
 
@@ -918,7 +921,7 @@ int RGWBucketAdminOp::info(RGWRados *store, RGWBucketAdminOpState& op_state,
       while (store->list_buckets_next(obj, &handle) >= 0) {
 	formatter->dump_string("bucket", obj.name);
         if (show_stats)
-          bucket_stats(store, obj.name, formatter);
+          bucket_stats(store, tenant, obj.name, formatter);
       }
     }
   }
diff --git a/src/rgw/rgw_bucket.h b/src/rgw/rgw_bucket.h
index 872c404c8de..7c285eb8511 100644
--- a/src/rgw/rgw_bucket.h
+++ b/src/rgw/rgw_bucket.h
@@ -101,6 +101,7 @@ extern void check_bad_user_bucket_mapping(RGWRados *store, const rgw_user& user_
 
 struct RGWBucketAdminOpState {
   rgw_user uid;
+  std::string tenant;
   std::string display_name;
   std::string bucket_name;
   std::string bucket_id;
@@ -123,6 +124,10 @@ struct RGWBucketAdminOpState {
   void set_user_id(rgw_user& user_id) {
     if (!user_id.empty())
       uid = user_id;
+    tenant = uid.tenant;
+  }
+  void set_tenant(string& t) {
+    tenant = t;
   }
   void set_bucket_name(std::string& bucket_str) {
     bucket_name = bucket_str; 
@@ -135,6 +140,7 @@ struct RGWBucketAdminOpState {
   std::string& get_user_display_name() { return display_name; };
   std::string& get_bucket_name() { return bucket_name; };
   std::string& get_object_name() { return object_name; };
+  std::string& get_tenant() { return tenant; };
 
   rgw_bucket& get_bucket() { return bucket; };
   void set_bucket(rgw_bucket& _bucket) {
@@ -166,6 +172,7 @@ class RGWBucket
   RGWAccessHandle handle;
 
   rgw_user user_id;
+  std::string tenant;
   std::string bucket_name;
 
   bool failure;
@@ -176,7 +183,7 @@ public:
   RGWBucket() : store(NULL), handle(NULL), failure(false) {}
   int init(RGWRados *storage, RGWBucketAdminOpState& op_state);
 
-  int create_bucket(string bucket_str, rgw_user& user_id, string& display_name);
+  int create_bucket(string& bucket_str, rgw_user& user_id, string& display_name);
   
   int check_bad_index_multipart(RGWBucketAdminOpState& op_state,
           list<std::string>& objs_to_unlink, std::string *err_msg = NULL);
diff --git a/src/rgw/rgw_common.h b/src/rgw/rgw_common.h
index 3d3592ecc07..3724029ece8 100644
--- a/src/rgw/rgw_common.h
+++ b/src/rgw/rgw_common.h
@@ -493,6 +493,7 @@ struct RGWUserInfo
 WRITE_CLASS_ENCODER(RGWUserInfo)
 
 struct rgw_bucket {
+  std::string tenant;
   std::string name;
   std::string pool;
   std::string marker;
@@ -503,19 +504,20 @@ struct rgw_bucket {
     assert(*n == '.'); // only rgw private buckets should be initialized without pool
     pool = n;
   }
-  rgw_bucket(const char *n, const char *p, const char *m, const char *id) :
-    name(n), pool(p), marker(m), bucket_id(id) {}
 
+  rgw_bucket(const char *t, const char *n, const char *p, const char *m, const char *id) :
+    tenant(t), name(n), pool(p), marker(m), bucket_id(id) {}
   void encode(bufferlist& bl) const {
-     ENCODE_START(4, 3, bl);
+     ENCODE_START(5, 3, bl);
     ::encode(name, bl);
     ::encode(pool, bl);
     ::encode(marker, bl);
     ::encode(bucket_id, bl);
+    ::encode(tenant, bl);
     ENCODE_FINISH(bl);
   }
   void decode(bufferlist::iterator& bl) {
-    DECODE_START_LEGACY_COMPAT_LEN(4, 3, 3, bl);
+    DECODE_START_LEGACY_COMPAT_LEN(5, 3, 3, bl);
     ::decode(name, bl);
     ::decode(pool, bl);
     if (struct_v >= 2) {
@@ -530,6 +532,8 @@ struct rgw_bucket {
         ::decode(bucket_id, bl);
       }
     }
+    if (struct_v >= 5)
+      ::decode(tenant, bl);
     DECODE_FINISH(bl);
   }
   void dump(Formatter *f) const;
@@ -559,6 +563,7 @@ struct RGWBucketInfo
      ::encode(bucket, bl);
      ::encode(owner.id, bl);
      ::encode(flags, bl);
+     ::encode(owner, bl);
      ENCODE_FINISH(bl);
   }
   void decode(bufferlist::iterator& bl) {
@@ -637,6 +642,7 @@ struct req_state {
    bool has_bad_meta;
 
    RGWUserInfo user; 
+   string tenant;
    RGWAccessControlPolicy *bucket_acl;
    RGWAccessControlPolicy *object_acl;
    RGWCORSConfiguration   *bucket_cors;
diff --git a/src/rgw/rgw_dencoder.cc b/src/rgw/rgw_dencoder.cc
index 3626c9a84e1..0447533f72d 100644
--- a/src/rgw/rgw_dencoder.cc
+++ b/src/rgw/rgw_dencoder.cc
@@ -13,7 +13,7 @@ void RGWObjManifestPart::generate_test_instances(std::list<RGWObjManifestPart*>&
   o.push_back(new RGWObjManifestPart);
 
   RGWObjManifestPart *p = new RGWObjManifestPart;
-  rgw_bucket b("bucket", ".pool", "marker_", "12");
+  rgw_bucket b("tenant", "bucket", ".pool", "marker_", "12");
   p->loc = rgw_obj(b, "object");
   p->loc_ofs = 512 * 1024;
   p->size = 128 * 1024;
@@ -25,7 +25,7 @@ void RGWObjManifest::generate_test_instances(std::list<RGWObjManifest*>& o)
   RGWObjManifest *m = new RGWObjManifest;
   for (int i = 0; i<10; i++) {
     RGWObjManifestPart p;
-    rgw_bucket b("bucket", ".pool", "marker_", "12");
+    rgw_bucket b("tenant", "bucket", ".pool", "marker_", "12");
     p.loc = rgw_obj(b, "object");
     p.loc_ofs = 0;
     p.size = 512 * 1024;
@@ -63,7 +63,7 @@ void rgw_log_entry::generate_test_instances(list<rgw_log_entry*>& o)
 void rgw_intent_log_entry::generate_test_instances(list<rgw_intent_log_entry*>& o)
 {
   rgw_intent_log_entry *e = new rgw_intent_log_entry;
-  rgw_bucket b("bucket", "pool", "marker", "10");
+  rgw_bucket b("tenant", "bucket", "pool", "marker", "10");
   e->obj = rgw_obj(b, "object");
   e->intent = DEL_OBJ;
   o.push_back(e);
@@ -254,7 +254,7 @@ void RGWUserInfo::generate_test_instances(list<RGWUserInfo*>& o)
 
 void rgw_bucket::generate_test_instances(list<rgw_bucket*>& o)
 {
-  rgw_bucket *b = new rgw_bucket("name", "pool", "marker", "123");
+  rgw_bucket *b = new rgw_bucket("tenant", "name", "pool", "marker", "123");
   o.push_back(b);
   o.push_back(new rgw_bucket);
 }
@@ -262,7 +262,7 @@ void rgw_bucket::generate_test_instances(list<rgw_bucket*>& o)
 void RGWBucketInfo::generate_test_instances(list<RGWBucketInfo*>& o)
 {
   RGWBucketInfo *i = new RGWBucketInfo;
-  i->bucket = rgw_bucket("bucket", "pool", "marker", "10");
+  i->bucket = rgw_bucket("tenant", "bucket", "pool", "marker", "10");
   i->owner = "owner";
   i->flags = BUCKET_SUSPENDED;
   o.push_back(i);
@@ -272,7 +272,7 @@ void RGWBucketInfo::generate_test_instances(list<RGWBucketInfo*>& o)
 void RGWBucketEnt::generate_test_instances(list<RGWBucketEnt*>& o)
 {
   RGWBucketEnt *e = new RGWBucketEnt;
-  e->bucket = rgw_bucket("bucket", "pool", "marker", "10");
+  e->bucket = rgw_bucket("tenant", "bucket", "pool", "marker", "10");
   e->size = 1024;
   e->size_rounded = 4096;
   e->count = 1;
@@ -292,7 +292,7 @@ void RGWUploadPartInfo::generate_test_instances(list<RGWUploadPartInfo*>& o)
 
 void rgw_obj::generate_test_instances(list<rgw_obj*>& o)
 {
-  rgw_bucket b = rgw_bucket("bucket", "pool", "marker", "10");
+  rgw_bucket b = rgw_bucket("tenant", "bucket", "pool", "marker", "10");
   rgw_obj *obj = new rgw_obj(b, "object");
   o.push_back(obj);
   o.push_back(new rgw_obj);
diff --git a/src/rgw/rgw_op.cc b/src/rgw/rgw_op.cc
index a482187cac7..7cdd785847e 100644
--- a/src/rgw/rgw_op.cc
+++ b/src/rgw/rgw_op.cc
@@ -213,7 +213,7 @@ static int get_policy_from_attr(CephContext *cct, RGWRados *store, void *ctx, RG
       /* object exists, but policy is broken */
       RGWBucketInfo info;
       RGWUserInfo uinfo;
-      int r = store->get_bucket_info(ctx, obj.bucket.name, info);
+      int r = store->get_bucket_info(ctx, obj.bucket.tenant, obj.bucket.name, info);
       if (r < 0)
         goto done;
       r = rgw_get_user_info_by_uid(store, info.owner, uinfo);
@@ -295,7 +295,7 @@ int rgw_build_policies(RGWRados *store, struct req_state *s, bool only_bucket, b
 
   RGWBucketInfo bucket_info;
   if (s->bucket_name_str.size()) {
-    ret = store->get_bucket_info(s->obj_ctx, s->bucket_name_str, bucket_info);
+    ret = store->get_bucket_info(s->obj_ctx, s->tenant, s->bucket_name_str, bucket_info);
     if (ret < 0) {
       ldout(s->cct, 0) << "NOTICE: couldn't get bucket from bucket_name (name=" << s->bucket_name_str << ")" << dendl;
       return ret;
@@ -510,7 +510,7 @@ int RGWGetObj::handle_user_manifest(const char *prefix)
 
   if (bucket_name.compare(s->bucket.name) != 0) {
     RGWBucketInfo bucket_info;
-    int r = store->get_bucket_info(NULL, bucket_name, bucket_info);
+    int r = store->get_bucket_info(NULL, s->tenant, bucket_name, bucket_info);
     if (r < 0) {
       ldout(s->cct, 0) << "could not get bucket info for bucket=" << bucket_name << dendl;
       return r;
@@ -896,7 +896,7 @@ void RGWCreateBucket::execute()
      */
     RGWBucketInfo info;
     map<string, bufferlist> attrs;
-    int r = store->get_bucket_info(NULL, s->bucket.name, info, &attrs);
+    int r = store->get_bucket_info(NULL, s->tenant, s->bucket.name, info, &attrs);
     if (r < 0) {
       ldout(s->cct, 0) << "ERROR: get_bucket_info on bucket=" << s->bucket.name << " returned err=" << r << " after create_bucket returned -EEXIST" << dendl;
       ret = r;
@@ -1674,7 +1674,7 @@ int RGWCopyObj::verify_permission()
 
   /* get buckets info (source and dest) */
 
-  ret = store->get_bucket_info(s->obj_ctx, src_bucket_name, src_bucket_info);
+  ret = store->get_bucket_info(s->obj_ctx, s->tenant, src_bucket_name, src_bucket_info);
   if (ret < 0)
     return ret;
 
@@ -1683,7 +1683,7 @@ int RGWCopyObj::verify_permission()
   if (src_bucket_name.compare(dest_bucket_name) == 0) {
     dest_bucket_info = src_bucket_info;
   } else {
-    ret = store->get_bucket_info(s->obj_ctx, dest_bucket_name, dest_bucket_info);
+    ret = store->get_bucket_info(s->obj_ctx, s->tenant, dest_bucket_name, dest_bucket_info);
     if (ret < 0)
       return ret;
   }
diff --git a/src/rgw/rgw_rados.cc b/src/rgw/rgw_rados.cc
index e03dae532e3..3866d807bd1 100644
--- a/src/rgw/rgw_rados.cc
+++ b/src/rgw/rgw_rados.cc
@@ -61,6 +61,20 @@ static RGWObjCategory main_category = RGW_OBJ_CATEGORY_MAIN;
 
 #define dout_subsys ceph_subsys_rgw
 
+static void get_bucket_oid(const string& tenant, const string& bucket_name, string& oid)
+{
+  if (!tenant.empty()) {
+    oid = tenant + ':' + bucket_name;
+  } else {
+    oid = bucket_name;
+  }
+}
+
+static void get_bucket_oid(const rgw_bucket& bucket, string& oid)
+{
+  get_bucket_oid(bucket.tenant, bucket.name, oid);
+}
+
 void RGWZoneParams::init_default()
 {
   domain_root = ".rgw";
@@ -183,7 +197,9 @@ RGWObjState *RGWRadosCtx::get_state(rgw_obj& obj) {
   if (obj.object.size()) {
     return &objs_state[obj];
   } else {
-    rgw_obj new_obj(store->zone.domain_root, obj.bucket.name);
+    string oid;
+    get_bucket_oid(obj.bucket, oid);
+    rgw_obj new_obj(store->zone.domain_root, oid);
     return &objs_state[new_obj];
   }
 }
@@ -192,7 +208,9 @@ void RGWRadosCtx::set_atomic(rgw_obj& obj) {
   if (obj.object.size()) {
     objs_state[obj].is_atomic = true;
   } else {
-    rgw_obj new_obj(store->zone.domain_root, obj.bucket.name);
+    string oid;
+    get_bucket_oid(obj.bucket, oid);
+    rgw_obj new_obj(store->zone.domain_root, oid);
     objs_state[new_obj].is_atomic = true;
   }
 }
@@ -201,7 +219,9 @@ void RGWRadosCtx::set_prefetch_data(rgw_obj& obj) {
   if (obj.object.size()) {
     objs_state[obj].prefetch_data = true;
   } else {
-    rgw_obj new_obj(store->zone.domain_root, obj.bucket.name);
+    string oid;
+    get_bucket_oid(obj.bucket, oid);
+    rgw_obj new_obj(store->zone.domain_root, oid);
     objs_state[new_obj].prefetch_data = true;
   }
 }
@@ -389,7 +409,9 @@ int RGWRados::open_bucket_ctx(rgw_bucket& bucket, librados::IoCtx&  io_ctx)
      the bucket object .. which will trigger update of osdmap
      if that is the case */
   time_t mtime;
-  r = root_pool_ctx.stat(bucket.name, NULL, &mtime);
+  string oid;
+  get_bucket_oid(bucket, oid);
+  r = root_pool_ctx.stat(oid, NULL, &mtime);
   if (r < 0)
     return -ENOENT;
 
@@ -822,7 +844,7 @@ int RGWRados::create_bucket(rgw_user& owner, rgw_bucket& bucket,
 {
   int ret = 0;
 
-  ret = select_bucket_placement(bucket.name, bucket);
+  ret = select_bucket_placement(owner.tenant, bucket.name, bucket);
   if (ret < 0)
     return ret;
   librados::IoCtx io_ctx; // context for new bucket
@@ -874,7 +896,10 @@ int RGWRados::store_bucket_info(RGWBucketInfo& info, map<string, bufferlist> *pa
   bufferlist bl;
   ::encode(info, bl);
 
-  int ret = rgw_put_system_obj(this, zone.domain_root, info.bucket.name, bl.c_str(), bl.length(), exclusive, pattrs);
+  string oid;
+  get_bucket_oid(info.bucket, oid);
+
+  int ret = rgw_put_system_obj(this, zone.domain_root, oid, bl.c_str(), bl.length(), exclusive, pattrs);
   if (ret < 0)
     return ret;
 
@@ -883,7 +908,7 @@ int RGWRados::store_bucket_info(RGWBucketInfo& info, map<string, bufferlist> *pa
 }
 
 
-int RGWRados::select_bucket_placement(string& bucket_name, rgw_bucket& bucket)
+int RGWRados::select_bucket_placement(string& tenant, string& bucket_name, rgw_bucket& bucket)
 {
   bufferlist map_bl;
   map<string, bufferlist> m;
@@ -954,6 +979,7 @@ read_omap:
     pool_name = miter->first;
   }
   bucket.pool = pool_name;
+  bucket.tenant = tenant;
   bucket.name = bucket_name;
 
   return 0;
@@ -1553,7 +1579,10 @@ int RGWRados::delete_bucket(rgw_bucket& bucket)
     }
   } while (is_truncated);
 
-  rgw_obj obj(zone.domain_root, bucket.name);
+  string bucket_oid;
+  get_bucket_oid(bucket, bucket_oid);
+
+  rgw_obj obj(zone.domain_root, bucket_oid);
   r = delete_obj(NULL, obj);
   if (r < 0)
     return r;
@@ -1576,7 +1605,7 @@ int RGWRados::set_bucket_owner(rgw_bucket& bucket, ACLOwner& owner)
 {
   RGWBucketInfo info;
   map<string, bufferlist> attrs;
-  int r = get_bucket_info(NULL, bucket.name, info, &attrs);
+  int r = get_bucket_info(NULL, bucket.tenant, bucket.name, info, &attrs);
   if (r < 0) {
     ldout(cct, 0) << "NOTICE: get_bucket_info on bucket=" << bucket.name << " returned err=" << r << dendl;
     return r;
@@ -1584,7 +1613,7 @@ int RGWRados::set_bucket_owner(rgw_bucket& bucket, ACLOwner& owner)
 
   info.owner = owner.get_id();
 
-  r = put_bucket_info(bucket.name, info, false, &attrs);
+  r = put_bucket_info(bucket.tenant, bucket.name, info, false, &attrs);
   if (r < 0) {
     ldout(cct, 0) << "NOTICE: put_bucket_info on bucket=" << bucket.name << " returned err=" << r << dendl;
     return r;
@@ -1609,7 +1638,7 @@ int RGWRados::set_buckets_enabled(vector<rgw_bucket>& buckets, bool enabled)
 
     RGWBucketInfo info;
     map<string, bufferlist> attrs;
-    int r = get_bucket_info(NULL, bucket.name, info, &attrs);
+    int r = get_bucket_info(NULL, bucket.tenant, bucket.name, info, &attrs);
     if (r < 0) {
       ldout(cct, 0) << "NOTICE: get_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
       ret = r;
@@ -1621,7 +1650,7 @@ int RGWRados::set_buckets_enabled(vector<rgw_bucket>& buckets, bool enabled)
       info.flags |= BUCKET_SUSPENDED;
     }
 
-    r = put_bucket_info(bucket.name, info, false, &attrs);
+    r = put_bucket_info(bucket.tenant, bucket.name, info, false, &attrs);
     if (r < 0) {
       ldout(cct, 0) << "NOTICE: put_bucket_info on bucket=" << bucket.name << " returned err=" << r << ", skipping bucket" << dendl;
       ret = r;
@@ -1634,7 +1663,7 @@ int RGWRados::set_buckets_enabled(vector<rgw_bucket>& buckets, bool enabled)
 int RGWRados::bucket_suspended(rgw_bucket& bucket, bool *suspended)
 {
   RGWBucketInfo bucket_info;
-  int ret = get_bucket_info(NULL, bucket.name, bucket_info);
+  int ret = get_bucket_info(NULL, bucket.tenant, bucket.name, bucket_info);
   if (ret < 0) {
     return ret;
   }
@@ -3263,15 +3292,20 @@ int RGWRados::get_bucket_stats(rgw_bucket& bucket, map<RGWObjCategory, RGWBucket
   return 0;
 }
 
-int RGWRados::get_bucket_info(void *ctx, string& bucket_name, RGWBucketInfo& info, map<string, bufferlist> *pattrs)
+int RGWRados::get_bucket_info(void *ctx, const string& tenant, const string& bucket_name,
+                              RGWBucketInfo& info, map<string, bufferlist> *pattrs)
 {
   bufferlist bl;
 
-  int ret = rgw_get_obj(this, ctx, zone.domain_root, bucket_name, bl, pattrs);
+  string oid;
+  get_bucket_oid(tenant, bucket_name, oid);
+
+  int ret = rgw_get_obj(this, ctx, zone.domain_root, oid, bl, pattrs);
   if (ret < 0) {
     if (ret != -ENOENT)
       return ret;
 
+    info.bucket.tenant = tenant;
     info.bucket.name = bucket_name;
     info.bucket.pool = bucket_name; // for now
     return 0;
@@ -3290,13 +3324,18 @@ int RGWRados::get_bucket_info(void *ctx, string& bucket_name, RGWBucketInfo& inf
   return 0;
 }
 
-int RGWRados::put_bucket_info(string& bucket_name, RGWBucketInfo& info, bool exclusive, map<string, bufferlist> *pattrs)
+int RGWRados::put_bucket_info(const string& tenant, const string& bucket_name,
+                              RGWBucketInfo& info, bool exclusive,
+                              map<string, bufferlist> *pattrs)
 {
   bufferlist bl;
 
   ::encode(info, bl);
 
-  int ret = rgw_put_system_obj(this, zone.domain_root, bucket_name, bl.c_str(), bl.length(), exclusive, pattrs);
+  string oid;
+  get_bucket_oid(tenant, bucket_name, oid);
+
+  int ret = rgw_put_system_obj(this, zone.domain_root, oid, bl.c_str(), bl.length(), exclusive, pattrs);
 
   return ret;
 }
diff --git a/src/rgw/rgw_rados.h b/src/rgw/rgw_rados.h
index a1ab01f694e..45971d032be 100644
--- a/src/rgw/rgw_rados.h
+++ b/src/rgw/rgw_rados.h
@@ -375,7 +375,7 @@ class RGWRados
   int complete_atomic_overwrite(RGWRadosCtx *rctx, RGWObjState *state, rgw_obj& obj);
 
   int update_placement_map();
-  int select_bucket_placement(std::string& bucket_name, rgw_bucket& bucket);
+  int select_bucket_placement(std::string& tenant, std::string& bucket_name, rgw_bucket& bucket);
   int store_bucket_info(RGWBucketInfo& info, map<string, bufferlist> *pattrs, bool exclusive);
 
 protected:
@@ -701,8 +701,10 @@ public:
 
   int decode_policy(bufferlist& bl, ACLOwner *owner);
   int get_bucket_stats(rgw_bucket& bucket, map<RGWObjCategory, RGWBucketStats>& stats);
-  virtual int get_bucket_info(void *ctx, string& bucket_name, RGWBucketInfo& info, map<string, bufferlist> *pattrs = NULL);
-  virtual int put_bucket_info(string& bucket_name, RGWBucketInfo& info, bool exclusive, map<string, bufferlist> *pattrs);
+  virtual int get_bucket_info(void *ctx, const string& tenant, const string& bucket_name,
+                              RGWBucketInfo& info, map<string, bufferlist> *pattrs = NULL);
+  virtual int put_bucket_info(const string& tenant, const string& bucket_name, RGWBucketInfo& info,
+                              bool exclusive, map<string, bufferlist> *pattrs);
 
   int cls_rgw_init_index(librados::IoCtx& io_ctx, librados::ObjectWriteOperation& op, string& oid);
   int cls_obj_prepare_op(rgw_bucket& bucket, uint8_t op, string& tag,
diff --git a/src/rgw/rgw_rest_s3.cc b/src/rgw/rgw_rest_s3.cc
index 38fab1bd2c1..4a628f92360 100644
--- a/src/rgw/rgw_rest_s3.cc
+++ b/src/rgw/rgw_rest_s3.cc
@@ -2006,6 +2006,8 @@ int RGW_Auth_S3::authorize(RGWRados *store, struct req_state *s)
     return -EPERM;
   }
 
+  s->tenant = s->user.user_id.tenant;
+
   // populate the owner info
   s->owner.set_id(s->user.user_id);
   s->owner.set_name(s->user.display_name);