struct rbd_device *rbd_dev,
                          struct ceph_snap_context *snapc,
                          u64 snapid,
-                         const char *obj, u64 ofs, u64 len,
+                         const char *object_name, u64 ofs, u64 len,
                          struct bio *bio,
                          struct page **pages,
                          int num_pages,
                req_data->coll_index = coll_index;
        }
 
-       dout("rbd_do_request obj=%s ofs=%lld len=%lld\n", obj, len, ofs);
+       dout("rbd_do_request object_name=%s ofs=%lld len=%lld\n",
+               object_name, len, ofs);
 
        down_read(&rbd_dev->header_rwsem);
 
        reqhead = req->r_request->front.iov_base;
        reqhead->snapid = cpu_to_le64(CEPH_NOSNAP);
 
-       strncpy(req->r_oid, obj, sizeof(req->r_oid));
+       strncpy(req->r_oid, object_name, sizeof(req->r_oid));
        req->r_oid_len = strlen(req->r_oid);
 
        layout = &req->r_file_layout;
                           int flags,
                           struct ceph_osd_req_op *orig_ops,
                           int num_reply,
-                          const char *obj,
+                          const char *object_name,
                           u64 ofs, u64 len,
                           char *buf,
                           struct ceph_osd_request **linger_req,
        }
 
        ret = rbd_do_request(NULL, rbd_dev, snapc, snapid,
-                         obj, ofs, len, NULL,
+                         object_name, ofs, len, NULL,
                          pages, num_pages,
                          flags,
                          ops,
 static int rbd_req_sync_read(struct rbd_device *rbd_dev,
                          struct ceph_snap_context *snapc,
                          u64 snapid,
-                         const char *obj,
+                         const char *object_name,
                          u64 ofs, u64 len,
                          char *buf,
                          u64 *ver)
                               CEPH_OSD_OP_READ,
                               CEPH_OSD_FLAG_READ,
                               NULL,
-                              1, obj, ofs, len, buf, NULL, ver);
+                              1, object_name, ofs, len, buf, NULL, ver);
 }
 
 /*
 static int rbd_req_sync_notify_ack(struct rbd_device *rbd_dev,
                                   u64 ver,
                                   u64 notify_id,
-                                  const char *obj)
+                                  const char *object_name)
 {
        struct ceph_osd_req_op *ops;
        int ret;
        ops[0].watch.flag = 0;
 
        ret = rbd_do_request(NULL, rbd_dev, NULL, CEPH_NOSNAP,
-                         obj, 0, 0, NULL,
+                         object_name, 0, 0, NULL,
                          NULL, 0,
                          CEPH_OSD_FLAG_READ,
                          ops,
  * Request sync osd watch
  */
 static int rbd_req_sync_watch(struct rbd_device *rbd_dev,
-                             const char *obj,
+                             const char *object_name,
                              u64 ver)
 {
        struct ceph_osd_req_op *ops;
                              0,
                              CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
                              ops,
-                             1, obj, 0, 0, NULL,
+                             1, object_name, 0, 0, NULL,
                              &rbd_dev->watch_request, NULL);
 
        if (ret < 0)
  * Request sync osd unwatch
  */
 static int rbd_req_sync_unwatch(struct rbd_device *rbd_dev,
-                               const char *obj)
+                               const char *object_name)
 {
        struct ceph_osd_req_op *ops;
 
                              0,
                              CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
                              ops,
-                             1, obj, 0, 0, NULL, NULL, NULL);
+                             1, object_name, 0, 0, NULL, NULL, NULL);
 
        rbd_destroy_ops(ops);
        ceph_osdc_cancel_event(rbd_dev->watch_event);
  * Request sync osd notify
  */
 static int rbd_req_sync_notify(struct rbd_device *rbd_dev,
-                         const char *obj)
+                         const char *object_name)
 {
        struct ceph_osd_req_op *ops;
        struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
                               0,
                               CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
                               ops,
-                              1, obj, 0, 0, NULL, NULL, NULL);
+                              1, object_name, 0, 0, NULL, NULL, NULL);
        if (ret < 0)
                goto fail_event;
 
  * Request sync osd read
  */
 static int rbd_req_sync_exec(struct rbd_device *rbd_dev,
-                            const char *obj,
-                            const char *cls,
-                            const char *method,
+                            const char *object_name,
+                            const char *class_name,
+                            const char *method_name,
                             const char *data,
                             int len,
                             u64 *ver)
 {
        struct ceph_osd_req_op *ops;
-       int cls_len = strlen(cls);
-       int method_len = strlen(method);
+       int class_name_len = strlen(class_name);
+       int method_name_len = strlen(method_name);
        int ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_CALL,
-                                   cls_len + method_len + len);
+                                   class_name_len + method_name_len + len);
        if (ret < 0)
                return ret;
 
-       ops[0].cls.class_name = cls;
-       ops[0].cls.class_len = (__u8)cls_len;
-       ops[0].cls.method_name = method;
-       ops[0].cls.method_len = (__u8)method_len;
+       ops[0].cls.class_name = class_name;
+       ops[0].cls.class_len = (__u8) class_name_len;
+       ops[0].cls.method_name = method_name;
+       ops[0].cls.method_len = (__u8) method_name_len;
        ops[0].cls.argc = 0;
        ops[0].cls.indata = data;
        ops[0].cls.indata_len = len;
                               0,
                               CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
                               ops,
-                              1, obj, 0, 0, NULL, NULL, ver);
+                              1, object_name, 0, 0, NULL, NULL, ver);
 
        rbd_destroy_ops(ops);