/*
     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/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 */

  /*
   * The basic unit of block I/O is a sector.  It is interpreted in a
   * number of contexts in Linux (blk, bio, genhd), but the default is
   * universally 512 bytes.  These symbols are just slightly more
   * meaningful than the bare numbers they represent.
   */
  #define	SECTOR_SHIFT	9
  #define	SECTOR_SIZE	(1ULL << SECTOR_SHIFT)

  /*
   * 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_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

  /* Feature bits */

  #define RBD_FEATURE_LAYERING	(1<<0)
  #define RBD_FEATURE_STRIPINGV2	(1<<1)
  #define RBD_FEATURES_ALL \
  	    (RBD_FEATURE_LAYERING | RBD_FEATURE_STRIPINGV2)

  
  /* 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.
   * MAX_INT_FORMAT_WIDTH is used in ensuring DEV_NAME_LEN is big
   * enough to hold all possible device names.
   */

  #define DEV_NAME_LEN		32

  #define MAX_INT_FORMAT_WIDTH	((5 * sizeof (int)) / 2 + 1)

  
  /*
   * 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;
  	__u8 crypt_type;
  	__u8 comp_type;

  	u64 stripe_unit;
  	u64 stripe_count;
  	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	*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 rbd_img_request;
  typedef void (*rbd_img_callback_t)(struct rbd_img_request *);
  
  #define	BAD_WHICH	U32_MAX		/* Good which or bad which, which? */
  
  struct rbd_obj_request;
  typedef void (*rbd_obj_callback_t)(struct rbd_obj_request *);

  enum obj_request_type {
  	OBJ_REQUEST_NODATA, OBJ_REQUEST_BIO, OBJ_REQUEST_PAGES
  };

  enum obj_operation_type {
  	OBJ_OP_WRITE,
  	OBJ_OP_READ,

  	OBJ_OP_DISCARD,

  };

  enum obj_req_flags {
  	OBJ_REQ_DONE,		/* completion flag: not done = 0, done = 1 */

  	OBJ_REQ_IMG_DATA,	/* object usage: standalone = 0, image = 1 */

  	OBJ_REQ_KNOWN,		/* EXISTS flag valid: no = 0, yes = 1 */
  	OBJ_REQ_EXISTS,		/* target exists: no = 0, yes = 1 */

  };

  struct rbd_obj_request {
  	const char		*object_name;
  	u64			offset;		/* object start byte */
  	u64			length;		/* bytes from offset */

  	unsigned long		flags;

  	/*
  	 * An object request associated with an image will have its
  	 * img_data flag set; a standalone object request will not.
  	 *
  	 * A standalone object request will have which == BAD_WHICH
  	 * and a null obj_request pointer.
  	 *
  	 * An object request initiated in support of a layered image
  	 * object (to check for its existence before a write) will
  	 * have which == BAD_WHICH and a non-null obj_request pointer.
  	 *
  	 * Finally, an object request for rbd image data will have
  	 * which != BAD_WHICH, and will have a non-null img_request
  	 * pointer.  The value of which will be in the range
  	 * 0..(img_request->obj_request_count-1).
  	 */
  	union {
  		struct rbd_obj_request	*obj_request;	/* STAT op */
  		struct {
  			struct rbd_img_request	*img_request;
  			u64			img_offset;
  			/* links for img_request->obj_requests list */
  			struct list_head	links;
  		};
  	};

  	u32			which;		/* posn image request list */
  
  	enum obj_request_type	type;

  	union {
  		struct bio	*bio_list;
  		struct {
  			struct page	**pages;
  			u32		page_count;
  		};
  	};

  	struct page		**copyup_pages;

  	u32			copyup_page_count;

  
  	struct ceph_osd_request	*osd_req;
  
  	u64			xferred;	/* bytes transferred */

  	int			result;

  
  	rbd_obj_callback_t	callback;

  	struct completion	completion;

  
  	struct kref		kref;
  };

  enum img_req_flags {

  	IMG_REQ_WRITE,		/* I/O direction: read = 0, write = 1 */
  	IMG_REQ_CHILD,		/* initiator: block = 0, child image = 1 */

  	IMG_REQ_LAYERED,	/* ENOENT handling: normal = 0, layered = 1 */

  	IMG_REQ_DISCARD,	/* discard: normal = 0, discard request = 1 */

  };

  struct rbd_img_request {

  	struct rbd_device	*rbd_dev;
  	u64			offset;	/* starting image byte offset */
  	u64			length;	/* byte count from offset */

  	unsigned long		flags;

  	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 page		**copyup_pages;

  	u32			copyup_page_count;

  	spinlock_t		completion_lock;/* protects next_completion */
  	u32			next_completion;
  	rbd_img_callback_t	callback;

  	u64			xferred;/* aggregate bytes transferred */

  	int			result;	/* first nonzero obj_request result */

  
  	u32			obj_request_count;
  	struct list_head	obj_requests;	/* rbd_obj_request structs */
  
  	struct kref		kref;
  };
  
  #define for_each_obj_request(ireq, oreq) \

  	list_for_each_entry(oreq, &(ireq)->obj_requests, links)

  #define for_each_obj_request_from(ireq, oreq) \

  	list_for_each_entry_from(oreq, &(ireq)->obj_requests, links)

  #define for_each_obj_request_safe(ireq, oreq, n) \

  	list_for_each_entry_safe_reverse(oreq, n, &(ireq)->obj_requests, links)

  struct rbd_mapping {

  	u64                     size;

  	u64                     features;

  	bool			read_only;
  };

  /*
   * 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;

  	struct ceph_object_id	header_oid;

  	struct ceph_object_locator header_oloc;

  	struct ceph_file_layout	layout;

  	struct ceph_osd_linger_request *watch_handle;

  	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.  If atomicity is required,
   * rbd_dev->lock is used to protect access.
   *
   * Currently, only the "removing" flag (which is coupled with the
   * "open_count" field) requires atomic access.
   */

  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 struct kmem_cache	*rbd_segment_name_cache;

  static int rbd_major;

  static DEFINE_IDA(rbd_dev_id_ida);

  static struct workqueue_struct *rbd_wq;

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

  static int rbd_img_request_submit(struct rbd_img_request *img_request);

  static ssize_t rbd_add(struct bus_type *bus, const char *buf,
  		       size_t count);
  static ssize_t rbd_remove(struct bus_type *bus, const char *buf,
  			  size_t count);

  static ssize_t rbd_add_single_major(struct bus_type *bus, const char *buf,
  				    size_t count);
  static ssize_t rbd_remove_single_major(struct bus_type *bus, const char *buf,
  				       size_t count);

  static int rbd_dev_image_probe(struct rbd_device *rbd_dev, int depth);

  static void rbd_spec_put(struct rbd_spec *spec);

  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 BUS_ATTR(add, S_IWUSR, NULL, rbd_add);
  static BUS_ATTR(remove, S_IWUSR, NULL, rbd_remove);

  static BUS_ATTR(add_single_major, S_IWUSR, NULL, rbd_add_single_major);
  static BUS_ATTR(remove_single_major, S_IWUSR, NULL, rbd_remove_single_major);

  
  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,

  	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
  ", RBD_DRV_NAME, &vaf);
  	else if (rbd_dev->disk)
  		printk(KERN_WARNING "%s: %s: %pV
  ",
  			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
  ",
  			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
  ",
  			RBD_DRV_NAME, rbd_dev->spec->image_id, &vaf);
  	else	/* punt */
  		printk(KERN_WARNING "%s: rbd_dev %p: %pV
  ",
  			RBD_DRV_NAME, rbd_dev, &vaf);
  	va_end(args);
  }

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

  static void rbd_osd_copyup_callback(struct rbd_obj_request *obj_request);

  static int rbd_img_obj_request_submit(struct rbd_obj_request *obj_request);

  static void rbd_img_parent_read(struct rbd_obj_request *obj_request);
  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_open(struct block_device *bdev, fmode_t mode)
  {

  	struct rbd_device *rbd_dev = bdev->bd_disk->private_data;

  	bool removing = false;

  	if ((mode & FMODE_WRITE) && rbd_dev->mapping.read_only)

  		return -EROFS;

  	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 ret = 0;

  	int val;
  	bool ro;

  	bool ro_changed = false;

  	/* get_user() may sleep, so call it before taking rbd_dev->lock */

  	if (get_user(val, (int __user *)(arg)))
  		return -EFAULT;
  
  	ro = val ? true : false;
  	/* Snapshot doesn't allow to write*/
  	if (rbd_dev->spec->snap_id != CEPH_NOSNAP && !ro)
  		return -EROFS;

  	spin_lock_irq(&rbd_dev->lock);
  	/* prevent others open this device */
  	if (rbd_dev->open_count > 1) {
  		ret = -EBUSY;
  		goto out;
  	}

  	if (rbd_dev->mapping.read_only != ro) {
  		rbd_dev->mapping.read_only = ro;

  		ro_changed = true;

  	}

  out:
  	spin_unlock_irq(&rbd_dev->lock);
  	/* set_disk_ro() may sleep, so call it after releasing rbd_dev->lock */
  	if (ret == 0 && ro_changed)
  		set_disk_ro(rbd_dev->disk, ro ? 1 : 0);
  
  	return ret;

  }
  
  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 = 0;

  	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:
  ", __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, 0, 0);

  	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
  ", __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
  ", __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_last_int,
  	/* int args above */
  	Opt_last_string,
  	/* string args above */

  	Opt_read_only,
  	Opt_read_write,

  	Opt_err

  };

  static match_table_t rbd_opts_tokens = {

  	{Opt_queue_depth, "queue_depth=%d"},

  	/* int args above */
  	/* 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_err, NULL}

  };

  struct rbd_options {

  	int	queue_depth;

  	bool	read_only;
  };

  #define RBD_QUEUE_DEPTH_DEFAULT	BLKDEV_MAX_RQ

  #define RBD_READ_ONLY_DEFAULT	false

  static int parse_rbd_opts_token(char *c, void *private)
  {

  	struct rbd_options *rbd_opts = 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 mount option arg (not int) at '%s'
  ", c);

  			return ret;
  		}
  		dout("got int token %d val %d
  ", token, intval);
  	} else if (token > Opt_last_int && token < Opt_last_string) {

  		dout("got string token %d val %s
  ", token, argstr[0].from);

  	} else {
  		dout("got token %d
  ", token);
  	}
  
  	switch (token) {

  	case Opt_queue_depth:
  		if (intval < 1) {
  			pr_err("queue_depth out of range
  ");
  			return -EINVAL;
  		}
  		rbd_opts->queue_depth = intval;
  		break;

  	case Opt_read_only:
  		rbd_opts->read_only = true;
  		break;
  	case Opt_read_write:
  		rbd_opts->read_only = 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";

  	default:
  		return "???";
  	}
  }

  /*

   * 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;

  	mutex_lock_nested(&client_mutex, SINGLE_DEPTH_NESTING);

  	rbdc = rbd_client_find(ceph_opts);

  	if (rbdc)	/* using an existing client */

  		ceph_destroy_options(ceph_opts);

  	else

  		rbdc = rbd_client_create(ceph_opts);

  	mutex_unlock(&client_mutex);

  	return rbdc;

  }
  
  /*
   * 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
  ", __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);

  }

  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;

  }

  /*

   * 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;

  	size_t size;

  	int ret = -ENOMEM;

  	u32 i;

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

  	if (first_time) {
  		size_t len;

  		len = strnlen(ondisk->object_prefix,
  				sizeof (ondisk->object_prefix));
  		object_prefix = kmalloc(len + 1, GFP_KERNEL);
  		if (!object_prefix)
  			return -ENOMEM;
  		memcpy(object_prefix, ondisk->object_prefix, len);
  		object_prefix[len] = '\0';
  	}

  	/* 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. */

  		size = snap_count * sizeof (*header->snap_sizes);

  		snap_sizes = kmalloc(size, 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;
  		header->crypt_type = ondisk->options.crypt_type;
  		header->comp_type = ondisk->options.comp_type;
  		/* The rest aren't used for format 1 images */
  		header->stripe_unit = 0;
  		header->stripe_count = 0;
  		header->features = 0;

  	} 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 rbd_segment_name_free(const char *name)
  {
  	/* The explicit cast here is needed to drop the const qualifier */
  
  	kmem_cache_free(rbd_segment_name_cache, (void *)name);
  }

  static const char *rbd_segment_name(struct rbd_device *rbd_dev, u64 offset)

  {

  	char *name;
  	u64 segment;
  	int ret;

  	char *name_format;

  	name = kmem_cache_alloc(rbd_segment_name_cache, GFP_NOIO);

  	if (!name)
  		return NULL;
  	segment = offset >> rbd_dev->header.obj_order;

  	name_format = "%s.%012llx";
  	if (rbd_dev->image_format == 2)
  		name_format = "%s.%016llx";

  	ret = snprintf(name, CEPH_MAX_OID_NAME_LEN + 1, name_format,

  			rbd_dev->header.object_prefix, segment);

  	if (ret < 0 || ret > CEPH_MAX_OID_NAME_LEN) {

  		pr_err("error formatting segment name for #%llu (%d)
  ",
  			segment, ret);

  		rbd_segment_name_free(name);

  		name = NULL;
  	}

  	return name;
  }

  static u64 rbd_segment_offset(struct rbd_device *rbd_dev, u64 offset)
  {
  	u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;

  	return offset & (segment_size - 1);
  }
  
  static u64 rbd_segment_length(struct rbd_device *rbd_dev,
  				u64 offset, u64 length)
  {
  	u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
  
  	offset &= segment_size - 1;

  	rbd_assert(length <= U64_MAX - offset);

  	if (offset + length > segment_size)
  		length = segment_size - offset;
  
  	return length;

  }
  
  /*

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

   * bio helpers
   */
  
  static void bio_chain_put(struct bio *chain)
  {
  	struct bio *tmp;
  
  	while (chain) {
  		tmp = chain;
  		chain = chain->bi_next;
  		bio_put(tmp);
  	}
  }
  
  /*
   * zeros a bio chain, starting at specific offset
   */
  static void zero_bio_chain(struct bio *chain, int start_ofs)
  {

  	struct bio_vec bv;
  	struct bvec_iter iter;

  	unsigned long flags;
  	void *buf;

  	int pos = 0;
  
  	while (chain) {

  		bio_for_each_segment(bv, chain, iter) {
  			if (pos + bv.bv_len > start_ofs) {

  				int remainder = max(start_ofs - pos, 0);

  				buf = bvec_kmap_irq(&bv, &flags);

  				memset(buf + remainder, 0,

  				       bv.bv_len - remainder);
  				flush_dcache_page(bv.bv_page);

  				bvec_kunmap_irq(buf, &flags);

  			}

  			pos += bv.bv_len;

  		}
  
  		chain = chain->bi_next;
  	}
  }
  
  /*

   * similar to zero_bio_chain(), zeros data defined by a page array,
   * starting at the given byte offset from the start of the array and
   * continuing up to the given end offset.  The pages array is
   * assumed to be big enough to hold all bytes up to the end.
   */
  static void zero_pages(struct page **pages, u64 offset, u64 end)
  {
  	struct page **page = &pages[offset >> PAGE_SHIFT];
  
  	rbd_assert(end > offset);
  	rbd_assert(end - offset <= (u64)SIZE_MAX);
  	while (offset < end) {
  		size_t page_offset;
  		size_t length;
  		unsigned long flags;
  		void *kaddr;

  		page_offset = offset & ~PAGE_MASK;
  		length = min_t(size_t, PAGE_SIZE - page_offset, end - offset);

  		local_irq_save(flags);
  		kaddr = kmap_atomic(*page);
  		memset(kaddr + page_offset, 0, length);

  		flush_dcache_page(*page);

  		kunmap_atomic(kaddr);
  		local_irq_restore(flags);
  
  		offset += length;
  		page++;
  	}
  }
  
  /*

   * Clone a portion of a bio, starting at the given byte offset
   * and continuing for the number of bytes indicated.

   */

  static struct bio *bio_clone_range(struct bio *bio_src,
  					unsigned int offset,
  					unsigned int len,
  					gfp_t gfpmask)

  {

  	struct bio *bio;

  	bio = bio_clone(bio_src, gfpmask);

  	if (!bio)
  		return NULL;	/* ENOMEM */

  	bio_advance(bio, offset);

  	bio->bi_iter.bi_size = len;

  
  	return bio;
  }
  
  /*
   * Clone a portion of a bio chain, starting at the given byte offset
   * into the first bio in the source chain and continuing for the
   * number of bytes indicated.  The result is another bio chain of
   * exactly the given length, or a null pointer on error.
   *
   * The bio_src and offset parameters are both in-out.  On entry they
   * refer to the first source bio and the offset into that bio where
   * the start of data to be cloned is located.
   *
   * On return, bio_src is updated to refer to the bio in the source
   * chain that contains first un-cloned byte, and *offset will
   * contain the offset of that byte within that bio.
   */
  static struct bio *bio_chain_clone_range(struct bio **bio_src,
  					unsigned int *offset,
  					unsigned int len,
  					gfp_t gfpmask)
  {
  	struct bio *bi = *bio_src;
  	unsigned int off = *offset;
  	struct bio *chain = NULL;
  	struct bio **end;
  
  	/* Build up a chain of clone bios up to the limit */

  	if (!bi || off >= bi->bi_iter.bi_size || !len)

  		return NULL;		/* Nothing to clone */

  	end = &chain;
  	while (len) {
  		unsigned int bi_size;
  		struct bio *bio;

  		if (!bi) {
  			rbd_warn(NULL, "bio_chain exhausted with %u left", len);

  			goto out_err;	/* EINVAL; ran out of bio's */

  		}

  		bi_size = min_t(unsigned int, bi->bi_iter.bi_size - off, len);

  		bio = bio_clone_range(bi, off, bi_size, gfpmask);
  		if (!bio)
  			goto out_err;	/* ENOMEM */
  
  		*end = bio;
  		end = &bio->bi_next;

  		off += bi_size;

  		if (off == bi->bi_iter.bi_size) {

  			bi = bi->bi_next;
  			off = 0;
  		}
  		len -= bi_size;
  	}
  	*bio_src = bi;
  	*offset = off;
  
  	return chain;
  out_err:
  	bio_chain_put(chain);

  	return NULL;
  }

  /*
   * The default/initial value for all object request flags is 0.  For
   * each flag, once its value is set to 1 it is never reset to 0
   * again.
   */

  static void obj_request_img_data_set(struct rbd_obj_request *obj_request)

  {

  	if (test_and_set_bit(OBJ_REQ_IMG_DATA, &obj_request->flags)) {

  		struct rbd_device *rbd_dev;

  		rbd_dev = obj_request->img_request->rbd_dev;

  		rbd_warn(rbd_dev, "obj_request %p already marked img_data",

  			obj_request);
  	}
  }

  static bool obj_request_img_data_test(struct rbd_obj_request *obj_request)

  {
  	smp_mb();

  	return test_bit(OBJ_REQ_IMG_DATA, &obj_request->flags) != 0;

  }

  static void obj_request_done_set(struct rbd_obj_request *obj_request)

  {

  	if (test_and_set_bit(OBJ_REQ_DONE, &obj_request->flags)) {
  		struct rbd_device *rbd_dev = NULL;

  		if (obj_request_img_data_test(obj_request))
  			rbd_dev = obj_request->img_request->rbd_dev;

  		rbd_warn(rbd_dev, "obj_request %p already marked done",

  			obj_request);
  	}
  }

  static bool obj_request_done_test(struct rbd_obj_request *obj_request)

  {
  	smp_mb();

  	return test_bit(OBJ_REQ_DONE, &obj_request->flags) != 0;

  }

  /*
   * This sets the KNOWN flag after (possibly) setting the EXISTS
   * flag.  The latter is set based on the "exists" value provided.
   *
   * Note that for our purposes once an object exists it never goes
   * away again.  It's possible that the response from two existence
   * checks are separated by the creation of the target object, and
   * the first ("doesn't exist") response arrives *after* the second
   * ("does exist").  In that case we ignore the second one.
   */
  static void obj_request_existence_set(struct rbd_obj_request *obj_request,
  				bool exists)
  {
  	if (exists)
  		set_bit(OBJ_REQ_EXISTS, &obj_request->flags);
  	set_bit(OBJ_REQ_KNOWN, &obj_request->flags);
  	smp_mb();
  }
  
  static bool obj_request_known_test(struct rbd_obj_request *obj_request)
  {
  	smp_mb();
  	return test_bit(OBJ_REQ_KNOWN, &obj_request->flags) != 0;
  }
  
  static bool obj_request_exists_test(struct rbd_obj_request *obj_request)
  {
  	smp_mb();
  	return test_bit(OBJ_REQ_EXISTS, &obj_request->flags) != 0;
  }

  static bool obj_request_overlaps_parent(struct rbd_obj_request *obj_request)
  {
  	struct rbd_device *rbd_dev = obj_request->img_request->rbd_dev;
  
  	return obj_request->img_offset <
  	    round_up(rbd_dev->parent_overlap, rbd_obj_bytes(&rbd_dev->header));
  }

  static void rbd_obj_request_get(struct rbd_obj_request *obj_request)
  {

  	dout("%s: obj %p (was %d)
  ", __func__, obj_request,
  		atomic_read(&obj_request->kref.refcount));

  	kref_get(&obj_request->kref);
  }
  
  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)
  ", __func__, obj_request,
  		atomic_read(&obj_request->kref.refcount));

  	kref_put(&obj_request->kref, rbd_obj_request_destroy);
  }

  static void rbd_img_request_get(struct rbd_img_request *img_request)
  {
  	dout("%s: img %p (was %d)
  ", __func__, img_request,
  	     atomic_read(&img_request->kref.refcount));
  	kref_get(&img_request->kref);
  }

  static bool img_request_child_test(struct rbd_img_request *img_request);
  static void rbd_parent_request_destroy(struct kref *kref);

  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)
  ", __func__, img_request,
  		atomic_read(&img_request->kref.refcount));

  	if (img_request_child_test(img_request))
  		kref_put(&img_request->kref, rbd_parent_request_destroy);
  	else
  		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;

  	obj_request->which = img_request->obj_request_count;

  	rbd_assert(!obj_request_img_data_test(obj_request));
  	obj_request_img_data_set(obj_request);

  	rbd_assert(obj_request->which != BAD_WHICH);

  	img_request->obj_request_count++;
  	list_add_tail(&obj_request->links, &img_request->obj_requests);

  	dout("%s: img %p obj %p w=%u
  ", __func__, img_request, obj_request,
  		obj_request->which);

  }
  
  static inline void rbd_img_obj_request_del(struct rbd_img_request *img_request,
  					struct rbd_obj_request *obj_request)
  {
  	rbd_assert(obj_request->which != BAD_WHICH);

  	dout("%s: img %p obj %p w=%u
  ", __func__, img_request, obj_request,
  		obj_request->which);

  	list_del(&obj_request->links);

  	rbd_assert(img_request->obj_request_count > 0);
  	img_request->obj_request_count--;
  	rbd_assert(obj_request->which == img_request->obj_request_count);
  	obj_request->which = BAD_WHICH;

  	rbd_assert(obj_request_img_data_test(obj_request));

  	rbd_assert(obj_request->img_request == img_request);

  	obj_request->img_request = NULL;

  	obj_request->callback = NULL;

  	rbd_obj_request_put(obj_request);
  }
  
  static bool obj_request_type_valid(enum obj_request_type type)
  {
  	switch (type) {

  	case OBJ_REQUEST_NODATA:

  	case OBJ_REQUEST_BIO:

  	case OBJ_REQUEST_PAGES:

  		return true;
  	default:
  		return false;
  	}
  }

  static int rbd_obj_request_submit(struct ceph_osd_client *osdc,
  				struct rbd_obj_request *obj_request)
  {

  	dout("%s %p
  ", __func__, obj_request);

  	return ceph_osdc_start_request(osdc, obj_request->osd_req, false);
  }

  static void rbd_obj_request_end(struct rbd_obj_request *obj_request)
  {
  	dout("%s %p
  ", __func__, obj_request);
  	ceph_osdc_cancel_request(obj_request->osd_req);
  }
  
  /*
   * Wait for an object request to complete.  If interrupted, cancel the
   * underlying osd request.

   *
   * @timeout: in jiffies, 0 means "wait forever"

   */

  static int __rbd_obj_request_wait(struct rbd_obj_request *obj_request,
  				  unsigned long timeout)

  {

  	long ret;

  
  	dout("%s %p
  ", __func__, obj_request);

  	ret = wait_for_completion_interruptible_timeout(
  					&obj_request->completion,
  					ceph_timeout_jiffies(timeout));
  	if (ret <= 0) {
  		if (ret == 0)
  			ret = -ETIMEDOUT;

  		rbd_obj_request_end(obj_request);

  	} else {
  		ret = 0;

  	}

  	dout("%s %p ret %d
  ", __func__, obj_request, (int)ret);
  	return ret;
  }
  
  static int rbd_obj_request_wait(struct rbd_obj_request *obj_request)
  {
  	return __rbd_obj_request_wait(obj_request, 0);
  }

  static void rbd_img_request_complete(struct rbd_img_request *img_request)
  {

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

  
  	/*
  	 * If no error occurred, compute the aggregate transfer
  	 * count for the image request.  We could instead use
  	 * atomic64_cmpxchg() to update it as each object request
  	 * completes; not clear which way is better off hand.
  	 */
  	if (!img_request->result) {
  		struct rbd_obj_request *obj_request;
  		u64 xferred = 0;
  
  		for_each_obj_request(img_request, obj_request)
  			xferred += obj_request->xferred;
  		img_request->xferred = xferred;
  	}

  	if (img_request->callback)
  		img_request->callback(img_request);
  	else
  		rbd_img_request_put(img_request);
  }

  /*
   * 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_write_set(struct rbd_img_request *img_request)
  {
  	set_bit(IMG_REQ_WRITE, &img_request->flags);
  	smp_mb();
  }
  
  static bool img_request_write_test(struct rbd_img_request *img_request)
  {
  	smp_mb();
  	return test_bit(IMG_REQ_WRITE, &img_request->flags) != 0;
  }

  /*
   * Set the discard flag when the img_request is an discard request
   */
  static void img_request_discard_set(struct rbd_img_request *img_request)
  {
  	set_bit(IMG_REQ_DISCARD, &img_request->flags);
  	smp_mb();
  }
  
  static bool img_request_discard_test(struct rbd_img_request *img_request)
  {
  	smp_mb();
  	return test_bit(IMG_REQ_DISCARD, &img_request->flags) != 0;
  }

  static void img_request_child_set(struct rbd_img_request *img_request)
  {
  	set_bit(IMG_REQ_CHILD, &img_request->flags);
  	smp_mb();
  }

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

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

  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 enum obj_operation_type
  rbd_img_request_op_type(struct rbd_img_request *img_request)
  {
  	if (img_request_write_test(img_request))
  		return OBJ_OP_WRITE;
  	else if (img_request_discard_test(img_request))
  		return OBJ_OP_DISCARD;
  	else
  		return OBJ_OP_READ;
  }

  static void
  rbd_img_obj_request_read_callback(struct rbd_obj_request *obj_request)
  {

  	u64 xferred = obj_request->xferred;
  	u64 length = obj_request->length;

  	dout("%s: obj %p img %p result %d %llu/%llu
  ", __func__,
  		obj_request, obj_request->img_request, obj_request->result,

  		xferred, length);

  	/*

  	 * ENOENT means a hole in the image.  We zero-fill the entire
  	 * length of the request.  A short read also implies zero-fill
  	 * to the end of the request.  An error requires the whole
  	 * length of the request to be reported finished with an error
  	 * to the block layer.  In each case we update the xferred
  	 * count to indicate the whole request was satisfied.

  	 */

  	rbd_assert(obj_request->type != OBJ_REQUEST_NODATA);

  	if (obj_request->result == -ENOENT) {

  		if (obj_request->type == OBJ_REQUEST_BIO)
  			zero_bio_chain(obj_request->bio_list, 0);
  		else
  			zero_pages(obj_request->pages, 0, length);

  		obj_request->result = 0;

  	} else if (xferred < length && !obj_request->result) {
  		if (obj_request->type == OBJ_REQUEST_BIO)
  			zero_bio_chain(obj_request->bio_list, xferred);
  		else
  			zero_pages(obj_request->pages, xferred, length);

  	}

  	obj_request->xferred = length;

  	obj_request_done_set(obj_request);
  }

  static void rbd_obj_request_complete(struct rbd_obj_request *obj_request)
  {

  	dout("%s: obj %p cb %p
  ", __func__, obj_request,
  		obj_request->callback);

  	if (obj_request->callback)
  		obj_request->callback(obj_request);

  	else
  		complete_all(&obj_request->completion);

  }

  static void rbd_osd_read_callback(struct rbd_obj_request *obj_request)

  {

  	struct rbd_img_request *img_request = NULL;

  	struct rbd_device *rbd_dev = NULL;

  	bool layered = false;
  
  	if (obj_request_img_data_test(obj_request)) {
  		img_request = obj_request->img_request;
  		layered = img_request && img_request_layered_test(img_request);

  		rbd_dev = img_request->rbd_dev;

  	}

  
  	dout("%s: obj %p img %p result %d %llu/%llu
  ", __func__,
  		obj_request, img_request, obj_request->result,
  		obj_request->xferred, obj_request->length);

  	if (layered && obj_request->result == -ENOENT &&
  			obj_request->img_offset < rbd_dev->parent_overlap)

  		rbd_img_parent_read(obj_request);
  	else if (img_request)

  		rbd_img_obj_request_read_callback(obj_request);
  	else
  		obj_request_done_set(obj_request);

  }

  static void rbd_osd_write_callback(struct rbd_obj_request *obj_request)

  {

  	dout("%s: obj %p result %d %llu
  ", __func__, obj_request,
  		obj_request->result, obj_request->length);
  	/*

  	 * There is no such thing as a successful short write.  Set
  	 * it to our originally-requested length.

  	 */
  	obj_request->xferred = obj_request->length;

  	obj_request_done_set(obj_request);

  }