/*
   rbd.c -- Export ceph rados objects as a Linux block device


   based on drivers/block/osdblk.c:

   Copyright 2009 Red Hat, Inc.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; see the file COPYING.  If not, write to
   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.



   For usage instructions, please refer to:

                 Documentation/ABI/testing/sysfs-bus-rbd

 */

#include <linux/ceph/libceph.h>
#include <linux/ceph/osd_client.h>
#include <linux/ceph/mon_client.h>
#include <linux/ceph/cls_lock_client.h>
#include <linux/ceph/striper.h>
#include <linux/ceph/decode.h>
#include <linux/parser.h>
#include <linux/bsearch.h>

#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/module.h>
#include <linux/blk-mq.h>
#include <linux/fs.h>
#include <linux/blkdev.h>
#include <linux/slab.h>
#include <linux/idr.h>
#include <linux/workqueue.h>

#include "rbd_types.h"

#define RBD_DEBUG       /* Activate rbd_assert() calls */

/*
 * Increment the given counter and return its updated value.
 * If the counter is already 0 it will not be incremented.
 * If the counter is already at its maximum value returns
 * -EINVAL without updating it.
 */
static int atomic_inc_return_safe(atomic_t *v)
{
        unsigned int counter;

        counter = (unsigned int)atomic_fetch_add_unless(v, 1, 0);
        if (counter <= (unsigned int)INT_MAX)
                return (int)counter;

        atomic_dec(v);

        return -EINVAL;
}

/* Decrement the counter.  Return the resulting value, or -EINVAL */
static int atomic_dec_return_safe(atomic_t *v)
{
        int counter;

        counter = atomic_dec_return(v);
        if (counter >= 0)
                return counter;

        atomic_inc(v);

        return -EINVAL;
}

#define RBD_DRV_NAME "rbd"

#define RBD_MINORS_PER_MAJOR            256
#define RBD_SINGLE_MAJOR_PART_SHIFT     4

#define RBD_MAX_PARENT_CHAIN_LEN        16

#define RBD_SNAP_DEV_NAME_PREFIX        "snap_"
#define RBD_MAX_SNAP_NAME_LEN   \
                        (NAME_MAX - (sizeof (RBD_SNAP_DEV_NAME_PREFIX) - 1))

#define RBD_MAX_SNAP_COUNT      510     /* allows max snapc to fit in 4KB */

#define RBD_SNAP_HEAD_NAME      "-"

#define BAD_SNAP_INDEX  U32_MAX         /* invalid index into snap array */

/* This allows a single page to hold an image name sent by OSD */
#define RBD_IMAGE_NAME_LEN_MAX  (PAGE_SIZE - sizeof (__le32) - 1)
#define RBD_IMAGE_ID_LEN_MAX    64

#define RBD_OBJ_PREFIX_LEN_MAX  64

#define RBD_NOTIFY_TIMEOUT      5       /* seconds */
#define RBD_RETRY_DELAY         msecs_to_jiffies(1000)

/* Feature bits */

#define RBD_FEATURE_LAYERING            (1ULL<<0)
#define RBD_FEATURE_STRIPINGV2          (1ULL<<1)
#define RBD_FEATURE_EXCLUSIVE_LOCK      (1ULL<<2)
#define RBD_FEATURE_OBJECT_MAP          (1ULL<<3)
#define RBD_FEATURE_FAST_DIFF           (1ULL<<4)
#define RBD_FEATURE_DEEP_FLATTEN        (1ULL<<5)
#define RBD_FEATURE_DATA_POOL           (1ULL<<7)
#define RBD_FEATURE_OPERATIONS          (1ULL<<8)

#define RBD_FEATURES_ALL        (RBD_FEATURE_LAYERING |         \
                                 RBD_FEATURE_STRIPINGV2 |       \
                                 RBD_FEATURE_EXCLUSIVE_LOCK |   \
                                 RBD_FEATURE_OBJECT_MAP |       \
                                 RBD_FEATURE_FAST_DIFF |        \
                                 RBD_FEATURE_DEEP_FLATTEN |     \
                                 RBD_FEATURE_DATA_POOL |        \
                                 RBD_FEATURE_OPERATIONS)

/* Features supported by this (client software) implementation. */

#define RBD_FEATURES_SUPPORTED  (RBD_FEATURES_ALL)

/*
 * An RBD device name will be "rbd#", where the "rbd" comes from
 * RBD_DRV_NAME above, and # is a unique integer identifier.
 */
#define DEV_NAME_LEN            32

/*
 * block device image metadata (in-memory version)
 */
struct rbd_image_header {
        /* These six fields never change for a given rbd image */
        char *object_prefix;
        __u8 obj_order;
        u64 stripe_unit;
        u64 stripe_count;
        s64 data_pool_id;
        u64 features;           /* Might be changeable someday? */

        /* The remaining fields need to be updated occasionally */
        u64 image_size;
        struct ceph_snap_context *snapc;
        char *snap_names;       /* format 1 only */
        u64 *snap_sizes;        /* format 1 only */
};

/*
 * An rbd image specification.
 *
 * The tuple (pool_id, image_id, snap_id) is sufficient to uniquely
 * identify an image.  Each rbd_dev structure includes a pointer to
 * an rbd_spec structure that encapsulates this identity.
 *
 * Each of the id's in an rbd_spec has an associated name.  For a
 * user-mapped image, the names are supplied and the id's associated
 * with them are looked up.  For a layered image, a parent image is
 * defined by the tuple, and the names are looked up.
 *
 * An rbd_dev structure contains a parent_spec pointer which is
 * non-null if the image it represents is a child in a layered
 * image.  This pointer will refer to the rbd_spec structure used
 * by the parent rbd_dev for its own identity (i.e., the structure
 * is shared between the parent and child).
 *
 * Since these structures are populated once, during the discovery
 * phase of image construction, they are effectively immutable so
 * we make no effort to synchronize access to them.
 *
 * Note that code herein does not assume the image name is known (it
 * could be a null pointer).
 */
struct rbd_spec {
        u64             pool_id;
        const char      *pool_name;
        const char      *pool_ns;       /* NULL if default, never "" */

        const char      *image_id;
        const char      *image_name;

        u64             snap_id;
        const char      *snap_name;

        struct kref     kref;
};

/*
 * an instance of the client.  multiple devices may share an rbd client.
 */
struct rbd_client {
        struct ceph_client      *client;
        struct kref             kref;
        struct list_head        node;
};

struct pending_result {
        int                     result;         /* first nonzero result */
        int                     num_pending;
};

struct rbd_img_request;

enum obj_request_type {
        OBJ_REQUEST_NODATA = 1,
        OBJ_REQUEST_BIO,        /* pointer into provided bio (list) */
        OBJ_REQUEST_BVECS,      /* pointer into provided bio_vec array */
        OBJ_REQUEST_OWN_BVECS,  /* private bio_vec array, doesn't own pages */
};

enum obj_operation_type {
        OBJ_OP_READ = 1,
        OBJ_OP_WRITE,
        OBJ_OP_DISCARD,
        OBJ_OP_ZEROOUT,
};

#define RBD_OBJ_FLAG_DELETION                   (1U << 0)
#define RBD_OBJ_FLAG_COPYUP_ENABLED             (1U << 1)
#define RBD_OBJ_FLAG_COPYUP_ZEROS               (1U << 2)
#define RBD_OBJ_FLAG_MAY_EXIST                  (1U << 3)
#define RBD_OBJ_FLAG_NOOP_FOR_NONEXISTENT       (1U << 4)

enum rbd_obj_read_state {
        RBD_OBJ_READ_START = 1,
        RBD_OBJ_READ_OBJECT,
        RBD_OBJ_READ_PARENT,
};

/*
 * Writes go through the following state machine to deal with
 * layering:
 *
 *            . . . . . RBD_OBJ_WRITE_GUARD. . . . . . . . . . . . . .
 *            .                 |                                    .
 *            .                 v                                    .
 *            .    RBD_OBJ_WRITE_READ_FROM_PARENT. . .               .
 *            .                 |                    .               .
 *            .                 v                    v (deep-copyup  .
 *    (image  .   RBD_OBJ_WRITE_COPYUP_EMPTY_SNAPC   .  not needed)  .
 * flattened) v                 |                    .               .
 *            .                 v                    .               .
 *            . . . .RBD_OBJ_WRITE_COPYUP_OPS. . . . .      (copyup  .
 *                              |                        not needed) v
 *                              v                                    .
 *                            done . . . . . . . . . . . . . . . . . .
 *                              ^
 *                              |
 *                     RBD_OBJ_WRITE_FLAT
 *
 * Writes start in RBD_OBJ_WRITE_GUARD or _FLAT, depending on whether
 * assert_exists guard is needed or not (in some cases it's not needed
 * even if there is a parent).
 */
enum rbd_obj_write_state {
        RBD_OBJ_WRITE_START = 1,
        RBD_OBJ_WRITE_PRE_OBJECT_MAP,
        RBD_OBJ_WRITE_OBJECT,
        __RBD_OBJ_WRITE_COPYUP,
        RBD_OBJ_WRITE_COPYUP,
        RBD_OBJ_WRITE_POST_OBJECT_MAP,
};

enum rbd_obj_copyup_state {
        RBD_OBJ_COPYUP_START = 1,
        RBD_OBJ_COPYUP_READ_PARENT,
        __RBD_OBJ_COPYUP_OBJECT_MAPS,
        RBD_OBJ_COPYUP_OBJECT_MAPS,
        __RBD_OBJ_COPYUP_WRITE_OBJECT,
        RBD_OBJ_COPYUP_WRITE_OBJECT,
};

struct rbd_obj_request {
        struct ceph_object_extent ex;
        unsigned int            flags;  /* RBD_OBJ_FLAG_* */
        union {
                enum rbd_obj_read_state  read_state;    /* for reads */
                enum rbd_obj_write_state write_state;   /* for writes */
        };

        struct rbd_img_request  *img_request;
        struct ceph_file_extent *img_extents;
        u32                     num_img_extents;

        union {
                struct ceph_bio_iter    bio_pos;
                struct {
                        struct ceph_bvec_iter   bvec_pos;
                        u32                     bvec_count;
                        u32                     bvec_idx;
                };
        };

        enum rbd_obj_copyup_state copyup_state;
        struct bio_vec          *copyup_bvecs;
        u32                     copyup_bvec_count;

        struct list_head        osd_reqs;       /* w/ r_private_item */

        struct mutex            state_mutex;
        struct pending_result   pending;
        struct kref             kref;
};

enum img_req_flags {
        IMG_REQ_CHILD,          /* initiator: block = 0, child image = 1 */
        IMG_REQ_LAYERED,        /* ENOENT handling: normal = 0, layered = 1 */
};

enum rbd_img_state {
        RBD_IMG_START = 1,
        RBD_IMG_EXCLUSIVE_LOCK,
        __RBD_IMG_OBJECT_REQUESTS,
        RBD_IMG_OBJECT_REQUESTS,
};

struct rbd_img_request {
        struct rbd_device       *rbd_dev;
        enum obj_operation_type op_type;
        enum obj_request_type   data_type;
        unsigned long           flags;
        enum rbd_img_state      state;
        union {
                u64                     snap_id;        /* for reads */
                struct ceph_snap_context *snapc;        /* for writes */
        };
        union {
                struct request          *rq;            /* block request */
                struct rbd_obj_request  *obj_request;   /* obj req initiator */
        };

        struct list_head        lock_item;
        struct list_head        object_extents; /* obj_req.ex structs */

        struct mutex            state_mutex;
        struct pending_result   pending;
        struct work_struct      work;
        int                     work_result;
        struct kref             kref;
};

#define for_each_obj_request(ireq, oreq) \
        list_for_each_entry(oreq, &(ireq)->object_extents, ex.oe_item)
#define for_each_obj_request_safe(ireq, oreq, n) \
        list_for_each_entry_safe(oreq, n, &(ireq)->object_extents, ex.oe_item)

enum rbd_watch_state {
        RBD_WATCH_STATE_UNREGISTERED,
        RBD_WATCH_STATE_REGISTERED,
        RBD_WATCH_STATE_ERROR,
};

enum rbd_lock_state {
        RBD_LOCK_STATE_UNLOCKED,
        RBD_LOCK_STATE_LOCKED,
        RBD_LOCK_STATE_RELEASING,
};

/* WatchNotify::ClientId */
struct rbd_client_id {
        u64 gid;
        u64 handle;
};

struct rbd_mapping {
        u64                     size;
        u64                     features;
};

/*
 * a single device
 */
struct rbd_device {
        int                     dev_id;         /* blkdev unique id */

        int                     major;          /* blkdev assigned major */
        int                     minor;
        struct gendisk          *disk;          /* blkdev's gendisk and rq */

        u32                     image_format;   /* Either 1 or 2 */
        struct rbd_client       *rbd_client;

        char                    name[DEV_NAME_LEN]; /* blkdev name, e.g. rbd3 */

        spinlock_t              lock;           /* queue, flags, open_count */

        struct rbd_image_header header;
        unsigned long           flags;          /* possibly lock protected */
        struct rbd_spec         *spec;
        struct rbd_options      *opts;
        char                    *config_info;   /* add{,_single_major} string */

        struct ceph_object_id   header_oid;
        struct ceph_object_locator header_oloc;

        struct ceph_file_layout layout;         /* used for all rbd requests */

        struct mutex            watch_mutex;
        enum rbd_watch_state    watch_state;
        struct ceph_osd_linger_request *watch_handle;
        u64                     watch_cookie;
        struct delayed_work     watch_dwork;

        struct rw_semaphore     lock_rwsem;
        enum rbd_lock_state     lock_state;
        char                    lock_cookie[32];
        struct rbd_client_id    owner_cid;
        struct work_struct      acquired_lock_work;
        struct work_struct      released_lock_work;
        struct delayed_work     lock_dwork;
        struct work_struct      unlock_work;
        spinlock_t              lock_lists_lock;
        struct list_head        acquiring_list;
        struct list_head        running_list;
        struct completion       acquire_wait;
        int                     acquire_err;
        struct completion       releasing_wait;

        spinlock_t              object_map_lock;
        u8                      *object_map;
        u64                     object_map_size;        /* in objects */
        u64                     object_map_flags;

        struct workqueue_struct *task_wq;

        struct rbd_spec         *parent_spec;
        u64                     parent_overlap;
        atomic_t                parent_ref;
        struct rbd_device       *parent;

        /* Block layer tags. */
        struct blk_mq_tag_set   tag_set;

        /* protects updating the header */
        struct rw_semaphore     header_rwsem;

        struct rbd_mapping      mapping;

        struct list_head        node;

        /* sysfs related */
        struct device           dev;
        unsigned long           open_count;     /* protected by lock */
};

/*
 * Flag bits for rbd_dev->flags:
 * - REMOVING (which is coupled with rbd_dev->open_count) is protected
 *   by rbd_dev->lock
 */
enum rbd_dev_flags {
        RBD_DEV_FLAG_EXISTS,    /* mapped snapshot has not been deleted */
        RBD_DEV_FLAG_REMOVING,  /* this mapping is being removed */
};

static DEFINE_MUTEX(client_mutex);      /* Serialize client creation */

static LIST_HEAD(rbd_dev_list);    /* devices */
static DEFINE_SPINLOCK(rbd_dev_list_lock);

static LIST_HEAD(rbd_client_list);              /* clients */
static DEFINE_SPINLOCK(rbd_client_list_lock);

/* Slab caches for frequently-allocated structures */

static struct kmem_cache        *rbd_img_request_cache;
static struct kmem_cache        *rbd_obj_request_cache;

static int rbd_major;
static DEFINE_IDA(rbd_dev_id_ida);

static struct workqueue_struct *rbd_wq;

static struct ceph_snap_context rbd_empty_snapc = {
        .nref = REFCOUNT_INIT(1),
};

/*
 * single-major requires >= 0.75 version of userspace rbd utility.
 */
static bool single_major = true;
module_param(single_major, bool, 0444);
MODULE_PARM_DESC(single_major, "Use a single major number for all rbd devices (default: true)");

static ssize_t add_store(struct bus_type *bus, const char *buf, size_t count);
static ssize_t remove_store(struct bus_type *bus, const char *buf,
                            size_t count);
static ssize_t add_single_major_store(struct bus_type *bus, const char *buf,
                                      size_t count);
static ssize_t remove_single_major_store(struct bus_type *bus, const char *buf,
                                         size_t count);
static int rbd_dev_image_probe(struct rbd_device *rbd_dev, int depth);

static int rbd_dev_id_to_minor(int dev_id)
{
        return dev_id << RBD_SINGLE_MAJOR_PART_SHIFT;
}

static int minor_to_rbd_dev_id(int minor)
{
        return minor >> RBD_SINGLE_MAJOR_PART_SHIFT;
}

static bool __rbd_is_lock_owner(struct rbd_device *rbd_dev)
{
        lockdep_assert_held(&rbd_dev->lock_rwsem);

        return rbd_dev->lock_state == RBD_LOCK_STATE_LOCKED ||
               rbd_dev->lock_state == RBD_LOCK_STATE_RELEASING;
}

static bool rbd_is_lock_owner(struct rbd_device *rbd_dev)
{
        bool is_lock_owner;

        down_read(&rbd_dev->lock_rwsem);
        is_lock_owner = __rbd_is_lock_owner(rbd_dev);
        up_read(&rbd_dev->lock_rwsem);
        return is_lock_owner;
}

static ssize_t supported_features_show(struct bus_type *bus, char *buf)
{
        return sprintf(buf, "0x%llx\n", RBD_FEATURES_SUPPORTED);
}

static BUS_ATTR_WO(add);
static BUS_ATTR_WO(remove);
static BUS_ATTR_WO(add_single_major);
static BUS_ATTR_WO(remove_single_major);
static BUS_ATTR_RO(supported_features);

static struct attribute *rbd_bus_attrs[] = {
        &bus_attr_add.attr,
        &bus_attr_remove.attr,
        &bus_attr_add_single_major.attr,
        &bus_attr_remove_single_major.attr,
        &bus_attr_supported_features.attr,
        NULL,
};

static umode_t rbd_bus_is_visible(struct kobject *kobj,
                                  struct attribute *attr, int index)
{
        if (!single_major &&
            (attr == &bus_attr_add_single_major.attr ||
             attr == &bus_attr_remove_single_major.attr))
                return 0;

        return attr->mode;
}

static const struct attribute_group rbd_bus_group = {
        .attrs = rbd_bus_attrs,
        .is_visible = rbd_bus_is_visible,
};
__ATTRIBUTE_GROUPS(rbd_bus);

static struct bus_type rbd_bus_type = {
        .name           = "rbd",
        .bus_groups     = rbd_bus_groups,
};

static void rbd_root_dev_release(struct device *dev)
{
}

static struct device rbd_root_dev = {
        .init_name =    "rbd",
        .release =      rbd_root_dev_release,
};

static __printf(2, 3)
void rbd_warn(struct rbd_device *rbd_dev, const char *fmt, ...)
{
        struct va_format vaf;
        va_list args;

        va_start(args, fmt);
        vaf.fmt = fmt;
        vaf.va = &args;

        if (!rbd_dev)
                printk(KERN_WARNING "%s: %pV\n", RBD_DRV_NAME, &vaf);
        else if (rbd_dev->disk)
                printk(KERN_WARNING "%s: %s: %pV\n",
                        RBD_DRV_NAME, rbd_dev->disk->disk_name, &vaf);
        else if (rbd_dev->spec && rbd_dev->spec->image_name)
                printk(KERN_WARNING "%s: image %s: %pV\n",
                        RBD_DRV_NAME, rbd_dev->spec->image_name, &vaf);
        else if (rbd_dev->spec && rbd_dev->spec->image_id)
                printk(KERN_WARNING "%s: id %s: %pV\n",
                        RBD_DRV_NAME, rbd_dev->spec->image_id, &vaf);
        else    /* punt */
                printk(KERN_WARNING "%s: rbd_dev %p: %pV\n",
                        RBD_DRV_NAME, rbd_dev, &vaf);
        va_end(args);
}

#ifdef RBD_DEBUG
#define rbd_assert(expr)                                                \
                if (unlikely(!(expr))) {                                \
                        printk(KERN_ERR "\nAssertion failure in %s() "  \
                                                "at line %d:\n\n"       \
                                        "\trbd_assert(%s);\n\n",        \
                                        __func__, __LINE__, #expr);     \
                        BUG();                                          \
                }
#else /* !RBD_DEBUG */
#  define rbd_assert(expr)      ((void) 0)
#endif /* !RBD_DEBUG */

static void rbd_dev_remove_parent(struct rbd_device *rbd_dev);

static int rbd_dev_refresh(struct rbd_device *rbd_dev);
static int rbd_dev_v2_header_onetime(struct rbd_device *rbd_dev);
static int rbd_dev_header_info(struct rbd_device *rbd_dev);
static int rbd_dev_v2_parent_info(struct rbd_device *rbd_dev);
static const char *rbd_dev_v2_snap_name(struct rbd_device *rbd_dev,
                                        u64 snap_id);
static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
                                u8 *order, u64 *snap_size);
static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
                u64 *snap_features);
static int rbd_dev_v2_get_flags(struct rbd_device *rbd_dev);

static void rbd_obj_handle_request(struct rbd_obj_request *obj_req, int result);
static void rbd_img_handle_request(struct rbd_img_request *img_req, int result);

/*
 * Return true if nothing else is pending.
 */
static bool pending_result_dec(struct pending_result *pending, int *result)
{
        rbd_assert(pending->num_pending > 0);

        if (*result && !pending->result)
                pending->result = *result;
        if (--pending->num_pending)
                return false;

        *result = pending->result;
        return true;
}

static int rbd_open(struct block_device *bdev, fmode_t mode)
{
        struct rbd_device *rbd_dev = bdev->bd_disk->private_data;
        bool removing = false;

        spin_lock_irq(&rbd_dev->lock);
        if (test_bit(RBD_DEV_FLAG_REMOVING, &rbd_dev->flags))
                removing = true;
        else
                rbd_dev->open_count++;
        spin_unlock_irq(&rbd_dev->lock);
        if (removing)
                return -ENOENT;

        (void) get_device(&rbd_dev->dev);

        return 0;
}

static void rbd_release(struct gendisk *disk, fmode_t mode)
{
        struct rbd_device *rbd_dev = disk->private_data;
        unsigned long open_count_before;

        spin_lock_irq(&rbd_dev->lock);
        open_count_before = rbd_dev->open_count--;
        spin_unlock_irq(&rbd_dev->lock);
        rbd_assert(open_count_before > 0);

        put_device(&rbd_dev->dev);
}

static int rbd_ioctl_set_ro(struct rbd_device *rbd_dev, unsigned long arg)
{
        int ro;

        if (get_user(ro, (int __user *)arg))
                return -EFAULT;

        /* Snapshots can't be marked read-write */
        if (rbd_dev->spec->snap_id != CEPH_NOSNAP && !ro)
                return -EROFS;

        /* Let blkdev_roset() handle it */
        return -ENOTTY;
}

static int rbd_ioctl(struct block_device *bdev, fmode_t mode,
                        unsigned int cmd, unsigned long arg)
{
        struct rbd_device *rbd_dev = bdev->bd_disk->private_data;
        int ret;

        switch (cmd) {
        case BLKROSET:
                ret = rbd_ioctl_set_ro(rbd_dev, arg);
                break;
        default:
                ret = -ENOTTY;
        }

        return ret;
}

#ifdef CONFIG_COMPAT
static int rbd_compat_ioctl(struct block_device *bdev, fmode_t mode,
                                unsigned int cmd, unsigned long arg)
{
        return rbd_ioctl(bdev, mode, cmd, arg);
}
#endif /* CONFIG_COMPAT */

static const struct block_device_operations rbd_bd_ops = {
        .owner                  = THIS_MODULE,
        .open                   = rbd_open,
        .release                = rbd_release,
        .ioctl                  = rbd_ioctl,
#ifdef CONFIG_COMPAT
        .compat_ioctl           = rbd_compat_ioctl,
#endif
};

/*
 * Initialize an rbd client instance.  Success or not, this function
 * consumes ceph_opts.  Caller holds client_mutex.
 */
static struct rbd_client *rbd_client_create(struct ceph_options *ceph_opts)
{
        struct rbd_client *rbdc;
        int ret = -ENOMEM;

        dout("%s:\n", __func__);
        rbdc = kmalloc(sizeof(struct rbd_client), GFP_KERNEL);
        if (!rbdc)
                goto out_opt;

        kref_init(&rbdc->kref);
        INIT_LIST_HEAD(&rbdc->node);

        rbdc->client = ceph_create_client(ceph_opts, rbdc);
        if (IS_ERR(rbdc->client))
                goto out_rbdc;
        ceph_opts = NULL; /* Now rbdc->client is responsible for ceph_opts */

        ret = ceph_open_session(rbdc->client);
        if (ret < 0)
                goto out_client;

        spin_lock(&rbd_client_list_lock);
        list_add_tail(&rbdc->node, &rbd_client_list);
        spin_unlock(&rbd_client_list_lock);

        dout("%s: rbdc %p\n", __func__, rbdc);

        return rbdc;
out_client:
        ceph_destroy_client(rbdc->client);
out_rbdc:
        kfree(rbdc);
out_opt:
        if (ceph_opts)
                ceph_destroy_options(ceph_opts);
        dout("%s: error %d\n", __func__, ret);

        return ERR_PTR(ret);
}

static struct rbd_client *__rbd_get_client(struct rbd_client *rbdc)
{
        kref_get(&rbdc->kref);

        return rbdc;
}

/*
 * Find a ceph client with specific addr and configuration.  If
 * found, bump its reference count.
 */
static struct rbd_client *rbd_client_find(struct ceph_options *ceph_opts)
{
        struct rbd_client *client_node;
        bool found = false;

        if (ceph_opts->flags & CEPH_OPT_NOSHARE)
                return NULL;

        spin_lock(&rbd_client_list_lock);
        list_for_each_entry(client_node, &rbd_client_list, node) {
                if (!ceph_compare_options(ceph_opts, client_node->client)) {
                        __rbd_get_client(client_node);

                        found = true;
                        break;
                }
        }
        spin_unlock(&rbd_client_list_lock);

        return found ? client_node : NULL;
}

/*
 * (Per device) rbd map options
 */
enum {
        Opt_queue_depth,
        Opt_alloc_size,
        Opt_lock_timeout,
        Opt_last_int,
        /* int args above */
        Opt_pool_ns,
        Opt_last_string,
        /* string args above */
        Opt_read_only,
        Opt_read_write,
        Opt_lock_on_read,
        Opt_exclusive,
        Opt_notrim,
        Opt_err
};

static match_table_t rbd_opts_tokens = {
        {Opt_queue_depth, "queue_depth=%d"},
        {Opt_alloc_size, "alloc_size=%d"},
        {Opt_lock_timeout, "lock_timeout=%d"},
        /* int args above */
        {Opt_pool_ns, "_pool_ns=%s"},
        /* string args above */
        {Opt_read_only, "read_only"},
        {Opt_read_only, "ro"},          /* Alternate spelling */
        {Opt_read_write, "read_write"},
        {Opt_read_write, "rw"},         /* Alternate spelling */
        {Opt_lock_on_read, "lock_on_read"},
        {Opt_exclusive, "exclusive"},
        {Opt_notrim, "notrim"},
        {Opt_err, NULL}
};

struct rbd_options {
        int     queue_depth;
        int     alloc_size;
        unsigned long   lock_timeout;
        bool    read_only;
        bool    lock_on_read;
        bool    exclusive;
        bool    trim;
};

#define RBD_QUEUE_DEPTH_DEFAULT BLKDEV_MAX_RQ
#define RBD_ALLOC_SIZE_DEFAULT  (64 * 1024)
#define RBD_LOCK_TIMEOUT_DEFAULT 0  /* no timeout */
#define RBD_READ_ONLY_DEFAULT   false
#define RBD_LOCK_ON_READ_DEFAULT false
#define RBD_EXCLUSIVE_DEFAULT   false
#define RBD_TRIM_DEFAULT        true

struct parse_rbd_opts_ctx {
        struct rbd_spec         *spec;
        struct rbd_options      *opts;
};

static int parse_rbd_opts_token(char *c, void *private)
{
        struct parse_rbd_opts_ctx *pctx = private;
        substring_t argstr[MAX_OPT_ARGS];
        int token, intval, ret;

        token = match_token(c, rbd_opts_tokens, argstr);
        if (token < Opt_last_int) {
                ret = match_int(&argstr[0], &intval);
                if (ret < 0) {
                        pr_err("bad option arg (not int) at '%s'\n", c);
                        return ret;
                }
                dout("got int token %d val %d\n", token, intval);
        } else if (token > Opt_last_int && token < Opt_last_string) {
                dout("got string token %d val %s\n", token, argstr[0].from);
        } else {
                dout("got token %d\n", token);
        }

        switch (token) {
        case Opt_queue_depth:
                if (intval < 1) {
                        pr_err("queue_depth out of range\n");
                        return -EINVAL;
                }
                pctx->opts->queue_depth = intval;
                break;
        case Opt_alloc_size:
                if (intval < SECTOR_SIZE) {
                        pr_err("alloc_size out of range\n");
                        return -EINVAL;
                }
                if (!is_power_of_2(intval)) {
                        pr_err("alloc_size must be a power of 2\n");
                        return -EINVAL;
                }
                pctx->opts->alloc_size = intval;
                break;
        case Opt_lock_timeout:
                /* 0 is "wait forever" (i.e. infinite timeout) */
                if (intval < 0 || intval > INT_MAX / 1000) {
                        pr_err("lock_timeout out of range\n");
                        return -EINVAL;
                }
                pctx->opts->lock_timeout = msecs_to_jiffies(intval * 1000);
                break;
        case Opt_pool_ns:
                kfree(pctx->spec->pool_ns);
                pctx->spec->pool_ns = match_strdup(argstr);
                if (!pctx->spec->pool_ns)
                        return -ENOMEM;
                break;
        case Opt_read_only:
                pctx->opts->read_only = true;
                break;
        case Opt_read_write:
                pctx->opts->read_only = false;
                break;
        case Opt_lock_on_read:
                pctx->opts->lock_on_read = true;
                break;
        case Opt_exclusive:
                pctx->opts->exclusive = true;
                break;
        case Opt_notrim:
                pctx->opts->trim = false;
                break;
        default:
                /* libceph prints "bad option" msg */
                return -EINVAL;
        }

        return 0;
}

static char* obj_op_name(enum obj_operation_type op_type)
{
        switch (op_type) {
        case OBJ_OP_READ:
                return "read";
        case OBJ_OP_WRITE:
                return "write";
        case OBJ_OP_DISCARD:
                return "discard";
        case OBJ_OP_ZEROOUT:
                return "zeroout";
        default:
                return "???";
        }
}

/*
 * Destroy ceph client
 *
 * Caller must hold rbd_client_list_lock.
 */
static void rbd_client_release(struct kref *kref)
{
        struct rbd_client *rbdc = container_of(kref, struct rbd_client, kref);

        dout("%s: rbdc %p\n", __func__, rbdc);
        spin_lock(&rbd_client_list_lock);
        list_del(&rbdc->node);
        spin_unlock(&rbd_client_list_lock);

        ceph_destroy_client(rbdc->client);
        kfree(rbdc);
}

/*
 * Drop reference to ceph client node. If it's not referenced anymore, release
 * it.
 */
static void rbd_put_client(struct rbd_client *rbdc)
{
        if (rbdc)
                kref_put(&rbdc->kref, rbd_client_release);
}

/*
 * Get a ceph client with specific addr and configuration, if one does

 * not exist create it.  Either way, ceph_opts is consumed by this
 * function.
 */
static struct rbd_client *rbd_get_client(struct ceph_options *ceph_opts)
{
        struct rbd_client *rbdc;
        int ret;

        mutex_lock(&client_mutex);
        rbdc = rbd_client_find(ceph_opts);
        if (rbdc) {
                ceph_destroy_options(ceph_opts);

                /*
                 * Using an existing client.  Make sure ->pg_pools is up to
                 * date before we look up the pool id in do_rbd_add().
                 */
                ret = ceph_wait_for_latest_osdmap(rbdc->client,
                                        rbdc->client->options->mount_timeout);
                if (ret) {
                        rbd_warn(NULL, "failed to get latest osdmap: %d", ret);
                        rbd_put_client(rbdc);
                        rbdc = ERR_PTR(ret);
                }
        } else {
                rbdc = rbd_client_create(ceph_opts);
        }
        mutex_unlock(&client_mutex);

        return rbdc;
}

static bool rbd_image_format_valid(u32 image_format)
{
        return image_format == 1 || image_format == 2;
}

static bool rbd_dev_ondisk_valid(struct rbd_image_header_ondisk *ondisk)
{
        size_t size;
        u32 snap_count;

        /* The header has to start with the magic rbd header text */
        if (memcmp(&ondisk->text, RBD_HEADER_TEXT, sizeof (RBD_HEADER_TEXT)))
                return false;

        /* The bio layer requires at least sector-sized I/O */

        if (ondisk->options.order < SECTOR_SHIFT)
                return false;

        /* If we use u64 in a few spots we may be able to loosen this */

        if (ondisk->options.order > 8 * sizeof (int) - 1)
                return false;

        /*
         * The size of a snapshot header has to fit in a size_t, and
         * that limits the number of snapshots.
         */
        snap_count = le32_to_cpu(ondisk->snap_count);
        size = SIZE_MAX - sizeof (struct ceph_snap_context);
        if (snap_count > size / sizeof (__le64))
                return false;

        /*
         * Not only that, but the size of the entire the snapshot
         * header must also be representable in a size_t.
         */
        size -= snap_count * sizeof (__le64);
        if ((u64) size < le64_to_cpu(ondisk->snap_names_len))
                return false;

        return true;
}

/*
 * returns the size of an object in the image
 */
static u32 rbd_obj_bytes(struct rbd_image_header *header)
{
        return 1U << header->obj_order;
}

static void rbd_init_layout(struct rbd_device *rbd_dev)
{
        if (rbd_dev->header.stripe_unit == 0 ||
            rbd_dev->header.stripe_count == 0) {
                rbd_dev->header.stripe_unit = rbd_obj_bytes(&rbd_dev->header);
                rbd_dev->header.stripe_count = 1;
        }

        rbd_dev->layout.stripe_unit = rbd_dev->header.stripe_unit;
        rbd_dev->layout.stripe_count = rbd_dev->header.stripe_count;
        rbd_dev->layout.object_size = rbd_obj_bytes(&rbd_dev->header);
        rbd_dev->layout.pool_id = rbd_dev->header.data_pool_id == CEPH_NOPOOL ?
                          rbd_dev->spec->pool_id : rbd_dev->header.data_pool_id;
        RCU_INIT_POINTER(rbd_dev->layout.pool_ns, NULL);
}

/*
 * Fill an rbd image header with information from the given format 1
 * on-disk header.
 */
static int rbd_header_from_disk(struct rbd_device *rbd_dev,
                                 struct rbd_image_header_ondisk *ondisk)
{
        struct rbd_image_header *header = &rbd_dev->header;
        bool first_time = header->object_prefix == NULL;
        struct ceph_snap_context *snapc;
        char *object_prefix = NULL;
        char *snap_names = NULL;
        u64 *snap_sizes = NULL;
        u32 snap_count;
        int ret = -ENOMEM;
        u32 i;

        /* Allocate this now to avoid having to handle failure below */

        if (first_time) {
                object_prefix = kstrndup(ondisk->object_prefix,
                                         sizeof(ondisk->object_prefix),
                                         GFP_KERNEL);
                if (!object_prefix)
                        return -ENOMEM;
        }

        /* Allocate the snapshot context and fill it in */

        snap_count = le32_to_cpu(ondisk->snap_count);
        snapc = ceph_create_snap_context(snap_count, GFP_KERNEL);
        if (!snapc)
                goto out_err;
        snapc->seq = le64_to_cpu(ondisk->snap_seq);
        if (snap_count) {
                struct rbd_image_snap_ondisk *snaps;
                u64 snap_names_len = le64_to_cpu(ondisk->snap_names_len);

                /* We'll keep a copy of the snapshot names... */

                if (snap_names_len > (u64)SIZE_MAX)
                        goto out_2big;
                snap_names = kmalloc(snap_names_len, GFP_KERNEL);
                if (!snap_names)
                        goto out_err;

                /* ...as well as the array of their sizes. */
                snap_sizes = kmalloc_array(snap_count,
                                           sizeof(*header->snap_sizes),
                                           GFP_KERNEL);
                if (!snap_sizes)
                        goto out_err;

                /*
                 * Copy the names, and fill in each snapshot's id
                 * and size.
                 *
                 * Note that rbd_dev_v1_header_info() guarantees the
                 * ondisk buffer we're working with has
                 * snap_names_len bytes beyond the end of the
                 * snapshot id array, this memcpy() is safe.
                 */
                memcpy(snap_names, &ondisk->snaps[snap_count], snap_names_len);
                snaps = ondisk->snaps;
                for (i = 0; i < snap_count; i++) {
                        snapc->snaps[i] = le64_to_cpu(snaps[i].id);
                        snap_sizes[i] = le64_to_cpu(snaps[i].image_size);
                }
        }

        /* We won't fail any more, fill in the header */

        if (first_time) {
                header->object_prefix = object_prefix;
                header->obj_order = ondisk->options.order;
                rbd_init_layout(rbd_dev);
        } else {
                ceph_put_snap_context(header->snapc);
                kfree(header->snap_names);
                kfree(header->snap_sizes);
        }

        /* The remaining fields always get updated (when we refresh) */

        header->image_size = le64_to_cpu(ondisk->image_size);
        header->snapc = snapc;
        header->snap_names = snap_names;
        header->snap_sizes = snap_sizes;

        return 0;
out_2big:
        ret = -EIO;
out_err:
        kfree(snap_sizes);
        kfree(snap_names);
        ceph_put_snap_context(snapc);
        kfree(object_prefix);

        return ret;
}

static const char *_rbd_dev_v1_snap_name(struct rbd_device *rbd_dev, u32 which)
{
        const char *snap_name;

        rbd_assert(which < rbd_dev->header.snapc->num_snaps);

        /* Skip over names until we find the one we are looking for */

        snap_name = rbd_dev->header.snap_names;
        while (which--)
                snap_name += strlen(snap_name) + 1;

        return kstrdup(snap_name, GFP_KERNEL);
}

/*
 * Snapshot id comparison function for use with qsort()/bsearch().
 * Note that result is for snapshots in *descending* order.
 */
static int snapid_compare_reverse(const void *s1, const void *s2)
{
        u64 snap_id1 = *(u64 *)s1;
        u64 snap_id2 = *(u64 *)s2;

        if (snap_id1 < snap_id2)
                return 1;
        return snap_id1 == snap_id2 ? 0 : -1;
}

/*
 * Search a snapshot context to see if the given snapshot id is
 * present.
 *
 * Returns the position of the snapshot id in the array if it's found,
 * or BAD_SNAP_INDEX otherwise.
 *
 * Note: The snapshot array is in kept sorted (by the osd) in
 * reverse order, highest snapshot id first.
 */
static u32 rbd_dev_snap_index(struct rbd_device *rbd_dev, u64 snap_id)
{
        struct ceph_snap_context *snapc = rbd_dev->header.snapc;
        u64 *found;

        found = bsearch(&snap_id, &snapc->snaps, snapc->num_snaps,
                                sizeof (snap_id), snapid_compare_reverse);

        return found ? (u32)(found - &snapc->snaps[0]) : BAD_SNAP_INDEX;
}

static const char *rbd_dev_v1_snap_name(struct rbd_device *rbd_dev,
                                        u64 snap_id)
{
        u32 which;
        const char *snap_name;

        which = rbd_dev_snap_index(rbd_dev, snap_id);
        if (which == BAD_SNAP_INDEX)
                return ERR_PTR(-ENOENT);

        snap_name = _rbd_dev_v1_snap_name(rbd_dev, which);
        return snap_name ? snap_name : ERR_PTR(-ENOMEM);
}

static const char *rbd_snap_name(struct rbd_device *rbd_dev, u64 snap_id)
{
        if (snap_id == CEPH_NOSNAP)
                return RBD_SNAP_HEAD_NAME;

        rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
        if (rbd_dev->image_format == 1)
                return rbd_dev_v1_snap_name(rbd_dev, snap_id);

        return rbd_dev_v2_snap_name(rbd_dev, snap_id);
}

static int rbd_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
                                u64 *snap_size)
{
        rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
        if (snap_id == CEPH_NOSNAP) {
                *snap_size = rbd_dev->header.image_size;
        } else if (rbd_dev->image_format == 1) {
                u32 which;

                which = rbd_dev_snap_index(rbd_dev, snap_id);
                if (which == BAD_SNAP_INDEX)
                        return -ENOENT;

                *snap_size = rbd_dev->header.snap_sizes[which];
        } else {
                u64 size = 0;
                int ret;

                ret = _rbd_dev_v2_snap_size(rbd_dev, snap_id, NULL, &size);
                if (ret)
                        return ret;

                *snap_size = size;
        }
        return 0;
}

static int rbd_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
                        u64 *snap_features)
{
        rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
        if (snap_id == CEPH_NOSNAP) {
                *snap_features = rbd_dev->header.features;
        } else if (rbd_dev->image_format == 1) {
                *snap_features = 0;     /* No features for format 1 */
        } else {
                u64 features = 0;
                int ret;

                ret = _rbd_dev_v2_snap_features(rbd_dev, snap_id, &features);
                if (ret)
                        return ret;

                *snap_features = features;
        }
        return 0;
}

static int rbd_dev_mapping_set(struct rbd_device *rbd_dev)
{
        u64 snap_id = rbd_dev->spec->snap_id;
        u64 size = 0;
        u64 features = 0;
        int ret;

        ret = rbd_snap_size(rbd_dev, snap_id, &size);
        if (ret)
                return ret;
        ret = rbd_snap_features(rbd_dev, snap_id, &features);
        if (ret)
                return ret;

        rbd_dev->mapping.size = size;
        rbd_dev->mapping.features = features;

        return 0;
}

static void rbd_dev_mapping_clear(struct rbd_device *rbd_dev)
{
        rbd_dev->mapping.size = 0;
        rbd_dev->mapping.features = 0;
}

static void zero_bvec(struct bio_vec *bv)
{
        void *buf;
        unsigned long flags;

        buf = bvec_kmap_irq(bv, &flags);
        memset(buf, 0, bv->bv_len);
        flush_dcache_page(bv->bv_page);
        bvec_kunmap_irq(buf, &flags);
}

static void zero_bios(struct ceph_bio_iter *bio_pos, u32 off, u32 bytes)
{
        struct ceph_bio_iter it = *bio_pos;

        ceph_bio_iter_advance(&it, off);
        ceph_bio_iter_advance_step(&it, bytes, ({
                zero_bvec(&bv);
        }));
}

static void zero_bvecs(struct ceph_bvec_iter *bvec_pos, u32 off, u32 bytes)
{
        struct ceph_bvec_iter it = *bvec_pos;

        ceph_bvec_iter_advance(&it, off);
        ceph_bvec_iter_advance_step(&it, bytes, ({
                zero_bvec(&bv);
        }));
}

/*
 * Zero a range in @obj_req data buffer defined by a bio (list) or
 * (private) bio_vec array.
 *
 * @off is relative to the start of the data buffer.
 */
static void rbd_obj_zero_range(struct rbd_obj_request *obj_req, u32 off,
                               u32 bytes)
{
        dout("%s %p data buf %u~%u\n", __func__, obj_req, off, bytes);

        switch (obj_req->img_request->data_type) {
        case OBJ_REQUEST_BIO:
                zero_bios(&obj_req->bio_pos, off, bytes);
                break;
        case OBJ_REQUEST_BVECS:
        case OBJ_REQUEST_OWN_BVECS:
                zero_bvecs(&obj_req->bvec_pos, off, bytes);
                break;
        default:
                BUG();
        }
}

static void rbd_obj_request_destroy(struct kref *kref);
static void rbd_obj_request_put(struct rbd_obj_request *obj_request)
{
        rbd_assert(obj_request != NULL);
        dout("%s: obj %p (was %d)\n", __func__, obj_request,
                kref_read(&obj_request->kref));
        kref_put(&obj_request->kref, rbd_obj_request_destroy);
}

static void rbd_img_request_destroy(struct kref *kref);
static void rbd_img_request_put(struct rbd_img_request *img_request)
{
        rbd_assert(img_request != NULL);
        dout("%s: img %p (was %d)\n", __func__, img_request,
                kref_read(&img_request->kref));
        kref_put(&img_request->kref, rbd_img_request_destroy);
}

static inline void rbd_img_obj_request_add(struct rbd_img_request *img_request,
                                        struct rbd_obj_request *obj_request)
{
        rbd_assert(obj_request->img_request == NULL);

        /* Image request now owns object's original reference */
        obj_request->img_request = img_request;
        dout("%s: img %p obj %p\n", __func__, img_request, obj_request);
}

static inline void rbd_img_obj_request_del(struct rbd_img_request *img_request,
                                        struct rbd_obj_request *obj_request)
{
        dout("%s: img %p obj %p\n", __func__, img_request, obj_request);
        list_del(&obj_request->ex.oe_item);
        rbd_assert(obj_request->img_request == img_request);
        rbd_obj_request_put(obj_request);
}

static void rbd_osd_submit(struct ceph_osd_request *osd_req)
{
        struct rbd_obj_request *obj_req = osd_req->r_priv;

        dout("%s osd_req %p for obj_req %p objno %llu %llu~%llu\n",
             __func__, osd_req, obj_req, obj_req->ex.oe_objno,
             obj_req->ex.oe_off, obj_req->ex.oe_len);
        ceph_osdc_start_request(osd_req->r_osdc, osd_req, false);
}

/*
 * The default/initial value for all image request flags is 0.  Each
 * is conditionally set to 1 at image request initialization time
 * and currently never change thereafter.
 */
static void img_request_layered_set(struct rbd_img_request *img_request)
{
        set_bit(IMG_REQ_LAYERED, &img_request->flags);
        smp_mb();
}

static void img_request_layered_clear(struct rbd_img_request *img_request)
{
        clear_bit(IMG_REQ_LAYERED, &img_request->flags);
        smp_mb();
}

static bool img_request_layered_test(struct rbd_img_request *img_request)
{
        smp_mb();
        return test_bit(IMG_REQ_LAYERED, &img_request->flags) != 0;
}

static bool rbd_obj_is_entire(struct rbd_obj_request *obj_req)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;

        return !obj_req->ex.oe_off &&
               obj_req->ex.oe_len == rbd_dev->layout.object_size;
}

static bool rbd_obj_is_tail(struct rbd_obj_request *obj_req)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;

        return obj_req->ex.oe_off + obj_req->ex.oe_len ==
                                        rbd_dev->layout.object_size;
}

/*
 * Must be called after rbd_obj_calc_img_extents().
 */
static bool rbd_obj_copyup_enabled(struct rbd_obj_request *obj_req)
{
        if (!obj_req->num_img_extents ||
            (rbd_obj_is_entire(obj_req) &&
             !obj_req->img_request->snapc->num_snaps))
                return false;

        return true;
}

static u64 rbd_obj_img_extents_bytes(struct rbd_obj_request *obj_req)
{
        return ceph_file_extents_bytes(obj_req->img_extents,
                                       obj_req->num_img_extents);
}

static bool rbd_img_is_write(struct rbd_img_request *img_req)
{
        switch (img_req->op_type) {
        case OBJ_OP_READ:
                return false;
        case OBJ_OP_WRITE:
        case OBJ_OP_DISCARD:
        case OBJ_OP_ZEROOUT:
                return true;
        default:
                BUG();
        }
}

static void rbd_osd_req_callback(struct ceph_osd_request *osd_req)
{
        struct rbd_obj_request *obj_req = osd_req->r_priv;
        int result;

        dout("%s osd_req %p result %d for obj_req %p\n", __func__, osd_req,
             osd_req->r_result, obj_req);

        /*
         * Writes aren't allowed to return a data payload.  In some
         * guarded write cases (e.g. stat + zero on an empty object)
         * a stat response makes it through, but we don't care.
         */
        if (osd_req->r_result > 0 && rbd_img_is_write(obj_req->img_request))
                result = 0;
        else
                result = osd_req->r_result;

        rbd_obj_handle_request(obj_req, result);
}

static void rbd_osd_format_read(struct ceph_osd_request *osd_req)
{
        struct rbd_obj_request *obj_request = osd_req->r_priv;

        osd_req->r_flags = CEPH_OSD_FLAG_READ;
        osd_req->r_snapid = obj_request->img_request->snap_id;
}

static void rbd_osd_format_write(struct ceph_osd_request *osd_req)
{
        struct rbd_obj_request *obj_request = osd_req->r_priv;

        osd_req->r_flags = CEPH_OSD_FLAG_WRITE;
        ktime_get_real_ts64(&osd_req->r_mtime);
        osd_req->r_data_offset = obj_request->ex.oe_off;
}

static struct ceph_osd_request *
__rbd_obj_add_osd_request(struct rbd_obj_request *obj_req,
                          struct ceph_snap_context *snapc, int num_ops)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
        struct ceph_osd_request *req;
        const char *name_format = rbd_dev->image_format == 1 ?
                                      RBD_V1_DATA_FORMAT : RBD_V2_DATA_FORMAT;
        int ret;

        req = ceph_osdc_alloc_request(osdc, snapc, num_ops, false, GFP_NOIO);
        if (!req)
                return ERR_PTR(-ENOMEM);

        list_add_tail(&req->r_private_item, &obj_req->osd_reqs);
        req->r_callback = rbd_osd_req_callback;
        req->r_priv = obj_req;

        /*
         * Data objects may be stored in a separate pool, but always in
         * the same namespace in that pool as the header in its pool.
         */
        ceph_oloc_copy(&req->r_base_oloc, &rbd_dev->header_oloc);
        req->r_base_oloc.pool = rbd_dev->layout.pool_id;

        ret = ceph_oid_aprintf(&req->r_base_oid, GFP_NOIO, name_format,
                               rbd_dev->header.object_prefix,
                               obj_req->ex.oe_objno);
        if (ret)
                return ERR_PTR(ret);

        return req;
}

static struct ceph_osd_request *
rbd_obj_add_osd_request(struct rbd_obj_request *obj_req, int num_ops)
{
        return __rbd_obj_add_osd_request(obj_req, obj_req->img_request->snapc,
                                         num_ops);
}

static struct rbd_obj_request *rbd_obj_request_create(void)
{
        struct rbd_obj_request *obj_request;

        obj_request = kmem_cache_zalloc(rbd_obj_request_cache, GFP_NOIO);
        if (!obj_request)
                return NULL;

        ceph_object_extent_init(&obj_request->ex);
        INIT_LIST_HEAD(&obj_request->osd_reqs);
        mutex_init(&obj_request->state_mutex);
        kref_init(&obj_request->kref);

        dout("%s %p\n", __func__, obj_request);
        return obj_request;
}

static void rbd_obj_request_destroy(struct kref *kref)
{
        struct rbd_obj_request *obj_request;
        struct ceph_osd_request *osd_req;
        u32 i;

        obj_request = container_of(kref, struct rbd_obj_request, kref);

        dout("%s: obj %p\n", __func__, obj_request);

        while (!list_empty(&obj_request->osd_reqs)) {
                osd_req = list_first_entry(&obj_request->osd_reqs,
                                    struct ceph_osd_request, r_private_item);
                list_del_init(&osd_req->r_private_item);
                ceph_osdc_put_request(osd_req);
        }

        switch (obj_request->img_request->data_type) {
        case OBJ_REQUEST_NODATA:
        case OBJ_REQUEST_BIO:
        case OBJ_REQUEST_BVECS:
                break;          /* Nothing to do */
        case OBJ_REQUEST_OWN_BVECS:
                kfree(obj_request->bvec_pos.bvecs);
                break;
        default:
                BUG();
        }

        kfree(obj_request->img_extents);
        if (obj_request->copyup_bvecs) {
                for (i = 0; i < obj_request->copyup_bvec_count; i++) {
                        if (obj_request->copyup_bvecs[i].bv_page)
                                __free_page(obj_request->copyup_bvecs[i].bv_page);
                }
                kfree(obj_request->copyup_bvecs);
        }

        kmem_cache_free(rbd_obj_request_cache, obj_request);
}

/* It's OK to call this for a device with no parent */

static void rbd_spec_put(struct rbd_spec *spec);
static void rbd_dev_unparent(struct rbd_device *rbd_dev)
{
        rbd_dev_remove_parent(rbd_dev);
        rbd_spec_put(rbd_dev->parent_spec);
        rbd_dev->parent_spec = NULL;
        rbd_dev->parent_overlap = 0;
}

/*
 * Parent image reference counting is used to determine when an
 * image's parent fields can be safely torn down--after there are no
 * more in-flight requests to the parent image.  When the last
 * reference is dropped, cleaning them up is safe.
 */
static void rbd_dev_parent_put(struct rbd_device *rbd_dev)
{
        int counter;

        if (!rbd_dev->parent_spec)
                return;

        counter = atomic_dec_return_safe(&rbd_dev->parent_ref);
        if (counter > 0)
                return;

        /* Last reference; clean up parent data structures */

        if (!counter)
                rbd_dev_unparent(rbd_dev);
        else
                rbd_warn(rbd_dev, "parent reference underflow");
}

/*
 * If an image has a non-zero parent overlap, get a reference to its
 * parent.
 *
 * Returns true if the rbd device has a parent with a non-zero
 * overlap and a reference for it was successfully taken, or
 * false otherwise.
 */
static bool rbd_dev_parent_get(struct rbd_device *rbd_dev)
{
        int counter = 0;

        if (!rbd_dev->parent_spec)
                return false;

        down_read(&rbd_dev->header_rwsem);
        if (rbd_dev->parent_overlap)
                counter = atomic_inc_return_safe(&rbd_dev->parent_ref);
        up_read(&rbd_dev->header_rwsem);

        if (counter < 0)
                rbd_warn(rbd_dev, "parent reference overflow");

        return counter > 0;
}

/*
 * Caller is responsible for filling in the list of object requests
 * that comprises the image request, and the Linux request pointer
 * (if there is one).
 */
static struct rbd_img_request *rbd_img_request_create(
                                        struct rbd_device *rbd_dev,
                                        enum obj_operation_type op_type,
                                        struct ceph_snap_context *snapc)
{
        struct rbd_img_request *img_request;

        img_request = kmem_cache_zalloc(rbd_img_request_cache, GFP_NOIO);
        if (!img_request)
                return NULL;

        img_request->rbd_dev = rbd_dev;
        img_request->op_type = op_type;
        if (!rbd_img_is_write(img_request))
                img_request->snap_id = rbd_dev->spec->snap_id;
        else
                img_request->snapc = snapc;

        if (rbd_dev_parent_get(rbd_dev))
                img_request_layered_set(img_request);

        INIT_LIST_HEAD(&img_request->lock_item);
        INIT_LIST_HEAD(&img_request->object_extents);
        mutex_init(&img_request->state_mutex);
        kref_init(&img_request->kref);

        return img_request;
}

static void rbd_img_request_destroy(struct kref *kref)
{
        struct rbd_img_request *img_request;
        struct rbd_obj_request *obj_request;
        struct rbd_obj_request *next_obj_request;

        img_request = container_of(kref, struct rbd_img_request, kref);

        dout("%s: img %p\n", __func__, img_request);

        WARN_ON(!list_empty(&img_request->lock_item));
        for_each_obj_request_safe(img_request, obj_request, next_obj_request)
                rbd_img_obj_request_del(img_request, obj_request);

        if (img_request_layered_test(img_request)) {
                img_request_layered_clear(img_request);
                rbd_dev_parent_put(img_request->rbd_dev);
        }

        if (rbd_img_is_write(img_request))
                ceph_put_snap_context(img_request->snapc);

        kmem_cache_free(rbd_img_request_cache, img_request);
}

#define BITS_PER_OBJ    2
#define OBJS_PER_BYTE   (BITS_PER_BYTE / BITS_PER_OBJ)
#define OBJ_MASK        ((1 << BITS_PER_OBJ) - 1)

static void __rbd_object_map_index(struct rbd_device *rbd_dev, u64 objno,
                                   u64 *index, u8 *shift)
{
        u32 off;

        rbd_assert(objno < rbd_dev->object_map_size);
        *index = div_u64_rem(objno, OBJS_PER_BYTE, &off);
        *shift = (OBJS_PER_BYTE - off - 1) * BITS_PER_OBJ;
}

static u8 __rbd_object_map_get(struct rbd_device *rbd_dev, u64 objno)
{
        u64 index;
        u8 shift;

        lockdep_assert_held(&rbd_dev->object_map_lock);
        __rbd_object_map_index(rbd_dev, objno, &index, &shift);
        return (rbd_dev->object_map[index] >> shift) & OBJ_MASK;
}

static void __rbd_object_map_set(struct rbd_device *rbd_dev, u64 objno, u8 val)
{
        u64 index;
        u8 shift;
        u8 *p;

        lockdep_assert_held(&rbd_dev->object_map_lock);
        rbd_assert(!(val & ~OBJ_MASK));

        __rbd_object_map_index(rbd_dev, objno, &index, &shift);
        p = &rbd_dev->object_map[index];
        *p = (*p & ~(OBJ_MASK << shift)) | (val << shift);
}

static u8 rbd_object_map_get(struct rbd_device *rbd_dev, u64 objno)
{
        u8 state;

        spin_lock(&rbd_dev->object_map_lock);
        state = __rbd_object_map_get(rbd_dev, objno);
        spin_unlock(&rbd_dev->object_map_lock);
        return state;
}

static bool use_object_map(struct rbd_device *rbd_dev)
{
        return ((rbd_dev->header.features & RBD_FEATURE_OBJECT_MAP) &&
                !(rbd_dev->object_map_flags & RBD_FLAG_OBJECT_MAP_INVALID));
}

static bool rbd_object_map_may_exist(struct rbd_device *rbd_dev, u64 objno)
{
        u8 state;

        /* fall back to default logic if object map is disabled or invalid */
        if (!use_object_map(rbd_dev))
                return true;

        state = rbd_object_map_get(rbd_dev, objno);
        return state != OBJECT_NONEXISTENT;
}

static void rbd_object_map_name(struct rbd_device *rbd_dev, u64 snap_id,
                                struct ceph_object_id *oid)
{
        if (snap_id == CEPH_NOSNAP)
                ceph_oid_printf(oid, "%s%s", RBD_OBJECT_MAP_PREFIX,
                                rbd_dev->spec->image_id);
        else
                ceph_oid_printf(oid, "%s%s.%016llx", RBD_OBJECT_MAP_PREFIX,
                                rbd_dev->spec->image_id, snap_id);
}

static int rbd_object_map_lock(struct rbd_device *rbd_dev)
{
        struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
        CEPH_DEFINE_OID_ONSTACK(oid);
        u8 lock_type;
        char *lock_tag;
        struct ceph_locker *lockers;
        u32 num_lockers;
        bool broke_lock = false;
        int ret;

        rbd_object_map_name(rbd_dev, CEPH_NOSNAP, &oid);

again:
        ret = ceph_cls_lock(osdc, &oid, &rbd_dev->header_oloc, RBD_LOCK_NAME,
                            CEPH_CLS_LOCK_EXCLUSIVE, "", "", "", 0);
        if (ret != -EBUSY || broke_lock) {
                if (ret == -EEXIST)
                        ret = 0; /* already locked by myself */
                if (ret)
                        rbd_warn(rbd_dev, "failed to lock object map: %d", ret);
                return ret;
        }

        ret = ceph_cls_lock_info(osdc, &oid, &rbd_dev->header_oloc,
                                 RBD_LOCK_NAME, &lock_type, &lock_tag,
                                 &lockers, &num_lockers);
        if (ret) {
                if (ret == -ENOENT)
                        goto again;

                rbd_warn(rbd_dev, "failed to get object map lockers: %d", ret);
                return ret;
        }

        kfree(lock_tag);
        if (num_lockers == 0)
                goto again;

        rbd_warn(rbd_dev, "breaking object map lock owned by %s%llu",
                 ENTITY_NAME(lockers[0].id.name));

        ret = ceph_cls_break_lock(osdc, &oid, &rbd_dev->header_oloc,
                                  RBD_LOCK_NAME, lockers[0].id.cookie,
                                  &lockers[0].id.name);
        ceph_free_lockers(lockers, num_lockers);
        if (ret) {
                if (ret == -ENOENT)
                        goto again;

                rbd_warn(rbd_dev, "failed to break object map lock: %d", ret);
                return ret;
        }

        broke_lock = true;
        goto again;
}

static void rbd_object_map_unlock(struct rbd_device *rbd_dev)
{
        struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
        CEPH_DEFINE_OID_ONSTACK(oid);
        int ret;

        rbd_object_map_name(rbd_dev, CEPH_NOSNAP, &oid);

        ret = ceph_cls_unlock(osdc, &oid, &rbd_dev->header_oloc, RBD_LOCK_NAME,
                              "");
        if (ret && ret != -ENOENT)
                rbd_warn(rbd_dev, "failed to unlock object map: %d", ret);
}

static int decode_object_map_header(void **p, void *end, u64 *object_map_size)
{
        u8 struct_v;
        u32 struct_len;
        u32 header_len;
        void *header_end;
        int ret;

        ceph_decode_32_safe(p, end, header_len, e_inval);
        header_end = *p + header_len;

        ret = ceph_start_decoding(p, end, 1, "BitVector header", &struct_v,
                                  &struct_len);
        if (ret)
                return ret;

        ceph_decode_64_safe(p, end, *object_map_size, e_inval);

        *p = header_end;
        return 0;

e_inval:
        return -EINVAL;
}

static int __rbd_object_map_load(struct rbd_device *rbd_dev)
{
        struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
        CEPH_DEFINE_OID_ONSTACK(oid);
        struct page **pages;
        void *p, *end;
        size_t reply_len;
        u64 num_objects;
        u64 object_map_bytes;
        u64 object_map_size;
        int num_pages;
        int ret;

        rbd_assert(!rbd_dev->object_map && !rbd_dev->object_map_size);

        num_objects = ceph_get_num_objects(&rbd_dev->layout,
                                           rbd_dev->mapping.size);
        object_map_bytes = DIV_ROUND_UP_ULL(num_objects * BITS_PER_OBJ,
                                            BITS_PER_BYTE);
        num_pages = calc_pages_for(0, object_map_bytes) + 1;
        pages = ceph_alloc_page_vector(num_pages, GFP_KERNEL);
        if (IS_ERR(pages))
                return PTR_ERR(pages);

        reply_len = num_pages * PAGE_SIZE;
        rbd_object_map_name(rbd_dev, rbd_dev->spec->snap_id, &oid);
        ret = ceph_osdc_call(osdc, &oid, &rbd_dev->header_oloc,
                             "rbd", "object_map_load", CEPH_OSD_FLAG_READ,
                             NULL, 0, pages, &reply_len);
        if (ret)
                goto out;

        p = page_address(pages[0]);
        end = p + min(reply_len, (size_t)PAGE_SIZE);
        ret = decode_object_map_header(&p, end, &object_map_size);
        if (ret)
                goto out;

        if (object_map_size != num_objects) {
                rbd_warn(rbd_dev, "object map size mismatch: %llu vs %llu",
                         object_map_size, num_objects);
                ret = -EINVAL;

                goto out;
        }

        if (offset_in_page(p) + object_map_bytes > reply_len) {
                ret = -EINVAL;
                goto out;
        }

        rbd_dev->object_map = kvmalloc(object_map_bytes, GFP_KERNEL);
        if (!rbd_dev->object_map) {
                ret = -ENOMEM;
                goto out;
        }

        rbd_dev->object_map_size = object_map_size;
        ceph_copy_from_page_vector(pages, rbd_dev->object_map,
                                   offset_in_page(p), object_map_bytes);

out:
        ceph_release_page_vector(pages, num_pages);
        return ret;
}

static void rbd_object_map_free(struct rbd_device *rbd_dev)
{
        kvfree(rbd_dev->object_map);
        rbd_dev->object_map = NULL;
        rbd_dev->object_map_size = 0;
}

static int rbd_object_map_load(struct rbd_device *rbd_dev)
{
        int ret;

        ret = __rbd_object_map_load(rbd_dev);
        if (ret)
                return ret;

        ret = rbd_dev_v2_get_flags(rbd_dev);
        if (ret) {
                rbd_object_map_free(rbd_dev);
                return ret;
        }

        if (rbd_dev->object_map_flags & RBD_FLAG_OBJECT_MAP_INVALID)
                rbd_warn(rbd_dev, "object map is invalid");

        return 0;
}

static int rbd_object_map_open(struct rbd_device *rbd_dev)
{
        int ret;

        ret = rbd_object_map_lock(rbd_dev);
        if (ret)
                return ret;

        ret = rbd_object_map_load(rbd_dev);
        if (ret) {
                rbd_object_map_unlock(rbd_dev);
                return ret;
        }

        return 0;
}

static void rbd_object_map_close(struct rbd_device *rbd_dev)
{
        rbd_object_map_free(rbd_dev);
        rbd_object_map_unlock(rbd_dev);
}

/*
 * This function needs snap_id (or more precisely just something to
 * distinguish between HEAD and snapshot object maps), new_state and
 * current_state that were passed to rbd_object_map_update().
 *
 * To avoid allocating and stashing a context we piggyback on the OSD
 * request.  A HEAD update has two ops (assert_locked).  For new_state
 * and current_state we decode our own object_map_update op, encoded in
 * rbd_cls_object_map_update().
 */
static int rbd_object_map_update_finish(struct rbd_obj_request *obj_req,
                                        struct ceph_osd_request *osd_req)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        struct ceph_osd_data *osd_data;
        u64 objno;
        u8 state, new_state, uninitialized_var(current_state);
        bool has_current_state;
        void *p;

        if (osd_req->r_result)
                return osd_req->r_result;

        /*
         * Nothing to do for a snapshot object map.
         */
        if (osd_req->r_num_ops == 1)
                return 0;

        /*
         * Update in-memory HEAD object map.
         */
        rbd_assert(osd_req->r_num_ops == 2);
        osd_data = osd_req_op_data(osd_req, 1, cls, request_data);
        rbd_assert(osd_data->type == CEPH_OSD_DATA_TYPE_PAGES);

        p = page_address(osd_data->pages[0]);
        objno = ceph_decode_64(&p);
        rbd_assert(objno == obj_req->ex.oe_objno);
        rbd_assert(ceph_decode_64(&p) == objno + 1);
        new_state = ceph_decode_8(&p);
        has_current_state = ceph_decode_8(&p);
        if (has_current_state)
                current_state = ceph_decode_8(&p);

        spin_lock(&rbd_dev->object_map_lock);
        state = __rbd_object_map_get(rbd_dev, objno);
        if (!has_current_state || current_state == state ||
            (current_state == OBJECT_EXISTS && state == OBJECT_EXISTS_CLEAN))
                __rbd_object_map_set(rbd_dev, objno, new_state);
        spin_unlock(&rbd_dev->object_map_lock);

        return 0;
}

static void rbd_object_map_callback(struct ceph_osd_request *osd_req)
{
        struct rbd_obj_request *obj_req = osd_req->r_priv;
        int result;

        dout("%s osd_req %p result %d for obj_req %p\n", __func__, osd_req,
             osd_req->r_result, obj_req);

        result = rbd_object_map_update_finish(obj_req, osd_req);
        rbd_obj_handle_request(obj_req, result);
}

static bool update_needed(struct rbd_device *rbd_dev, u64 objno, u8 new_state)
{
        u8 state = rbd_object_map_get(rbd_dev, objno);

        if (state == new_state ||
            (new_state == OBJECT_PENDING && state == OBJECT_NONEXISTENT) ||
            (new_state == OBJECT_NONEXISTENT && state != OBJECT_PENDING))
                return false;

        return true;
}

static int rbd_cls_object_map_update(struct ceph_osd_request *req,
                                     int which, u64 objno, u8 new_state,
                                     const u8 *current_state)
{
        struct page **pages;
        void *p, *start;
        int ret;

        ret = osd_req_op_cls_init(req, which, "rbd", "object_map_update");
        if (ret)
                return ret;

        pages = ceph_alloc_page_vector(1, GFP_NOIO);
        if (IS_ERR(pages))
                return PTR_ERR(pages);

        p = start = page_address(pages[0]);
        ceph_encode_64(&p, objno);
        ceph_encode_64(&p, objno + 1);
        ceph_encode_8(&p, new_state);
        if (current_state) {
                ceph_encode_8(&p, 1);
                ceph_encode_8(&p, *current_state);
        } else {
                ceph_encode_8(&p, 0);
        }

        osd_req_op_cls_request_data_pages(req, which, pages, p - start, 0,
                                          false, true);
        return 0;
}

/*
 * Return:
 *   0 - object map update sent
 *   1 - object map update isn't needed
 *  <0 - error
 */
static int rbd_object_map_update(struct rbd_obj_request *obj_req, u64 snap_id,
                                 u8 new_state, const u8 *current_state)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
        struct ceph_osd_request *req;
        int num_ops = 1;
        int which = 0;
        int ret;

        if (snap_id == CEPH_NOSNAP) {
                if (!update_needed(rbd_dev, obj_req->ex.oe_objno, new_state))
                        return 1;

                num_ops++; /* assert_locked */
        }

        req = ceph_osdc_alloc_request(osdc, NULL, num_ops, false, GFP_NOIO);
        if (!req)
                return -ENOMEM;

        list_add_tail(&req->r_private_item, &obj_req->osd_reqs);
        req->r_callback = rbd_object_map_callback;
        req->r_priv = obj_req;

        rbd_object_map_name(rbd_dev, snap_id, &req->r_base_oid);
        ceph_oloc_copy(&req->r_base_oloc, &rbd_dev->header_oloc);
        req->r_flags = CEPH_OSD_FLAG_WRITE;
        ktime_get_real_ts64(&req->r_mtime);

        if (snap_id == CEPH_NOSNAP) {
                /*
                 * Protect against possible race conditions during lock
                 * ownership transitions.
                 */
                ret = ceph_cls_assert_locked(req, which++, RBD_LOCK_NAME,
                                             CEPH_CLS_LOCK_EXCLUSIVE, "", "");
                if (ret)
                        return ret;
        }

        ret = rbd_cls_object_map_update(req, which, obj_req->ex.oe_objno,
                                        new_state, current_state);
        if (ret)
                return ret;

        ret = ceph_osdc_alloc_messages(req, GFP_NOIO);
        if (ret)
                return ret;

        ceph_osdc_start_request(osdc, req, false);
        return 0;
}

static void prune_extents(struct ceph_file_extent *img_extents,
                          u32 *num_img_extents, u64 overlap)
{
        u32 cnt = *num_img_extents;

        /* drop extents completely beyond the overlap */
        while (cnt && img_extents[cnt - 1].fe_off >= overlap)
                cnt--;

        if (cnt) {
                struct ceph_file_extent *ex = &img_extents[cnt - 1];

                /* trim final overlapping extent */
                if (ex->fe_off + ex->fe_len > overlap)
                        ex->fe_len = overlap - ex->fe_off;
        }

        *num_img_extents = cnt;
}

/*
 * Determine the byte range(s) covered by either just the object extent
 * or the entire object in the parent image.
 */
static int rbd_obj_calc_img_extents(struct rbd_obj_request *obj_req,
                                    bool entire)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        int ret;

        if (!rbd_dev->parent_overlap)
                return 0;

        ret = ceph_extent_to_file(&rbd_dev->layout, obj_req->ex.oe_objno,
                                  entire ? 0 : obj_req->ex.oe_off,
                                  entire ? rbd_dev->layout.object_size :
                                                        obj_req->ex.oe_len,
                                  &obj_req->img_extents,
                                  &obj_req->num_img_extents);
        if (ret)
                return ret;

        prune_extents(obj_req->img_extents, &obj_req->num_img_extents,
                      rbd_dev->parent_overlap);
        return 0;
}

static void rbd_osd_setup_data(struct ceph_osd_request *osd_req, int which)
{
        struct rbd_obj_request *obj_req = osd_req->r_priv;

        switch (obj_req->img_request->data_type) {
        case OBJ_REQUEST_BIO:
                osd_req_op_extent_osd_data_bio(osd_req, which,
                                               &obj_req->bio_pos,
                                               obj_req->ex.oe_len);
                break;
        case OBJ_REQUEST_BVECS:
        case OBJ_REQUEST_OWN_BVECS:
                rbd_assert(obj_req->bvec_pos.iter.bi_size ==
                                                        obj_req->ex.oe_len);
                rbd_assert(obj_req->bvec_idx == obj_req->bvec_count);
                osd_req_op_extent_osd_data_bvec_pos(osd_req, which,
                                                    &obj_req->bvec_pos);
                break;
        default:
                BUG();
        }
}

static int rbd_osd_setup_stat(struct ceph_osd_request *osd_req, int which)
{
        struct page **pages;

        /*
         * The response data for a STAT call consists of:
         *     le64 length;
         *     struct {
         *         le32 tv_sec;
         *         le32 tv_nsec;
         *     } mtime;
         */
        pages = ceph_alloc_page_vector(1, GFP_NOIO);
        if (IS_ERR(pages))
                return PTR_ERR(pages);

        osd_req_op_init(osd_req, which, CEPH_OSD_OP_STAT, 0);
        osd_req_op_raw_data_in_pages(osd_req, which, pages,
                                     8 + sizeof(struct ceph_timespec),
                                     0, false, true);
        return 0;
}

static int rbd_osd_setup_copyup(struct ceph_osd_request *osd_req, int which,
                                u32 bytes)
{
        struct rbd_obj_request *obj_req = osd_req->r_priv;
        int ret;

        ret = osd_req_op_cls_init(osd_req, which, "rbd", "copyup");
        if (ret)
                return ret;

        osd_req_op_cls_request_data_bvecs(osd_req, which, obj_req->copyup_bvecs,
                                          obj_req->copyup_bvec_count, bytes);
        return 0;
}

static int rbd_obj_init_read(struct rbd_obj_request *obj_req)
{
        obj_req->read_state = RBD_OBJ_READ_START;
        return 0;
}

static void __rbd_osd_setup_write_ops(struct ceph_osd_request *osd_req,
                                      int which)
{
        struct rbd_obj_request *obj_req = osd_req->r_priv;
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        u16 opcode;

        if (!use_object_map(rbd_dev) ||
            !(obj_req->flags & RBD_OBJ_FLAG_MAY_EXIST)) {
                osd_req_op_alloc_hint_init(osd_req, which++,
                                           rbd_dev->layout.object_size,
                                           rbd_dev->layout.object_size);
        }

        if (rbd_obj_is_entire(obj_req))
                opcode = CEPH_OSD_OP_WRITEFULL;
        else
                opcode = CEPH_OSD_OP_WRITE;

        osd_req_op_extent_init(osd_req, which, opcode,
                               obj_req->ex.oe_off, obj_req->ex.oe_len, 0, 0);
        rbd_osd_setup_data(osd_req, which);
}

static int rbd_obj_init_write(struct rbd_obj_request *obj_req)
{
        int ret;

        /* reverse map the entire object onto the parent */
        ret = rbd_obj_calc_img_extents(obj_req, true);
        if (ret)
                return ret;

        if (rbd_obj_copyup_enabled(obj_req))
                obj_req->flags |= RBD_OBJ_FLAG_COPYUP_ENABLED;

        obj_req->write_state = RBD_OBJ_WRITE_START;
        return 0;
}

static u16 truncate_or_zero_opcode(struct rbd_obj_request *obj_req)
{
        return rbd_obj_is_tail(obj_req) ? CEPH_OSD_OP_TRUNCATE :
                                          CEPH_OSD_OP_ZERO;
}

static void __rbd_osd_setup_discard_ops(struct ceph_osd_request *osd_req,
                                        int which)
{
        struct rbd_obj_request *obj_req = osd_req->r_priv;

        if (rbd_obj_is_entire(obj_req) && !obj_req->num_img_extents) {
                rbd_assert(obj_req->flags & RBD_OBJ_FLAG_DELETION);
                osd_req_op_init(osd_req, which, CEPH_OSD_OP_DELETE, 0);
        } else {
                osd_req_op_extent_init(osd_req, which,
                                       truncate_or_zero_opcode(obj_req),
                                       obj_req->ex.oe_off, obj_req->ex.oe_len,
                                       0, 0);
        }
}

static int rbd_obj_init_discard(struct rbd_obj_request *obj_req)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        u64 off, next_off;
        int ret;

        /*
         * Align the range to alloc_size boundary and punt on discards
         * that are too small to free up any space.
         *
         * alloc_size == object_size && is_tail() is a special case for
         * filestore with filestore_punch_hole = false, needed to allow
         * truncate (in addition to delete).
         */
        if (rbd_dev->opts->alloc_size != rbd_dev->layout.object_size ||
            !rbd_obj_is_tail(obj_req)) {
                off = round_up(obj_req->ex.oe_off, rbd_dev->opts->alloc_size);
                next_off = round_down(obj_req->ex.oe_off + obj_req->ex.oe_len,
                                      rbd_dev->opts->alloc_size);
                if (off >= next_off)
                        return 1;

                dout("%s %p %llu~%llu -> %llu~%llu\n", __func__,
                     obj_req, obj_req->ex.oe_off, obj_req->ex.oe_len,
                     off, next_off - off);
                obj_req->ex.oe_off = off;
                obj_req->ex.oe_len = next_off - off;
        }

        /* reverse map the entire object onto the parent */
        ret = rbd_obj_calc_img_extents(obj_req, true);
        if (ret)
                return ret;

        obj_req->flags |= RBD_OBJ_FLAG_NOOP_FOR_NONEXISTENT;
        if (rbd_obj_is_entire(obj_req) && !obj_req->num_img_extents)
                obj_req->flags |= RBD_OBJ_FLAG_DELETION;

        obj_req->write_state = RBD_OBJ_WRITE_START;
        return 0;
}

static void __rbd_osd_setup_zeroout_ops(struct ceph_osd_request *osd_req,
                                        int which)
{
        struct rbd_obj_request *obj_req = osd_req->r_priv;
        u16 opcode;

        if (rbd_obj_is_entire(obj_req)) {
                if (obj_req->num_img_extents) {
                        if (!(obj_req->flags & RBD_OBJ_FLAG_COPYUP_ENABLED))
                                osd_req_op_init(osd_req, which++,
                                                CEPH_OSD_OP_CREATE, 0);
                        opcode = CEPH_OSD_OP_TRUNCATE;
                } else {
                        rbd_assert(obj_req->flags & RBD_OBJ_FLAG_DELETION);
                        osd_req_op_init(osd_req, which++,
                                        CEPH_OSD_OP_DELETE, 0);
                        opcode = 0;
                }
        } else {
                opcode = truncate_or_zero_opcode(obj_req);
        }

        if (opcode)
                osd_req_op_extent_init(osd_req, which, opcode,
                                       obj_req->ex.oe_off, obj_req->ex.oe_len,
                                       0, 0);
}

static int rbd_obj_init_zeroout(struct rbd_obj_request *obj_req)
{
        int ret;

        /* reverse map the entire object onto the parent */
        ret = rbd_obj_calc_img_extents(obj_req, true);
        if (ret)
                return ret;

        if (rbd_obj_copyup_enabled(obj_req))
                obj_req->flags |= RBD_OBJ_FLAG_COPYUP_ENABLED;
        if (!obj_req->num_img_extents) {
                obj_req->flags |= RBD_OBJ_FLAG_NOOP_FOR_NONEXISTENT;
                if (rbd_obj_is_entire(obj_req))
                        obj_req->flags |= RBD_OBJ_FLAG_DELETION;
        }

        obj_req->write_state = RBD_OBJ_WRITE_START;
        return 0;
}

static int count_write_ops(struct rbd_obj_request *obj_req)
{
        struct rbd_img_request *img_req = obj_req->img_request;

        switch (img_req->op_type) {
        case OBJ_OP_WRITE:
                if (!use_object_map(img_req->rbd_dev) ||
                    !(obj_req->flags & RBD_OBJ_FLAG_MAY_EXIST))
                        return 2; /* setallochint + write/writefull */

                return 1; /* write/writefull */
        case OBJ_OP_DISCARD:
                return 1; /* delete/truncate/zero */
        case OBJ_OP_ZEROOUT:
                if (rbd_obj_is_entire(obj_req) && obj_req->num_img_extents &&
                    !(obj_req->flags & RBD_OBJ_FLAG_COPYUP_ENABLED))
                        return 2; /* create + truncate */

                return 1; /* delete/truncate/zero */
        default:
                BUG();
        }
}

static void rbd_osd_setup_write_ops(struct ceph_osd_request *osd_req,
                                    int which)
{
        struct rbd_obj_request *obj_req = osd_req->r_priv;

        switch (obj_req->img_request->op_type) {
        case OBJ_OP_WRITE:
                __rbd_osd_setup_write_ops(osd_req, which);
                break;
        case OBJ_OP_DISCARD:
                __rbd_osd_setup_discard_ops(osd_req, which);
                break;
        case OBJ_OP_ZEROOUT:
                __rbd_osd_setup_zeroout_ops(osd_req, which);
                break;
        default:
                BUG();
        }
}

/*
 * Prune the list of object requests (adjust offset and/or length, drop
 * redundant requests).  Prepare object request state machines and image
 * request state machine for execution.
 */
static int __rbd_img_fill_request(struct rbd_img_request *img_req)
{
        struct rbd_obj_request *obj_req, *next_obj_req;
        int ret;

        for_each_obj_request_safe(img_req, obj_req, next_obj_req) {
                switch (img_req->op_type) {
                case OBJ_OP_READ:
                        ret = rbd_obj_init_read(obj_req);
                        break;
                case OBJ_OP_WRITE:
                        ret = rbd_obj_init_write(obj_req);
                        break;
                case OBJ_OP_DISCARD:
                        ret = rbd_obj_init_discard(obj_req);
                        break;
                case OBJ_OP_ZEROOUT:
                        ret = rbd_obj_init_zeroout(obj_req);
                        break;
                default:
                        BUG();
                }
                if (ret < 0)
                        return ret;
                if (ret > 0) {
                        rbd_img_obj_request_del(img_req, obj_req);
                        continue;
                }
        }

        img_req->state = RBD_IMG_START;
        return 0;
}

union rbd_img_fill_iter {
        struct ceph_bio_iter    bio_iter;
        struct ceph_bvec_iter   bvec_iter;
};

struct rbd_img_fill_ctx {
        enum obj_request_type   pos_type;
        union rbd_img_fill_iter *pos;
        union rbd_img_fill_iter iter;
        ceph_object_extent_fn_t set_pos_fn;
        ceph_object_extent_fn_t count_fn;
        ceph_object_extent_fn_t copy_fn;
};

static struct ceph_object_extent *alloc_object_extent(void *arg)
{
        struct rbd_img_request *img_req = arg;
        struct rbd_obj_request *obj_req;

        obj_req = rbd_obj_request_create();
        if (!obj_req)
                return NULL;

        rbd_img_obj_request_add(img_req, obj_req);
        return &obj_req->ex;
}

/*
 * While su != os && sc == 1 is technically not fancy (it's the same
 * layout as su == os && sc == 1), we can't use the nocopy path for it
 * because ->set_pos_fn() should be called only once per object.
 * ceph_file_to_extents() invokes action_fn once per stripe unit, so
 * treat su != os && sc == 1 as fancy.
 */
static bool rbd_layout_is_fancy(struct ceph_file_layout *l)
{
        return l->stripe_unit != l->object_size;
}

static int rbd_img_fill_request_nocopy(struct rbd_img_request *img_req,
                                       struct ceph_file_extent *img_extents,
                                       u32 num_img_extents,
                                       struct rbd_img_fill_ctx *fctx)
{
        u32 i;
        int ret;

        img_req->data_type = fctx->pos_type;

        /*
         * Create object requests and set each object request's starting
         * position in the provided bio (list) or bio_vec array.
         */
        fctx->iter = *fctx->pos;
        for (i = 0; i < num_img_extents; i++) {
                ret = ceph_file_to_extents(&img_req->rbd_dev->layout,
                                           img_extents[i].fe_off,
                                           img_extents[i].fe_len,
                                           &img_req->object_extents,
                                           alloc_object_extent, img_req,
                                           fctx->set_pos_fn, &fctx->iter);
                if (ret)
                        return ret;
        }

        return __rbd_img_fill_request(img_req);
}

/*
 * Map a list of image extents to a list of object extents, create the
 * corresponding object requests (normally each to a different object,
 * but not always) and add them to @img_req.  For each object request,
 * set up its data descriptor to point to the corresponding chunk(s) of
 * @fctx->pos data buffer.
 *
 * Because ceph_file_to_extents() will merge adjacent object extents
 * together, each object request's data descriptor may point to multiple
 * different chunks of @fctx->pos data buffer.
 *
 * @fctx->pos data buffer is assumed to be large enough.
 */
static int rbd_img_fill_request(struct rbd_img_request *img_req,
                                struct ceph_file_extent *img_extents,
                                u32 num_img_extents,
                                struct rbd_img_fill_ctx *fctx)
{
        struct rbd_device *rbd_dev = img_req->rbd_dev;
        struct rbd_obj_request *obj_req;
        u32 i;
        int ret;

        if (fctx->pos_type == OBJ_REQUEST_NODATA ||
            !rbd_layout_is_fancy(&rbd_dev->layout))
                return rbd_img_fill_request_nocopy(img_req, img_extents,
                                                   num_img_extents, fctx);

        img_req->data_type = OBJ_REQUEST_OWN_BVECS;

        /*
         * Create object requests and determine ->bvec_count for each object
         * request.  Note that ->bvec_count sum over all object requests may
         * be greater than the number of bio_vecs in the provided bio (list)
         * or bio_vec array because when mapped, those bio_vecs can straddle
         * stripe unit boundaries.
         */
        fctx->iter = *fctx->pos;
        for (i = 0; i < num_img_extents; i++) {
                ret = ceph_file_to_extents(&rbd_dev->layout,
                                           img_extents[i].fe_off,
                                           img_extents[i].fe_len,
                                           &img_req->object_extents,
                                           alloc_object_extent, img_req,
                                           fctx->count_fn, &fctx->iter);
                if (ret)
                        return ret;
        }

        for_each_obj_request(img_req, obj_req) {
                obj_req->bvec_pos.bvecs = kmalloc_array(obj_req->bvec_count,
                                              sizeof(*obj_req->bvec_pos.bvecs),
                                              GFP_NOIO);
                if (!obj_req->bvec_pos.bvecs)
                        return -ENOMEM;
        }

        /*
         * Fill in each object request's private bio_vec array, splitting and
         * rearranging the provided bio_vecs in stripe unit chunks as needed.
         */
        fctx->iter = *fctx->pos;
        for (i = 0; i < num_img_extents; i++) {
                ret = ceph_iterate_extents(&rbd_dev->layout,
                                           img_extents[i].fe_off,
                                           img_extents[i].fe_len,
                                           &img_req->object_extents,
                                           fctx->copy_fn, &fctx->iter);
                if (ret)
                        return ret;
        }

        return __rbd_img_fill_request(img_req);
}

static int rbd_img_fill_nodata(struct rbd_img_request *img_req,
                               u64 off, u64 len)
{
        struct ceph_file_extent ex = { off, len };
        union rbd_img_fill_iter dummy;
        struct rbd_img_fill_ctx fctx = {
                .pos_type = OBJ_REQUEST_NODATA,
                .pos = &dummy,
        };

        return rbd_img_fill_request(img_req, &ex, 1, &fctx);
}

static void set_bio_pos(struct ceph_object_extent *ex, u32 bytes, void *arg)
{
        struct rbd_obj_request *obj_req =
            container_of(ex, struct rbd_obj_request, ex);
        struct ceph_bio_iter *it = arg;

        dout("%s objno %llu bytes %u\n", __func__, ex->oe_objno, bytes);
        obj_req->bio_pos = *it;
        ceph_bio_iter_advance(it, bytes);
}

static void count_bio_bvecs(struct ceph_object_extent *ex, u32 bytes, void *arg)
{
        struct rbd_obj_request *obj_req =
            container_of(ex, struct rbd_obj_request, ex);
        struct ceph_bio_iter *it = arg;

        dout("%s objno %llu bytes %u\n", __func__, ex->oe_objno, bytes);
        ceph_bio_iter_advance_step(it, bytes, ({
                obj_req->bvec_count++;
        }));

}

static void copy_bio_bvecs(struct ceph_object_extent *ex, u32 bytes, void *arg)
{
        struct rbd_obj_request *obj_req =
            container_of(ex, struct rbd_obj_request, ex);
        struct ceph_bio_iter *it = arg;

        dout("%s objno %llu bytes %u\n", __func__, ex->oe_objno, bytes);
        ceph_bio_iter_advance_step(it, bytes, ({
                obj_req->bvec_pos.bvecs[obj_req->bvec_idx++] = bv;
                obj_req->bvec_pos.iter.bi_size += bv.bv_len;
        }));
}

static int __rbd_img_fill_from_bio(struct rbd_img_request *img_req,
                                   struct ceph_file_extent *img_extents,
                                   u32 num_img_extents,
                                   struct ceph_bio_iter *bio_pos)
{
        struct rbd_img_fill_ctx fctx = {
                .pos_type = OBJ_REQUEST_BIO,
                .pos = (union rbd_img_fill_iter *)bio_pos,
                .set_pos_fn = set_bio_pos,
                .count_fn = count_bio_bvecs,
                .copy_fn = copy_bio_bvecs,
        };

        return rbd_img_fill_request(img_req, img_extents, num_img_extents,
                                    &fctx);
}

static int rbd_img_fill_from_bio(struct rbd_img_request *img_req,
                                 u64 off, u64 len, struct bio *bio)
{
        struct ceph_file_extent ex = { off, len };
        struct ceph_bio_iter it = { .bio = bio, .iter = bio->bi_iter };

        return __rbd_img_fill_from_bio(img_req, &ex, 1, &it);
}

static void set_bvec_pos(struct ceph_object_extent *ex, u32 bytes, void *arg)
{
        struct rbd_obj_request *obj_req =
            container_of(ex, struct rbd_obj_request, ex);
        struct ceph_bvec_iter *it = arg;

        obj_req->bvec_pos = *it;
        ceph_bvec_iter_shorten(&obj_req->bvec_pos, bytes);
        ceph_bvec_iter_advance(it, bytes);
}

static void count_bvecs(struct ceph_object_extent *ex, u32 bytes, void *arg)
{
        struct rbd_obj_request *obj_req =
            container_of(ex, struct rbd_obj_request, ex);
        struct ceph_bvec_iter *it = arg;

        ceph_bvec_iter_advance_step(it, bytes, ({
                obj_req->bvec_count++;
        }));
}

static void copy_bvecs(struct ceph_object_extent *ex, u32 bytes, void *arg)
{
        struct rbd_obj_request *obj_req =
            container_of(ex, struct rbd_obj_request, ex);
        struct ceph_bvec_iter *it = arg;

        ceph_bvec_iter_advance_step(it, bytes, ({
                obj_req->bvec_pos.bvecs[obj_req->bvec_idx++] = bv;
                obj_req->bvec_pos.iter.bi_size += bv.bv_len;
        }));
}

static int __rbd_img_fill_from_bvecs(struct rbd_img_request *img_req,
                                     struct ceph_file_extent *img_extents,
                                     u32 num_img_extents,
                                     struct ceph_bvec_iter *bvec_pos)
{
        struct rbd_img_fill_ctx fctx = {
                .pos_type = OBJ_REQUEST_BVECS,
                .pos = (union rbd_img_fill_iter *)bvec_pos,
                .set_pos_fn = set_bvec_pos,
                .count_fn = count_bvecs,
                .copy_fn = copy_bvecs,
        };

        return rbd_img_fill_request(img_req, img_extents, num_img_extents,
                                    &fctx);
}

static int rbd_img_fill_from_bvecs(struct rbd_img_request *img_req,
                                   struct ceph_file_extent *img_extents,
                                   u32 num_img_extents,
                                   struct bio_vec *bvecs)
{
        struct ceph_bvec_iter it = {
                .bvecs = bvecs,
                .iter = { .bi_size = ceph_file_extents_bytes(img_extents,
                                                             num_img_extents) },
        };

        return __rbd_img_fill_from_bvecs(img_req, img_extents, num_img_extents,
                                         &it);
}

static void rbd_img_handle_request_work(struct work_struct *work)
{
        struct rbd_img_request *img_req =
            container_of(work, struct rbd_img_request, work);

        rbd_img_handle_request(img_req, img_req->work_result);
}

static void rbd_img_schedule(struct rbd_img_request *img_req, int result)
{
        INIT_WORK(&img_req->work, rbd_img_handle_request_work);
        img_req->work_result = result;
        queue_work(rbd_wq, &img_req->work);
}

static bool rbd_obj_may_exist(struct rbd_obj_request *obj_req)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;

        if (rbd_object_map_may_exist(rbd_dev, obj_req->ex.oe_objno)) {
                obj_req->flags |= RBD_OBJ_FLAG_MAY_EXIST;
                return true;
        }

        dout("%s %p objno %llu assuming dne\n", __func__, obj_req,
             obj_req->ex.oe_objno);
        return false;
}

static int rbd_obj_read_object(struct rbd_obj_request *obj_req)
{
        struct ceph_osd_request *osd_req;
        int ret;

        osd_req = __rbd_obj_add_osd_request(obj_req, NULL, 1);
        if (IS_ERR(osd_req))
                return PTR_ERR(osd_req);

        osd_req_op_extent_init(osd_req, 0, CEPH_OSD_OP_READ,
                               obj_req->ex.oe_off, obj_req->ex.oe_len, 0, 0);
        rbd_osd_setup_data(osd_req, 0);
        rbd_osd_format_read(osd_req);

        ret = ceph_osdc_alloc_messages(osd_req, GFP_NOIO);
        if (ret)
                return ret;

        rbd_osd_submit(osd_req);
        return 0;
}

static int rbd_obj_read_from_parent(struct rbd_obj_request *obj_req)
{
        struct rbd_img_request *img_req = obj_req->img_request;
        struct rbd_img_request *child_img_req;
        int ret;

        child_img_req = rbd_img_request_create(img_req->rbd_dev->parent,
                                               OBJ_OP_READ, NULL);
        if (!child_img_req)
                return -ENOMEM;

        __set_bit(IMG_REQ_CHILD, &child_img_req->flags);
        child_img_req->obj_request = obj_req;

        dout("%s child_img_req %p for obj_req %p\n", __func__, child_img_req,
             obj_req);

        if (!rbd_img_is_write(img_req)) {
                switch (img_req->data_type) {
                case OBJ_REQUEST_BIO:
                        ret = __rbd_img_fill_from_bio(child_img_req,
                                                      obj_req->img_extents,
                                                      obj_req->num_img_extents,
                                                      &obj_req->bio_pos);
                        break;
                case OBJ_REQUEST_BVECS:
                case OBJ_REQUEST_OWN_BVECS:
                        ret = __rbd_img_fill_from_bvecs(child_img_req,
                                                      obj_req->img_extents,
                                                      obj_req->num_img_extents,
                                                      &obj_req->bvec_pos);
                        break;
                default:
                        BUG();
                }
        } else {
                ret = rbd_img_fill_from_bvecs(child_img_req,
                                              obj_req->img_extents,
                                              obj_req->num_img_extents,
                                              obj_req->copyup_bvecs);
        }
        if (ret) {
                rbd_img_request_put(child_img_req);
                return ret;
        }

        /* avoid parent chain recursion */
        rbd_img_schedule(child_img_req, 0);
        return 0;
}

static bool rbd_obj_advance_read(struct rbd_obj_request *obj_req, int *result)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        int ret;

again:
        switch (obj_req->read_state) {
        case RBD_OBJ_READ_START:
                rbd_assert(!*result);

                if (!rbd_obj_may_exist(obj_req)) {
                        *result = -ENOENT;
                        obj_req->read_state = RBD_OBJ_READ_OBJECT;
                        goto again;
                }

                ret = rbd_obj_read_object(obj_req);
                if (ret) {
                        *result = ret;

                        return true;
                }
                obj_req->read_state = RBD_OBJ_READ_OBJECT;
                return false;
        case RBD_OBJ_READ_OBJECT:
                if (*result == -ENOENT && rbd_dev->parent_overlap) {
                        /* reverse map this object extent onto the parent */
                        ret = rbd_obj_calc_img_extents(obj_req, false);
                        if (ret) {
                                *result = ret;
                                return true;
                        }
                        if (obj_req->num_img_extents) {
                                ret = rbd_obj_read_from_parent(obj_req);
                                if (ret) {
                                        *result = ret;
                                        return true;
                                }
                                obj_req->read_state = RBD_OBJ_READ_PARENT;
                                return false;
                        }
                }

                /*
                 * -ENOENT means a hole in the image -- zero-fill the entire
                 * length of the request.  A short read also implies zero-fill
                 * to the end of the request.
                 */
                if (*result == -ENOENT) {
                        rbd_obj_zero_range(obj_req, 0, obj_req->ex.oe_len);
                        *result = 0;
                } else if (*result >= 0) {
                        if (*result < obj_req->ex.oe_len)
                                rbd_obj_zero_range(obj_req, *result,
                                                obj_req->ex.oe_len - *result);
                        else
                                rbd_assert(*result == obj_req->ex.oe_len);
                        *result = 0;
                }
                return true;
        case RBD_OBJ_READ_PARENT:
                /*
                 * The parent image is read only up to the overlap -- zero-fill
                 * from the overlap to the end of the request.
                 */
                if (!*result) {
                        u32 obj_overlap = rbd_obj_img_extents_bytes(obj_req);

                        if (obj_overlap < obj_req->ex.oe_len)
                                rbd_obj_zero_range(obj_req, obj_overlap,
                                            obj_req->ex.oe_len - obj_overlap);
                }
                return true;
        default:
                BUG();
        }
}

static bool rbd_obj_write_is_noop(struct rbd_obj_request *obj_req)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;

        if (rbd_object_map_may_exist(rbd_dev, obj_req->ex.oe_objno))
                obj_req->flags |= RBD_OBJ_FLAG_MAY_EXIST;

        if (!(obj_req->flags & RBD_OBJ_FLAG_MAY_EXIST) &&
            (obj_req->flags & RBD_OBJ_FLAG_NOOP_FOR_NONEXISTENT)) {
                dout("%s %p noop for nonexistent\n", __func__, obj_req);
                return true;
        }

        return false;
}

/*
 * Return:
 *   0 - object map update sent
 *   1 - object map update isn't needed
 *  <0 - error
 */
static int rbd_obj_write_pre_object_map(struct rbd_obj_request *obj_req)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        u8 new_state;

        if (!(rbd_dev->header.features & RBD_FEATURE_OBJECT_MAP))
                return 1;

        if (obj_req->flags & RBD_OBJ_FLAG_DELETION)
                new_state = OBJECT_PENDING;
        else
                new_state = OBJECT_EXISTS;

        return rbd_object_map_update(obj_req, CEPH_NOSNAP, new_state, NULL);
}

static int rbd_obj_write_object(struct rbd_obj_request *obj_req)
{
        struct ceph_osd_request *osd_req;
        int num_ops = count_write_ops(obj_req);
        int which = 0;
        int ret;

        if (obj_req->flags & RBD_OBJ_FLAG_COPYUP_ENABLED)
                num_ops++; /* stat */

        osd_req = rbd_obj_add_osd_request(obj_req, num_ops);
        if (IS_ERR(osd_req))
                return PTR_ERR(osd_req);

        if (obj_req->flags & RBD_OBJ_FLAG_COPYUP_ENABLED) {
                ret = rbd_osd_setup_stat(osd_req, which++);
                if (ret)
                        return ret;
        }

        rbd_osd_setup_write_ops(osd_req, which);
        rbd_osd_format_write(osd_req);

        ret = ceph_osdc_alloc_messages(osd_req, GFP_NOIO);
        if (ret)
                return ret;

        rbd_osd_submit(osd_req);
        return 0;
}

/*
 * copyup_bvecs pages are never highmem pages
 */
static bool is_zero_bvecs(struct bio_vec *bvecs, u32 bytes)
{
        struct ceph_bvec_iter it = {
                .bvecs = bvecs,
                .iter = { .bi_size = bytes },
        };

        ceph_bvec_iter_advance_step(&it, bytes, ({
                if (memchr_inv(page_address(bv.bv_page) + bv.bv_offset, 0,
                               bv.bv_len))
                        return false;
        }));
        return true;
}

#define MODS_ONLY       U32_MAX

static int rbd_obj_copyup_empty_snapc(struct rbd_obj_request *obj_req,
                                      u32 bytes)
{
        struct ceph_osd_request *osd_req;
        int ret;

        dout("%s obj_req %p bytes %u\n", __func__, obj_req, bytes);
        rbd_assert(bytes > 0 && bytes != MODS_ONLY);

        osd_req = __rbd_obj_add_osd_request(obj_req, &rbd_empty_snapc, 1);
        if (IS_ERR(osd_req))
                return PTR_ERR(osd_req);

        ret = rbd_osd_setup_copyup(osd_req, 0, bytes);
        if (ret)
                return ret;

        rbd_osd_format_write(osd_req);

        ret = ceph_osdc_alloc_messages(osd_req, GFP_NOIO);
        if (ret)
                return ret;

        rbd_osd_submit(osd_req);
        return 0;
}

static int rbd_obj_copyup_current_snapc(struct rbd_obj_request *obj_req,
                                        u32 bytes)
{
        struct ceph_osd_request *osd_req;
        int num_ops = count_write_ops(obj_req);
        int which = 0;
        int ret;

        dout("%s obj_req %p bytes %u\n", __func__, obj_req, bytes);

        if (bytes != MODS_ONLY)
                num_ops++; /* copyup */

        osd_req = rbd_obj_add_osd_request(obj_req, num_ops);
        if (IS_ERR(osd_req))
                return PTR_ERR(osd_req);

        if (bytes != MODS_ONLY) {
                ret = rbd_osd_setup_copyup(osd_req, which++, bytes);
                if (ret)
                        return ret;
        }

        rbd_osd_setup_write_ops(osd_req, which);
        rbd_osd_format_write(osd_req);

        ret = ceph_osdc_alloc_messages(osd_req, GFP_NOIO);
        if (ret)
                return ret;

        rbd_osd_submit(osd_req);
        return 0;
}

static int setup_copyup_bvecs(struct rbd_obj_request *obj_req, u64 obj_overlap)
{
        u32 i;

        rbd_assert(!obj_req->copyup_bvecs);
        obj_req->copyup_bvec_count = calc_pages_for(0, obj_overlap);
        obj_req->copyup_bvecs = kcalloc(obj_req->copyup_bvec_count,
                                        sizeof(*obj_req->copyup_bvecs),
                                        GFP_NOIO);
        if (!obj_req->copyup_bvecs)
                return -ENOMEM;

        for (i = 0; i < obj_req->copyup_bvec_count; i++) {
                unsigned int len = min(obj_overlap, (u64)PAGE_SIZE);

                obj_req->copyup_bvecs[i].bv_page = alloc_page(GFP_NOIO);
                if (!obj_req->copyup_bvecs[i].bv_page)
                        return -ENOMEM;

                obj_req->copyup_bvecs[i].bv_offset = 0;
                obj_req->copyup_bvecs[i].bv_len = len;
                obj_overlap -= len;
        }

        rbd_assert(!obj_overlap);
        return 0;
}

/*
 * The target object doesn't exist.  Read the data for the entire
 * target object up to the overlap point (if any) from the parent,
 * so we can use it for a copyup.
 */
static int rbd_obj_copyup_read_parent(struct rbd_obj_request *obj_req)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        int ret;

        rbd_assert(obj_req->num_img_extents);
        prune_extents(obj_req->img_extents, &obj_req->num_img_extents,
                      rbd_dev->parent_overlap);
        if (!obj_req->num_img_extents) {
                /*
                 * The overlap has become 0 (most likely because the
                 * image has been flattened).  Re-submit the original write
                 * request -- pass MODS_ONLY since the copyup isn't needed
                 * anymore.
                 */
                return rbd_obj_copyup_current_snapc(obj_req, MODS_ONLY);
        }

        ret = setup_copyup_bvecs(obj_req, rbd_obj_img_extents_bytes(obj_req));
        if (ret)
                return ret;

        return rbd_obj_read_from_parent(obj_req);
}

static void rbd_obj_copyup_object_maps(struct rbd_obj_request *obj_req)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        struct ceph_snap_context *snapc = obj_req->img_request->snapc;
        u8 new_state;
        u32 i;
        int ret;

        rbd_assert(!obj_req->pending.result && !obj_req->pending.num_pending);

        if (!(rbd_dev->header.features & RBD_FEATURE_OBJECT_MAP))
                return;

        if (obj_req->flags & RBD_OBJ_FLAG_COPYUP_ZEROS)
                return;

        for (i = 0; i < snapc->num_snaps; i++) {
                if ((rbd_dev->header.features & RBD_FEATURE_FAST_DIFF) &&
                    i + 1 < snapc->num_snaps)
                        new_state = OBJECT_EXISTS_CLEAN;
                else
                        new_state = OBJECT_EXISTS;

                ret = rbd_object_map_update(obj_req, snapc->snaps[i],
                                            new_state, NULL);
                if (ret < 0) {
                        obj_req->pending.result = ret;
                        return;
                }

                rbd_assert(!ret);
                obj_req->pending.num_pending++;
        }
}

static void rbd_obj_copyup_write_object(struct rbd_obj_request *obj_req)
{
        u32 bytes = rbd_obj_img_extents_bytes(obj_req);
        int ret;

        rbd_assert(!obj_req->pending.result && !obj_req->pending.num_pending);

        /*
         * Only send non-zero copyup data to save some I/O and network
         * bandwidth -- zero copyup data is equivalent to the object not
         * existing.
         */
        if (obj_req->flags & RBD_OBJ_FLAG_COPYUP_ZEROS)
                bytes = 0;

        if (obj_req->img_request->snapc->num_snaps && bytes > 0) {
                /*
                 * Send a copyup request with an empty snapshot context to
                 * deep-copyup the object through all existing snapshots.
                 * A second request with the current snapshot context will be
                 * sent for the actual modification.
                 */
                ret = rbd_obj_copyup_empty_snapc(obj_req, bytes);
                if (ret) {
                        obj_req->pending.result = ret;
                        return;
                }

                obj_req->pending.num_pending++;
                bytes = MODS_ONLY;
        }

        ret = rbd_obj_copyup_current_snapc(obj_req, bytes);
        if (ret) {
                obj_req->pending.result = ret;
                return;
        }

        obj_req->pending.num_pending++;
}

static bool rbd_obj_advance_copyup(struct rbd_obj_request *obj_req, int *result)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        int ret;

again:
        switch (obj_req->copyup_state) {
        case RBD_OBJ_COPYUP_START:
                rbd_assert(!*result);

                ret = rbd_obj_copyup_read_parent(obj_req);
                if (ret) {
                        *result = ret;
                        return true;
                }
                if (obj_req->num_img_extents)
                        obj_req->copyup_state = RBD_OBJ_COPYUP_READ_PARENT;
                else
                        obj_req->copyup_state = RBD_OBJ_COPYUP_WRITE_OBJECT;
                return false;
        case RBD_OBJ_COPYUP_READ_PARENT:
                if (*result)
                        return true;

                if (is_zero_bvecs(obj_req->copyup_bvecs,
                                  rbd_obj_img_extents_bytes(obj_req))) {
                        dout("%s %p detected zeros\n", __func__, obj_req);
                        obj_req->flags |= RBD_OBJ_FLAG_COPYUP_ZEROS;
                }

                rbd_obj_copyup_object_maps(obj_req);
                if (!obj_req->pending.num_pending) {
                        *result = obj_req->pending.result;
                        obj_req->copyup_state = RBD_OBJ_COPYUP_OBJECT_MAPS;
                        goto again;
                }
                obj_req->copyup_state = __RBD_OBJ_COPYUP_OBJECT_MAPS;
                return false;
        case __RBD_OBJ_COPYUP_OBJECT_MAPS:
                if (!pending_result_dec(&obj_req->pending, result))
                        return false;
                /* fall through */
        case RBD_OBJ_COPYUP_OBJECT_MAPS:
                if (*result) {
                        rbd_warn(rbd_dev, "snap object map update failed: %d",
                                 *result);
                        return true;
                }

                rbd_obj_copyup_write_object(obj_req);
                if (!obj_req->pending.num_pending) {
                        *result = obj_req->pending.result;
                        obj_req->copyup_state = RBD_OBJ_COPYUP_WRITE_OBJECT;
                        goto again;
                }
                obj_req->copyup_state = __RBD_OBJ_COPYUP_WRITE_OBJECT;
                return false;
        case __RBD_OBJ_COPYUP_WRITE_OBJECT:
                if (!pending_result_dec(&obj_req->pending, result))
                        return false;
                /* fall through */
        case RBD_OBJ_COPYUP_WRITE_OBJECT:
                return true;
        default:
                BUG();
        }
}

/*
 * Return:
 *   0 - object map update sent
 *   1 - object map update isn't needed
 *  <0 - error
 */
static int rbd_obj_write_post_object_map(struct rbd_obj_request *obj_req)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        u8 current_state = OBJECT_PENDING;

        if (!(rbd_dev->header.features & RBD_FEATURE_OBJECT_MAP))
                return 1;

        if (!(obj_req->flags & RBD_OBJ_FLAG_DELETION))
                return 1;

        return rbd_object_map_update(obj_req, CEPH_NOSNAP, OBJECT_NONEXISTENT,
                                     &current_state);
}

static bool rbd_obj_advance_write(struct rbd_obj_request *obj_req, int *result)
{
        struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
        int ret;

again:
        switch (obj_req->write_state) {
        case RBD_OBJ_WRITE_START:
                rbd_assert(!*result);

                if (rbd_obj_write_is_noop(obj_req))
                        return true;

                ret = rbd_obj_write_pre_object_map(obj_req);
                if (ret < 0) {
                        *result = ret;
                        return true;
                }
                obj_req->write_state = RBD_OBJ_WRITE_PRE_OBJECT_MAP;
                if (ret > 0)
                        goto again;
                return false;
        case RBD_OBJ_WRITE_PRE_OBJECT_MAP:
                if (*result) {
                        rbd_warn(rbd_dev, "pre object map update failed: %d",
                                 *result);
                        return true;
                }
                ret = rbd_obj_write_object(obj_req);
                if (ret) {
                        *result = ret;
                        return true;
                }
                obj_req->write_state = RBD_OBJ_WRITE_OBJECT;
                return false;
        case RBD_OBJ_WRITE_OBJECT:
                if (*result == -ENOENT) {
                        if (obj_req->flags & RBD_OBJ_FLAG_COPYUP_ENABLED) {
                                *result = 0;
                                obj_req->copyup_state = RBD_OBJ_COPYUP_START;
                                obj_req->write_state = __RBD_OBJ_WRITE_COPYUP;
                                goto again;
                        }
                        /*
                         * On a non-existent object:
                         *   delete - -ENOENT, truncate/zero - 0
                         */
                        if (obj_req->flags & RBD_OBJ_FLAG_DELETION)
                                *result = 0;
                }
                if (*result)
                        return true;

                obj_req->write_state = RBD_OBJ_WRITE_COPYUP;
                goto again;
        case __RBD_OBJ_WRITE_COPYUP:
                if (!rbd_obj_advance_copyup(obj_req, result))
                        return false;
                /* fall through */
        case RBD_OBJ_WRITE_COPYUP:
                if (*result) {
                        rbd_warn(rbd_dev, "copyup failed: %d", *result);
                        return true;
                }
                ret = rbd_obj_write_post_object_map(obj_req);
                if (ret < 0) {
                        *result = ret;
                        return true;
                }
                obj_req->write_state = RBD_OBJ_WRITE_POST_OBJECT_MAP;
                if (ret > 0)
                        goto again;
                return false;
        case RBD_OBJ_WRITE_POST_OBJECT_MAP:
                if (*result)
                        rbd_warn(rbd_dev, "post object map update failed: %d",
                                 *result);
                return true;
        default:
                BUG();
        }
}

/*
 * Return true if @obj_req is completed.
 */
static bool __rbd_obj_handle_request(struct rbd_obj_request *obj_req,
                                     int *result)
{
        struct rbd_img_request *img_req = obj_req->img_request;
        struct rbd_device *rbd_dev = img_req->rbd_dev;
        bool done;

        mutex_lock(&obj_req->state_mutex);
        if (!rbd_img_is_write(img_req))
                done = rbd_obj_advance_read(obj_req, result);
        else
                done = rbd_obj_advance_write(obj_req, result);
        mutex_unlock(&obj_req->state_mutex);

        if (done && *result) {
                rbd_assert(*result < 0);
                rbd_warn(rbd_dev, "%s at objno %llu %llu~%llu result %d",
                         obj_op_name(img_req->op_type), obj_req->ex.oe_objno,
                         obj_req->ex.oe_off, obj_req->ex.oe_len, *result);
        }
        return done;
}

/*
 * This is open-coded in rbd_img_handle_request() to avoid parent chain
 * recursion.
 */
static void rbd_obj_handle_request(struct rbd_obj_request *obj_req, int result)
{
        if (__rbd_obj_handle_request(obj_req, &result))
                rbd_img_handle_request(obj_req->img_request, result);
}

static bool need_exclusive_lock(struct rbd_img_request *img_req)
{
        struct rbd_device *rbd_dev = img_req->rbd_dev;

        if (!(rbd_dev->header.features & RBD_FEATURE_EXCLUSIVE_LOCK))
                return false;

        if (rbd_dev->spec->snap_id != CEPH_NOSNAP)
                return false;

        rbd_assert(!test_bit(IMG_REQ_CHILD, &img_req->flags));
        if (rbd_dev->opts->lock_on_read ||
            (rbd_dev->header.features & RBD_FEATURE_OBJECT_MAP))
                return true;

        return rbd_img_is_write(img_req);
}

static bool rbd_lock_add_request(struct rbd_img_request *img_req)
{
        struct rbd_device *rbd_dev = img_req->rbd_dev;
        bool locked;

        lockdep_assert_held(&rbd_dev->lock_rwsem);
        locked = rbd_dev->lock_state == RBD_LOCK_STATE_LOCKED;
        spin_lock(&rbd_dev->lock_lists_lock);
        rbd_assert(list_empty(&img_req->lock_item));
        if (!locked)
                list_add_tail(&img_req->lock_item, &rbd_dev->acquiring_list);
        else
                list_add_tail(&img_req->lock_item, &rbd_dev->running_list);
        spin_unlock(&rbd_dev->lock_lists_lock);
        return locked;
}

static void rbd_lock_del_request(struct rbd_img_request *img_req)
{
        struct rbd_device *rbd_dev = img_req->rbd_dev;
        bool need_wakeup;

        lockdep_assert_held(&rbd_dev->lock_rwsem);
        spin_lock(&rbd_dev->lock_lists_lock);
        rbd_assert(!list_empty(&img_req->lock_item));
        list_del_init(&img_req->lock_item);
        need_wakeup = (rbd_dev->lock_state == RBD_LOCK_STATE_RELEASING &&
                       list_empty(&rbd_dev->running_list));
        spin_unlock(&rbd_dev->lock_lists_lock);
        if (need_wakeup)
                complete(&rbd_dev->releasing_wait);
}

static int rbd_img_exclusive_lock(struct rbd_img_request *img_req)
{
        struct rbd_device *rbd_dev = img_req->rbd_dev;

        if (!need_exclusive_lock(img_req))
                return 1;

        if (rbd_lock_add_request(img_req))
                return 1;

        if (rbd_dev->opts->exclusive) {
                WARN_ON(1); /* lock got released? */
                return -EROFS;
        }

        /*
         * Note the use of mod_delayed_work() in rbd_acquire_lock()
         * and cancel_delayed_work() in wake_lock_waiters().
         */
        dout("%s rbd_dev %p queueing lock_dwork\n", __func__, rbd_dev);
        queue_delayed_work(rbd_dev->task_wq, &rbd_dev->lock_dwork, 0);
        return 0;
}

static void rbd_img_object_requests(struct rbd_img_request *img_req)
{
        struct rbd_obj_request *obj_req;

        rbd_assert(!img_req->pending.result && !img_req->pending.num_pending);

        for_each_obj_request(img_req, obj_req) {
                int result = 0;

                if (__rbd_obj_handle_request(obj_req, &result)) {
                        if (result) {
                                img_req->pending.result = result;
                                return;
                        }
                } else {
                        img_req->pending.num_pending++;
                }
        }
}

static bool rbd_img_advance(struct rbd_img_request *img_req, int *result)
{
        struct rbd_device *rbd_dev = img_req->rbd_dev;
        int ret;

again:
        switch (img_req->state) {
        case RBD_IMG_START:
                rbd_assert(!*result);

                ret = rbd_img_exclusive_lock(img_req);
                if (ret < 0) {
                        *result = ret;
                        return true;
                }
                img_req->state = RBD_IMG_EXCLUSIVE_LOCK;
                if (ret > 0)
                        goto again;
                return false;
        case RBD_IMG_EXCLUSIVE_LOCK:
                if (*result)
                        return true;

                rbd_assert(!need_exclusive_lock(img_req) ||
                           __rbd_is_lock_owner(rbd_dev));

                rbd_img_object_requests(img_req);
                if (!img_req->pending.num_pending) {
                        *result = img_req->pending.result;
                        img_req->state = RBD_IMG_OBJECT_REQUESTS;
                        goto again;
                }
                img_req->state = __RBD_IMG_OBJECT_REQUESTS;
                return false;
        case __RBD_IMG_OBJECT_REQUESTS:
                if (!pending_result_dec(&img_req->pending, result))
                        return false;
                /* fall through */
        case RBD_IMG_OBJECT_REQUESTS:
                return true;
        default:
                BUG();
        }
}

/*
 * Return true if @img_req is completed.
 */
static bool __rbd_img_handle_request(struct rbd_img_request *img_req,
                                     int *result)
{
        struct rbd_device *rbd_dev = img_req->rbd_dev;
        bool done;

        if (need_exclusive_lock(img_req)) {
                down_read(&rbd_dev->lock_rwsem);
                mutex_lock(&img_req->state_mutex);
                done = rbd_img_advance(img_req, result);
                if (done)
                        rbd_lock_del_request(img_req);
                mutex_unlock(&img_req->state_mutex);
                up_read(&rbd_dev->lock_rwsem);
        } else {
                mutex_lock(&img_req->state_mutex);
                done = rbd_img_advance(img_req, result);
                mutex_unlock(&img_req->state_mutex);
        }

        if (done && *result) {
                rbd_assert(*result < 0);
                rbd_warn(rbd_dev, "%s%s result %d",
                      test_bit(IMG_REQ_CHILD, &img_req->flags) ? "child " : "",
                      obj_op_name(img_req->op_type), *result);
        }
        return done;
}

static void rbd_img_handle_request(struct rbd_img_request *img_req, int result)
{
again:
        if (!__rbd_img_handle_request(img_req, &result))
                return;

        if (test_bit(IMG_REQ_CHILD, &img_req->flags)) {
                struct rbd_obj_request *obj_req = img_req->obj_request;

                rbd_img_request_put(img_req);
                if (__rbd_obj_handle_request(obj_req, &result)) {
                        img_req = obj_req->img_request;
                        goto again;
                }
        } else {
                struct request *rq = img_req->rq;

                rbd_img_request_put(img_req);
                blk_mq_end_request(rq, errno_to_blk_status(result));
        }
}

static const struct rbd_client_id rbd_empty_cid;

static bool rbd_cid_equal(const struct rbd_client_id *lhs,
                          const struct rbd_client_id *rhs)
{
        return lhs->gid == rhs->gid && lhs->handle == rhs->handle;
}

static struct rbd_client_id rbd_get_cid(struct rbd_device *rbd_dev)
{
        struct rbd_client_id cid;

        mutex_lock(&rbd_dev->watch_mutex);
        cid.gid = ceph_client_gid(rbd_dev->rbd_client->client);
        cid.handle = rbd_dev->watch_cookie;
        mutex_unlock(&rbd_dev->watch_mutex);
        return cid;
}

/*
 * lock_rwsem must be held for write
 */
static void rbd_set_owner_cid(struct rbd_device *rbd_dev,
                              const struct rbd_client_id *cid)
{
        dout("%s rbd_dev %p %llu-%llu -> %llu-%llu\n", __func__, rbd_dev,
             rbd_dev->owner_cid.gid, rbd_dev->owner_cid.handle,
             cid->gid, cid->handle);
        rbd_dev->owner_cid = *cid; /* struct */
}

static void format_lock_cookie(struct rbd_device *rbd_dev, char *buf)
{
        mutex_lock(&rbd_dev->watch_mutex);
        sprintf(buf, "%s %llu", RBD_LOCK_COOKIE_PREFIX, rbd_dev->watch_cookie);
        mutex_unlock(&rbd_dev->watch_mutex);
}

static void __rbd_lock(struct rbd_device *rbd_dev, const char *cookie)
{
        struct rbd_client_id cid = rbd_get_cid(rbd_dev);

        rbd_dev->lock_state = RBD_LOCK_STATE_LOCKED;
        strcpy(rbd_dev->lock_cookie, cookie);
        rbd_set_owner_cid(rbd_dev, &cid);
        queue_work(rbd_dev->task_wq, &rbd_dev->acquired_lock_work);
}

/*
 * lock_rwsem must be held for write
 */
static int rbd_lock(struct rbd_device *rbd_dev)
{
        struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
        char cookie[32];
        int ret;

        WARN_ON(__rbd_is_lock_owner(rbd_dev) ||
                rbd_dev->lock_cookie[0] != '\0');

        format_lock_cookie(rbd_dev, cookie);
        ret = ceph_cls_lock(osdc, &rbd_dev->header_oid, &rbd_dev->header_oloc,
                            RBD_LOCK_NAME, CEPH_CLS_LOCK_EXCLUSIVE, cookie,
                            RBD_LOCK_TAG, "", 0);
        if (ret)
                return ret;

        __rbd_lock(rbd_dev, cookie);
        return 0;
}

/*
 * lock_rwsem must be held for write
 */
static void rbd_unlock(struct rbd_device *rbd_dev)
{
        struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
        int ret;

        WARN_ON(!__rbd_is_lock_owner(rbd_dev) ||
                rbd_dev->lock_cookie[0] == '\0');

        ret = ceph_cls_unlock(osdc, &rbd_dev->header_oid, &rbd_dev->header_oloc,
                              RBD_LOCK_NAME, rbd_dev->lock_cookie);
        if (ret && ret != -ENOENT)
                rbd_warn(rbd_dev, "failed to unlock header: %d", ret);

        /* treat errors as the image is unlocked */
        rbd_dev->lock_state = RBD_LOCK_STATE_UNLOCKED;
        rbd_dev->lock_cookie[0] = '\0';
        rbd_set_owner_cid(rbd_dev, &rbd_empty_cid);
        queue_work(rbd_dev->task_wq, &rbd_dev->released_lock_work);
}

static int __rbd_notify_op_lock(struct rbd_device *rbd_dev,
                                enum rbd_notify_op notify_op,
                                struct page ***preply_pages,
                                size_t *preply_len)
{
        struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
        struct rbd_client_id cid = rbd_get_cid(rbd_dev);
        char buf[4 + 8 + 8 + CEPH_ENCODING_START_BLK_LEN];
        int buf_size = sizeof(buf);
        void *p = buf;

        dout("%s rbd_dev %p notify_op %d\n", __func__, rbd_dev, notify_op);

        /* encode *LockPayload NotifyMessage (op + ClientId) */
        ceph_start_encoding(&p, 2, 1, buf_size - CEPH_ENCODING_START_BLK_LEN);
        ceph_encode_32(&p, notify_op);
        ceph_encode_64(&p, cid.gid);
        ceph_encode_64(&p, cid.handle);

        return ceph_osdc_notify(osdc, &rbd_dev->header_oid,
                                &rbd_dev->header_oloc, buf, buf_size,
                                RBD_NOTIFY_TIMEOUT, preply_pages, preply_len);
}

static void rbd_notify_op_lock(struct rbd_device *rbd_dev,
                               enum rbd_notify_op notify_op)
{
        struct page **reply_pages;
        size_t reply_len;

        __rbd_notify_op_lock(rbd_dev, notify_op, &reply_pages, &reply_len);
        ceph_release_page_vector(reply_pages, calc_pages_for(0, reply_len));
}

static void rbd_notify_acquired_lock(struct work_struct *work)
{
        struct rbd_device *rbd_dev = container_of(work, struct rbd_device,
                                                  acquired_lock_work);

        rbd_notify_op_lock(rbd_dev, RBD_NOTIFY_OP_ACQUIRED_LOCK);
}

static void rbd_notify_released_lock(struct work_struct *work)
{
        struct rbd_device *rbd_dev = container_of(work, struct rbd_device,
                                                  released_lock_work);

        rbd_notify_op_lock(rbd_dev, RBD_NOTIFY_OP_RELEASED_LOCK);
}

static int rbd_request_lock(struct rbd_device *rbd_dev)
{
        struct page **reply_pages;
        size_t reply_len;
        bool lock_owner_responded = false;
        int ret;

        dout("%s rbd_dev %p\n", __func__, rbd_dev);

        ret = __rbd_notify_op_lock(rbd_dev, RBD_NOTIFY_OP_REQUEST_LOCK,
                                   &reply_pages, &reply_len);
        if (ret && ret != -ETIMEDOUT) {
                rbd_warn(rbd_dev, "failed to request lock: %d", ret);
                goto out;
        }

        if (reply_len > 0 && reply_len <= PAGE_SIZE) {
                void *p = page_address(reply_pages[0]);
                void *const end = p + reply_len;
                u32 n;

                ceph_decode_32_safe(&p, end, n, e_inval); /* num_acks */
                while (n--) {
                        u8 struct_v;
                        u32 len;

                        ceph_decode_need(&p, end, 8 + 8, e_inval);
                        p += 8 + 8; /* skip gid and cookie */

                        ceph_decode_32_safe(&p, end, len, e_inval);
                        if (!len)
                                continue;

                        if (lock_owner_responded) {
                                rbd_warn(rbd_dev,
                                         "duplicate lock owners detected");
                                ret = -EIO;
                                goto out;
                        }

                        lock_owner_responded = true;
                        ret = ceph_start_decoding(&p, end, 1, "ResponseMessage",
                                                  &struct_v, &len);
                        if (ret) {
                                rbd_warn(rbd_dev,
                                         "failed to decode ResponseMessage: %d",
                                         ret);
                                goto e_inval;
                        }

                        ret = ceph_decode_32(&p);
                }
        }

        if (!lock_owner_responded) {
                rbd_warn(rbd_dev, "no lock owners detected");
                ret = -ETIMEDOUT;
        }

out:
        ceph_release_page_vector(reply_pages, calc_pages_for(0, reply_len));
        return ret;

e_inval:
        ret = -EINVAL;
        goto out;
}

/*
 * Either image request state machine(s) or rbd_add_acquire_lock()
 * (i.e. "rbd map").
 */
static void wake_lock_waiters(struct rbd_device *rbd_dev, int result)
{
        struct rbd_img_request *img_req;

        dout("%s rbd_dev %p result %d\n", __func__, rbd_dev, result);
        lockdep_assert_held_write(&rbd_dev->lock_rwsem);

        cancel_delayed_work(&rbd_dev->lock_dwork);
        if (!completion_done(&rbd_dev->acquire_wait)) {
                rbd_assert(list_empty(&rbd_dev->acquiring_list) &&
                           list_empty(&rbd_dev->running_list));
                rbd_dev->acquire_err = result;
                complete_all(&rbd_dev->acquire_wait);
                return;
        }

        list_for_each_entry(img_req, &rbd_dev->acquiring_list, lock_item) {
                mutex_lock(&img_req->state_mutex);
                rbd_assert(img_req->state == RBD_IMG_EXCLUSIVE_LOCK);
                rbd_img_schedule(img_req, result);
                mutex_unlock(&img_req->state_mutex);
        }

        list_splice_tail_init(&rbd_dev->acquiring_list, &rbd_dev->running_list);
}

static int get_lock_owner_info(struct rbd_device *rbd_dev,
                               struct ceph_locker **lockers, u32 *num_lockers)
{
        struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
        u8 lock_type;
        char *lock_tag;
        int ret;

        dout("%s rbd_dev %p\n", __func__, rbd_dev);

        ret = ceph_cls_lock_info(osdc, &rbd_dev->header_oid,
                                 &rbd_dev->header_oloc, RBD_LOCK_NAME,
                                 &lock_type, &lock_tag, lockers, num_lockers);
        if (ret)