blob: 8b6091b6d5cbb4f007b06cd964ffd3e7a12ac203 [file] [log] [blame]
Alex Eldere2a58ee2013-04-30 00:44:33 -05001
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002/*
3 rbd.c -- Export ceph rados objects as a Linux block device
4
5
6 based on drivers/block/osdblk.c:
7
8 Copyright 2009 Red Hat, Inc.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING. If not, write to
21 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
22
23
24
Yehuda Sadehdfc56062010-11-19 14:51:04 -080025 For usage instructions, please refer to:
Yehuda Sadeh602adf42010-08-12 16:11:25 -070026
Yehuda Sadehdfc56062010-11-19 14:51:04 -080027 Documentation/ABI/testing/sysfs-bus-rbd
Yehuda Sadeh602adf42010-08-12 16:11:25 -070028
29 */
30
31#include <linux/ceph/libceph.h>
32#include <linux/ceph/osd_client.h>
33#include <linux/ceph/mon_client.h>
34#include <linux/ceph/decode.h>
Yehuda Sadeh59c2be12011-03-21 15:10:11 -070035#include <linux/parser.h>
Alex Elder30d1cff2013-05-01 12:43:03 -050036#include <linux/bsearch.h>
Yehuda Sadeh602adf42010-08-12 16:11:25 -070037
38#include <linux/kernel.h>
39#include <linux/device.h>
40#include <linux/module.h>
41#include <linux/fs.h>
42#include <linux/blkdev.h>
Alex Elder1c2a9df2013-05-01 12:43:03 -050043#include <linux/slab.h>
Yehuda Sadeh602adf42010-08-12 16:11:25 -070044
45#include "rbd_types.h"
46
Alex Elderaafb2302012-09-06 16:00:54 -050047#define RBD_DEBUG /* Activate rbd_assert() calls */
48
Alex Elder593a9e72012-02-07 12:03:37 -060049/*
50 * The basic unit of block I/O is a sector. It is interpreted in a
51 * number of contexts in Linux (blk, bio, genhd), but the default is
52 * universally 512 bytes. These symbols are just slightly more
53 * meaningful than the bare numbers they represent.
54 */
55#define SECTOR_SHIFT 9
56#define SECTOR_SIZE (1ULL << SECTOR_SHIFT)
57
Alex Eldera2acd002013-05-08 22:50:04 -050058/*
59 * Increment the given counter and return its updated value.
60 * If the counter is already 0 it will not be incremented.
61 * If the counter is already at its maximum value returns
62 * -EINVAL without updating it.
63 */
64static int atomic_inc_return_safe(atomic_t *v)
65{
66 unsigned int counter;
67
68 counter = (unsigned int)__atomic_add_unless(v, 1, 0);
69 if (counter <= (unsigned int)INT_MAX)
70 return (int)counter;
71
72 atomic_dec(v);
73
74 return -EINVAL;
75}
76
77/* Decrement the counter. Return the resulting value, or -EINVAL */
78static int atomic_dec_return_safe(atomic_t *v)
79{
80 int counter;
81
82 counter = atomic_dec_return(v);
83 if (counter >= 0)
84 return counter;
85
86 atomic_inc(v);
87
88 return -EINVAL;
89}
90
Alex Elderf0f8cef2012-01-29 13:57:44 -060091#define RBD_DRV_NAME "rbd"
92#define RBD_DRV_NAME_LONG "rbd (rados block device)"
Yehuda Sadeh602adf42010-08-12 16:11:25 -070093
94#define RBD_MINORS_PER_MAJOR 256 /* max minors per blkdev */
95
Alex Elderd4b125e2012-07-03 16:01:19 -050096#define RBD_SNAP_DEV_NAME_PREFIX "snap_"
97#define RBD_MAX_SNAP_NAME_LEN \
98 (NAME_MAX - (sizeof (RBD_SNAP_DEV_NAME_PREFIX) - 1))
99
Alex Elder35d489f2012-07-03 16:01:19 -0500100#define RBD_MAX_SNAP_COUNT 510 /* allows max snapc to fit in 4KB */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700101
102#define RBD_SNAP_HEAD_NAME "-"
103
Alex Elder9682fc62013-04-30 00:44:33 -0500104#define BAD_SNAP_INDEX U32_MAX /* invalid index into snap array */
105
Alex Elder9e15b772012-10-30 19:40:33 -0500106/* This allows a single page to hold an image name sent by OSD */
107#define RBD_IMAGE_NAME_LEN_MAX (PAGE_SIZE - sizeof (__le32) - 1)
Alex Elder1e130192012-07-03 16:01:19 -0500108#define RBD_IMAGE_ID_LEN_MAX 64
Alex Elder9e15b772012-10-30 19:40:33 -0500109
Alex Elder1e130192012-07-03 16:01:19 -0500110#define RBD_OBJ_PREFIX_LEN_MAX 64
Alex Elder589d30e2012-07-10 20:30:11 -0500111
Alex Elderd8891402012-10-09 13:50:17 -0700112/* Feature bits */
113
Alex Elder5cbf6f122013-04-11 09:29:48 -0500114#define RBD_FEATURE_LAYERING (1<<0)
115#define RBD_FEATURE_STRIPINGV2 (1<<1)
116#define RBD_FEATURES_ALL \
117 (RBD_FEATURE_LAYERING | RBD_FEATURE_STRIPINGV2)
Alex Elderd8891402012-10-09 13:50:17 -0700118
119/* Features supported by this (client software) implementation. */
120
Alex Elder770eba62012-10-25 23:34:40 -0500121#define RBD_FEATURES_SUPPORTED (RBD_FEATURES_ALL)
Alex Elderd8891402012-10-09 13:50:17 -0700122
Alex Elder81a89792012-02-02 08:13:30 -0600123/*
124 * An RBD device name will be "rbd#", where the "rbd" comes from
125 * RBD_DRV_NAME above, and # is a unique integer identifier.
126 * MAX_INT_FORMAT_WIDTH is used in ensuring DEV_NAME_LEN is big
127 * enough to hold all possible device names.
128 */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700129#define DEV_NAME_LEN 32
Alex Elder81a89792012-02-02 08:13:30 -0600130#define MAX_INT_FORMAT_WIDTH ((5 * sizeof (int)) / 2 + 1)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700131
132/*
133 * block device image metadata (in-memory version)
134 */
135struct rbd_image_header {
Alex Elderf35a4de2013-05-06 09:51:29 -0500136 /* These six fields never change for a given rbd image */
Alex Elder849b4262012-07-09 21:04:24 -0500137 char *object_prefix;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700138 __u8 obj_order;
139 __u8 crypt_type;
140 __u8 comp_type;
Alex Elderf35a4de2013-05-06 09:51:29 -0500141 u64 stripe_unit;
142 u64 stripe_count;
143 u64 features; /* Might be changeable someday? */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700144
Alex Elderf84344f2012-08-31 17:29:51 -0500145 /* The remaining fields need to be updated occasionally */
146 u64 image_size;
147 struct ceph_snap_context *snapc;
Alex Elderf35a4de2013-05-06 09:51:29 -0500148 char *snap_names; /* format 1 only */
149 u64 *snap_sizes; /* format 1 only */
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700150};
151
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500152/*
153 * An rbd image specification.
154 *
155 * The tuple (pool_id, image_id, snap_id) is sufficient to uniquely
Alex Elderc66c6e02012-11-01 08:39:26 -0500156 * identify an image. Each rbd_dev structure includes a pointer to
157 * an rbd_spec structure that encapsulates this identity.
158 *
159 * Each of the id's in an rbd_spec has an associated name. For a
160 * user-mapped image, the names are supplied and the id's associated
161 * with them are looked up. For a layered image, a parent image is
162 * defined by the tuple, and the names are looked up.
163 *
164 * An rbd_dev structure contains a parent_spec pointer which is
165 * non-null if the image it represents is a child in a layered
166 * image. This pointer will refer to the rbd_spec structure used
167 * by the parent rbd_dev for its own identity (i.e., the structure
168 * is shared between the parent and child).
169 *
170 * Since these structures are populated once, during the discovery
171 * phase of image construction, they are effectively immutable so
172 * we make no effort to synchronize access to them.
173 *
174 * Note that code herein does not assume the image name is known (it
175 * could be a null pointer).
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500176 */
177struct rbd_spec {
178 u64 pool_id;
Alex Elderecb4dc222013-04-26 09:43:47 -0500179 const char *pool_name;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500180
Alex Elderecb4dc222013-04-26 09:43:47 -0500181 const char *image_id;
182 const char *image_name;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500183
184 u64 snap_id;
Alex Elderecb4dc222013-04-26 09:43:47 -0500185 const char *snap_name;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500186
187 struct kref kref;
188};
189
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700190/*
Alex Elderf0f8cef2012-01-29 13:57:44 -0600191 * an instance of the client. multiple devices may share an rbd client.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700192 */
193struct rbd_client {
194 struct ceph_client *client;
195 struct kref kref;
196 struct list_head node;
197};
198
Alex Elderbf0d5f502012-11-22 00:00:08 -0600199struct rbd_img_request;
200typedef void (*rbd_img_callback_t)(struct rbd_img_request *);
201
202#define BAD_WHICH U32_MAX /* Good which or bad which, which? */
203
204struct rbd_obj_request;
205typedef void (*rbd_obj_callback_t)(struct rbd_obj_request *);
206
Alex Elder9969ebc2013-01-18 12:31:10 -0600207enum obj_request_type {
208 OBJ_REQUEST_NODATA, OBJ_REQUEST_BIO, OBJ_REQUEST_PAGES
209};
Alex Elderbf0d5f502012-11-22 00:00:08 -0600210
Alex Elder926f9b32013-02-11 12:33:24 -0600211enum obj_req_flags {
212 OBJ_REQ_DONE, /* completion flag: not done = 0, done = 1 */
Alex Elder6365d332013-02-11 12:33:24 -0600213 OBJ_REQ_IMG_DATA, /* object usage: standalone = 0, image = 1 */
Alex Elder5679c592013-02-11 12:33:24 -0600214 OBJ_REQ_KNOWN, /* EXISTS flag valid: no = 0, yes = 1 */
215 OBJ_REQ_EXISTS, /* target exists: no = 0, yes = 1 */
Alex Elder926f9b32013-02-11 12:33:24 -0600216};
217
Alex Elderbf0d5f502012-11-22 00:00:08 -0600218struct rbd_obj_request {
219 const char *object_name;
220 u64 offset; /* object start byte */
221 u64 length; /* bytes from offset */
Alex Elder926f9b32013-02-11 12:33:24 -0600222 unsigned long flags;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600223
Alex Elderc5b5ef62013-02-11 12:33:24 -0600224 /*
225 * An object request associated with an image will have its
226 * img_data flag set; a standalone object request will not.
227 *
228 * A standalone object request will have which == BAD_WHICH
229 * and a null obj_request pointer.
230 *
231 * An object request initiated in support of a layered image
232 * object (to check for its existence before a write) will
233 * have which == BAD_WHICH and a non-null obj_request pointer.
234 *
235 * Finally, an object request for rbd image data will have
236 * which != BAD_WHICH, and will have a non-null img_request
237 * pointer. The value of which will be in the range
238 * 0..(img_request->obj_request_count-1).
239 */
240 union {
241 struct rbd_obj_request *obj_request; /* STAT op */
242 struct {
243 struct rbd_img_request *img_request;
244 u64 img_offset;
245 /* links for img_request->obj_requests list */
246 struct list_head links;
247 };
248 };
Alex Elderbf0d5f502012-11-22 00:00:08 -0600249 u32 which; /* posn image request list */
250
251 enum obj_request_type type;
Alex Elder788e2df2013-01-17 12:25:27 -0600252 union {
253 struct bio *bio_list;
254 struct {
255 struct page **pages;
256 u32 page_count;
257 };
258 };
Alex Elder0eefd472013-04-19 15:34:50 -0500259 struct page **copyup_pages;
Alex Elderebda6402013-05-10 16:29:22 -0500260 u32 copyup_page_count;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600261
262 struct ceph_osd_request *osd_req;
263
264 u64 xferred; /* bytes transferred */
Sage Weil1b83bef2013-02-25 16:11:12 -0800265 int result;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600266
267 rbd_obj_callback_t callback;
Alex Elder788e2df2013-01-17 12:25:27 -0600268 struct completion completion;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600269
270 struct kref kref;
271};
272
Alex Elder0c425242013-02-08 09:55:49 -0600273enum img_req_flags {
Alex Elder9849e982013-01-24 16:13:36 -0600274 IMG_REQ_WRITE, /* I/O direction: read = 0, write = 1 */
275 IMG_REQ_CHILD, /* initiator: block = 0, child image = 1 */
Alex Elderd0b2e942013-01-24 16:13:36 -0600276 IMG_REQ_LAYERED, /* ENOENT handling: normal = 0, layered = 1 */
Alex Elder0c425242013-02-08 09:55:49 -0600277};
278
Alex Elderbf0d5f502012-11-22 00:00:08 -0600279struct rbd_img_request {
Alex Elderbf0d5f502012-11-22 00:00:08 -0600280 struct rbd_device *rbd_dev;
281 u64 offset; /* starting image byte offset */
282 u64 length; /* byte count from offset */
Alex Elder0c425242013-02-08 09:55:49 -0600283 unsigned long flags;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600284 union {
Alex Elder9849e982013-01-24 16:13:36 -0600285 u64 snap_id; /* for reads */
Alex Elderbf0d5f502012-11-22 00:00:08 -0600286 struct ceph_snap_context *snapc; /* for writes */
Alex Elder9849e982013-01-24 16:13:36 -0600287 };
288 union {
289 struct request *rq; /* block request */
290 struct rbd_obj_request *obj_request; /* obj req initiator */
Alex Elderbf0d5f502012-11-22 00:00:08 -0600291 };
Alex Elder3d7efd12013-04-19 15:34:50 -0500292 struct page **copyup_pages;
Alex Elderebda6402013-05-10 16:29:22 -0500293 u32 copyup_page_count;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600294 spinlock_t completion_lock;/* protects next_completion */
295 u32 next_completion;
296 rbd_img_callback_t callback;
Alex Elder55f27e02013-04-10 12:34:25 -0500297 u64 xferred;/* aggregate bytes transferred */
Alex Eldera5a337d2013-01-24 16:13:36 -0600298 int result; /* first nonzero obj_request result */
Alex Elderbf0d5f502012-11-22 00:00:08 -0600299
300 u32 obj_request_count;
301 struct list_head obj_requests; /* rbd_obj_request structs */
302
303 struct kref kref;
304};
305
306#define for_each_obj_request(ireq, oreq) \
Alex Elderef06f4d32013-02-08 09:55:48 -0600307 list_for_each_entry(oreq, &(ireq)->obj_requests, links)
Alex Elderbf0d5f502012-11-22 00:00:08 -0600308#define for_each_obj_request_from(ireq, oreq) \
Alex Elderef06f4d32013-02-08 09:55:48 -0600309 list_for_each_entry_from(oreq, &(ireq)->obj_requests, links)
Alex Elderbf0d5f502012-11-22 00:00:08 -0600310#define for_each_obj_request_safe(ireq, oreq, n) \
Alex Elderef06f4d32013-02-08 09:55:48 -0600311 list_for_each_entry_safe_reverse(oreq, n, &(ireq)->obj_requests, links)
Alex Elderbf0d5f502012-11-22 00:00:08 -0600312
Alex Elderf84344f2012-08-31 17:29:51 -0500313struct rbd_mapping {
Alex Elder99c1f08f2012-08-30 14:42:15 -0500314 u64 size;
Alex Elder34b13182012-07-13 20:35:12 -0500315 u64 features;
Alex Elderf84344f2012-08-31 17:29:51 -0500316 bool read_only;
317};
318
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700319/*
320 * a single device
321 */
322struct rbd_device {
Alex Elderde71a292012-07-03 16:01:19 -0500323 int dev_id; /* blkdev unique id */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700324
325 int major; /* blkdev assigned major */
326 struct gendisk *disk; /* blkdev's gendisk and rq */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700327
Alex Eldera30b71b2012-07-10 20:30:11 -0500328 u32 image_format; /* Either 1 or 2 */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700329 struct rbd_client *rbd_client;
330
331 char name[DEV_NAME_LEN]; /* blkdev name, e.g. rbd3 */
332
Alex Elderb82d1672013-01-14 12:43:31 -0600333 spinlock_t lock; /* queue, flags, open_count */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700334
335 struct rbd_image_header header;
Alex Elderb82d1672013-01-14 12:43:31 -0600336 unsigned long flags; /* possibly lock protected */
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500337 struct rbd_spec *spec;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700338
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500339 char *header_name;
Alex Elder971f8392012-10-25 23:34:41 -0500340
Alex Elder0903e872012-11-14 12:25:19 -0600341 struct ceph_file_layout layout;
342
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700343 struct ceph_osd_event *watch_event;
Alex Elder975241a2013-01-25 17:08:55 -0600344 struct rbd_obj_request *watch_request;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700345
Alex Elder86b00e02012-10-25 23:34:42 -0500346 struct rbd_spec *parent_spec;
347 u64 parent_overlap;
Alex Eldera2acd002013-05-08 22:50:04 -0500348 atomic_t parent_ref;
Alex Elder2f82ee52012-10-30 19:40:33 -0500349 struct rbd_device *parent;
Alex Elder86b00e02012-10-25 23:34:42 -0500350
Josh Durginc6666012011-11-21 17:11:12 -0800351 /* protects updating the header */
352 struct rw_semaphore header_rwsem;
Alex Elderf84344f2012-08-31 17:29:51 -0500353
354 struct rbd_mapping mapping;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700355
356 struct list_head node;
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800357
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800358 /* sysfs related */
359 struct device dev;
Alex Elderb82d1672013-01-14 12:43:31 -0600360 unsigned long open_count; /* protected by lock */
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800361};
362
Alex Elderb82d1672013-01-14 12:43:31 -0600363/*
364 * Flag bits for rbd_dev->flags. If atomicity is required,
365 * rbd_dev->lock is used to protect access.
366 *
367 * Currently, only the "removing" flag (which is coupled with the
368 * "open_count" field) requires atomic access.
369 */
Alex Elder6d292902013-01-14 12:43:31 -0600370enum rbd_dev_flags {
371 RBD_DEV_FLAG_EXISTS, /* mapped snapshot has not been deleted */
Alex Elderb82d1672013-01-14 12:43:31 -0600372 RBD_DEV_FLAG_REMOVING, /* this mapping is being removed */
Alex Elder6d292902013-01-14 12:43:31 -0600373};
374
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700375static DEFINE_MUTEX(ctl_mutex); /* Serialize open/close/setup/teardown */
Alex Eldere124a82f2012-01-29 13:57:44 -0600376
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700377static LIST_HEAD(rbd_dev_list); /* devices */
Alex Eldere124a82f2012-01-29 13:57:44 -0600378static DEFINE_SPINLOCK(rbd_dev_list_lock);
379
Alex Elder432b8582012-01-29 13:57:44 -0600380static LIST_HEAD(rbd_client_list); /* clients */
381static DEFINE_SPINLOCK(rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700382
Alex Elder78c2a442013-05-01 12:43:04 -0500383/* Slab caches for frequently-allocated structures */
384
Alex Elder1c2a9df2013-05-01 12:43:03 -0500385static struct kmem_cache *rbd_img_request_cache;
Alex Elder868311b2013-05-01 12:43:03 -0500386static struct kmem_cache *rbd_obj_request_cache;
Alex Elder78c2a442013-05-01 12:43:04 -0500387static struct kmem_cache *rbd_segment_name_cache;
Alex Elder1c2a9df2013-05-01 12:43:03 -0500388
Alex Elder3d7efd12013-04-19 15:34:50 -0500389static int rbd_img_request_submit(struct rbd_img_request *img_request);
390
Alex Elder200a6a82013-04-28 23:32:34 -0500391static void rbd_dev_device_release(struct device *dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800392
Alex Elderf0f8cef2012-01-29 13:57:44 -0600393static ssize_t rbd_add(struct bus_type *bus, const char *buf,
394 size_t count);
395static ssize_t rbd_remove(struct bus_type *bus, const char *buf,
396 size_t count);
Alex Elder1f3ef782013-05-06 17:40:33 -0500397static int rbd_dev_image_probe(struct rbd_device *rbd_dev, bool mapping);
Alex Eldera2acd002013-05-08 22:50:04 -0500398static void rbd_spec_put(struct rbd_spec *spec);
Alex Elderf0f8cef2012-01-29 13:57:44 -0600399
400static struct bus_attribute rbd_bus_attrs[] = {
401 __ATTR(add, S_IWUSR, NULL, rbd_add),
402 __ATTR(remove, S_IWUSR, NULL, rbd_remove),
403 __ATTR_NULL
404};
405
406static struct bus_type rbd_bus_type = {
407 .name = "rbd",
408 .bus_attrs = rbd_bus_attrs,
409};
410
411static void rbd_root_dev_release(struct device *dev)
412{
413}
414
415static struct device rbd_root_dev = {
416 .init_name = "rbd",
417 .release = rbd_root_dev_release,
418};
419
Alex Elder06ecc6c2012-11-01 10:17:15 -0500420static __printf(2, 3)
421void rbd_warn(struct rbd_device *rbd_dev, const char *fmt, ...)
422{
423 struct va_format vaf;
424 va_list args;
425
426 va_start(args, fmt);
427 vaf.fmt = fmt;
428 vaf.va = &args;
429
430 if (!rbd_dev)
431 printk(KERN_WARNING "%s: %pV\n", RBD_DRV_NAME, &vaf);
432 else if (rbd_dev->disk)
433 printk(KERN_WARNING "%s: %s: %pV\n",
434 RBD_DRV_NAME, rbd_dev->disk->disk_name, &vaf);
435 else if (rbd_dev->spec && rbd_dev->spec->image_name)
436 printk(KERN_WARNING "%s: image %s: %pV\n",
437 RBD_DRV_NAME, rbd_dev->spec->image_name, &vaf);
438 else if (rbd_dev->spec && rbd_dev->spec->image_id)
439 printk(KERN_WARNING "%s: id %s: %pV\n",
440 RBD_DRV_NAME, rbd_dev->spec->image_id, &vaf);
441 else /* punt */
442 printk(KERN_WARNING "%s: rbd_dev %p: %pV\n",
443 RBD_DRV_NAME, rbd_dev, &vaf);
444 va_end(args);
445}
446
Alex Elderaafb2302012-09-06 16:00:54 -0500447#ifdef RBD_DEBUG
448#define rbd_assert(expr) \
449 if (unlikely(!(expr))) { \
450 printk(KERN_ERR "\nAssertion failure in %s() " \
451 "at line %d:\n\n" \
452 "\trbd_assert(%s);\n\n", \
453 __func__, __LINE__, #expr); \
454 BUG(); \
455 }
456#else /* !RBD_DEBUG */
457# define rbd_assert(expr) ((void) 0)
458#endif /* !RBD_DEBUG */
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800459
Alex Elderb454e362013-04-19 15:34:50 -0500460static int rbd_img_obj_request_submit(struct rbd_obj_request *obj_request);
Alex Elder05a46af2013-04-26 15:44:36 -0500461static void rbd_img_parent_read(struct rbd_obj_request *obj_request);
462static void rbd_dev_remove_parent(struct rbd_device *rbd_dev);
Alex Elder8b3e1a52013-01-24 16:13:36 -0600463
Alex Eldercc4a38bd2013-04-30 00:44:33 -0500464static int rbd_dev_refresh(struct rbd_device *rbd_dev);
Alex Elder2df3fac2013-05-06 09:51:30 -0500465static int rbd_dev_v2_header_onetime(struct rbd_device *rbd_dev);
466static int rbd_dev_v2_header_info(struct rbd_device *rbd_dev);
Alex Elder54cac612013-04-30 00:44:33 -0500467static const char *rbd_dev_v2_snap_name(struct rbd_device *rbd_dev,
468 u64 snap_id);
Alex Elder2ad3d712013-04-30 00:44:33 -0500469static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
470 u8 *order, u64 *snap_size);
471static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
472 u64 *snap_features);
473static u64 rbd_snap_id_by_name(struct rbd_device *rbd_dev, const char *name);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700474
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700475static int rbd_open(struct block_device *bdev, fmode_t mode)
476{
Alex Elderf0f8cef2012-01-29 13:57:44 -0600477 struct rbd_device *rbd_dev = bdev->bd_disk->private_data;
Alex Elderb82d1672013-01-14 12:43:31 -0600478 bool removing = false;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700479
Alex Elderf84344f2012-08-31 17:29:51 -0500480 if ((mode & FMODE_WRITE) && rbd_dev->mapping.read_only)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700481 return -EROFS;
482
Alex Eldera14ea262013-02-05 13:23:12 -0600483 spin_lock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600484 if (test_bit(RBD_DEV_FLAG_REMOVING, &rbd_dev->flags))
485 removing = true;
486 else
487 rbd_dev->open_count++;
Alex Eldera14ea262013-02-05 13:23:12 -0600488 spin_unlock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600489 if (removing)
490 return -ENOENT;
491
Alex Elder42382b72012-11-16 09:29:16 -0600492 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Alex Elderc3e946c2012-11-16 09:29:16 -0600493 (void) get_device(&rbd_dev->dev);
Alex Elderf84344f2012-08-31 17:29:51 -0500494 set_device_ro(bdev, rbd_dev->mapping.read_only);
Alex Elder42382b72012-11-16 09:29:16 -0600495 mutex_unlock(&ctl_mutex);
Alex Elder340c7a22012-08-10 13:12:07 -0700496
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700497 return 0;
498}
499
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800500static int rbd_release(struct gendisk *disk, fmode_t mode)
501{
502 struct rbd_device *rbd_dev = disk->private_data;
Alex Elderb82d1672013-01-14 12:43:31 -0600503 unsigned long open_count_before;
504
Alex Eldera14ea262013-02-05 13:23:12 -0600505 spin_lock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600506 open_count_before = rbd_dev->open_count--;
Alex Eldera14ea262013-02-05 13:23:12 -0600507 spin_unlock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600508 rbd_assert(open_count_before > 0);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800509
Alex Elder42382b72012-11-16 09:29:16 -0600510 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Alex Elderc3e946c2012-11-16 09:29:16 -0600511 put_device(&rbd_dev->dev);
Alex Elder42382b72012-11-16 09:29:16 -0600512 mutex_unlock(&ctl_mutex);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800513
514 return 0;
515}
516
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700517static const struct block_device_operations rbd_bd_ops = {
518 .owner = THIS_MODULE,
519 .open = rbd_open,
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800520 .release = rbd_release,
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700521};
522
523/*
524 * Initialize an rbd client instance.
Alex Elder43ae4702012-07-03 16:01:18 -0500525 * We own *ceph_opts.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700526 */
Alex Elderf8c38922012-08-10 13:12:07 -0700527static struct rbd_client *rbd_client_create(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700528{
529 struct rbd_client *rbdc;
530 int ret = -ENOMEM;
531
Alex Elder37206ee2013-02-20 17:32:08 -0600532 dout("%s:\n", __func__);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700533 rbdc = kmalloc(sizeof(struct rbd_client), GFP_KERNEL);
534 if (!rbdc)
535 goto out_opt;
536
537 kref_init(&rbdc->kref);
538 INIT_LIST_HEAD(&rbdc->node);
539
Alex Elderbc534d82012-01-29 13:57:44 -0600540 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
541
Alex Elder43ae4702012-07-03 16:01:18 -0500542 rbdc->client = ceph_create_client(ceph_opts, rbdc, 0, 0);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700543 if (IS_ERR(rbdc->client))
Alex Elderbc534d82012-01-29 13:57:44 -0600544 goto out_mutex;
Alex Elder43ae4702012-07-03 16:01:18 -0500545 ceph_opts = NULL; /* Now rbdc->client is responsible for ceph_opts */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700546
547 ret = ceph_open_session(rbdc->client);
548 if (ret < 0)
549 goto out_err;
550
Alex Elder432b8582012-01-29 13:57:44 -0600551 spin_lock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700552 list_add_tail(&rbdc->node, &rbd_client_list);
Alex Elder432b8582012-01-29 13:57:44 -0600553 spin_unlock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700554
Alex Elderbc534d82012-01-29 13:57:44 -0600555 mutex_unlock(&ctl_mutex);
Alex Elder37206ee2013-02-20 17:32:08 -0600556 dout("%s: rbdc %p\n", __func__, rbdc);
Alex Elderbc534d82012-01-29 13:57:44 -0600557
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700558 return rbdc;
559
560out_err:
561 ceph_destroy_client(rbdc->client);
Alex Elderbc534d82012-01-29 13:57:44 -0600562out_mutex:
563 mutex_unlock(&ctl_mutex);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700564 kfree(rbdc);
565out_opt:
Alex Elder43ae4702012-07-03 16:01:18 -0500566 if (ceph_opts)
567 ceph_destroy_options(ceph_opts);
Alex Elder37206ee2013-02-20 17:32:08 -0600568 dout("%s: error %d\n", __func__, ret);
569
Vasiliy Kulikov28f259b2010-09-26 12:59:37 +0400570 return ERR_PTR(ret);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700571}
572
Alex Elder2f82ee52012-10-30 19:40:33 -0500573static struct rbd_client *__rbd_get_client(struct rbd_client *rbdc)
574{
575 kref_get(&rbdc->kref);
576
577 return rbdc;
578}
579
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700580/*
Alex Elder1f7ba332012-08-10 13:12:07 -0700581 * Find a ceph client with specific addr and configuration. If
582 * found, bump its reference count.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700583 */
Alex Elder1f7ba332012-08-10 13:12:07 -0700584static struct rbd_client *rbd_client_find(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700585{
586 struct rbd_client *client_node;
Alex Elder1f7ba332012-08-10 13:12:07 -0700587 bool found = false;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700588
Alex Elder43ae4702012-07-03 16:01:18 -0500589 if (ceph_opts->flags & CEPH_OPT_NOSHARE)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700590 return NULL;
591
Alex Elder1f7ba332012-08-10 13:12:07 -0700592 spin_lock(&rbd_client_list_lock);
593 list_for_each_entry(client_node, &rbd_client_list, node) {
594 if (!ceph_compare_options(ceph_opts, client_node->client)) {
Alex Elder2f82ee52012-10-30 19:40:33 -0500595 __rbd_get_client(client_node);
596
Alex Elder1f7ba332012-08-10 13:12:07 -0700597 found = true;
598 break;
599 }
600 }
601 spin_unlock(&rbd_client_list_lock);
602
603 return found ? client_node : NULL;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700604}
605
606/*
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700607 * mount options
608 */
609enum {
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700610 Opt_last_int,
611 /* int args above */
612 Opt_last_string,
613 /* string args above */
Alex Eldercc0538b2012-08-10 13:12:07 -0700614 Opt_read_only,
615 Opt_read_write,
616 /* Boolean args above */
617 Opt_last_bool,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700618};
619
Alex Elder43ae4702012-07-03 16:01:18 -0500620static match_table_t rbd_opts_tokens = {
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700621 /* int args above */
622 /* string args above */
Alex Elderbe466c12012-10-22 11:31:26 -0500623 {Opt_read_only, "read_only"},
Alex Eldercc0538b2012-08-10 13:12:07 -0700624 {Opt_read_only, "ro"}, /* Alternate spelling */
625 {Opt_read_write, "read_write"},
626 {Opt_read_write, "rw"}, /* Alternate spelling */
627 /* Boolean args above */
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700628 {-1, NULL}
629};
630
Alex Elder98571b52013-01-20 14:44:42 -0600631struct rbd_options {
632 bool read_only;
633};
634
635#define RBD_READ_ONLY_DEFAULT false
636
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700637static int parse_rbd_opts_token(char *c, void *private)
638{
Alex Elder43ae4702012-07-03 16:01:18 -0500639 struct rbd_options *rbd_opts = private;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700640 substring_t argstr[MAX_OPT_ARGS];
641 int token, intval, ret;
642
Alex Elder43ae4702012-07-03 16:01:18 -0500643 token = match_token(c, rbd_opts_tokens, argstr);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700644 if (token < 0)
645 return -EINVAL;
646
647 if (token < Opt_last_int) {
648 ret = match_int(&argstr[0], &intval);
649 if (ret < 0) {
650 pr_err("bad mount option arg (not int) "
651 "at '%s'\n", c);
652 return ret;
653 }
654 dout("got int token %d val %d\n", token, intval);
655 } else if (token > Opt_last_int && token < Opt_last_string) {
656 dout("got string token %d val %s\n", token,
657 argstr[0].from);
Alex Eldercc0538b2012-08-10 13:12:07 -0700658 } else if (token > Opt_last_string && token < Opt_last_bool) {
659 dout("got Boolean token %d\n", token);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700660 } else {
661 dout("got token %d\n", token);
662 }
663
664 switch (token) {
Alex Eldercc0538b2012-08-10 13:12:07 -0700665 case Opt_read_only:
666 rbd_opts->read_only = true;
667 break;
668 case Opt_read_write:
669 rbd_opts->read_only = false;
670 break;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700671 default:
Alex Elderaafb2302012-09-06 16:00:54 -0500672 rbd_assert(false);
673 break;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700674 }
675 return 0;
676}
677
678/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700679 * Get a ceph client with specific addr and configuration, if one does
680 * not exist create it.
681 */
Alex Elder9d3997f2012-10-25 23:34:42 -0500682static struct rbd_client *rbd_get_client(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700683{
Alex Elderf8c38922012-08-10 13:12:07 -0700684 struct rbd_client *rbdc;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700685
Alex Elder1f7ba332012-08-10 13:12:07 -0700686 rbdc = rbd_client_find(ceph_opts);
Alex Elder9d3997f2012-10-25 23:34:42 -0500687 if (rbdc) /* using an existing client */
Alex Elder43ae4702012-07-03 16:01:18 -0500688 ceph_destroy_options(ceph_opts);
Alex Elder9d3997f2012-10-25 23:34:42 -0500689 else
Alex Elderf8c38922012-08-10 13:12:07 -0700690 rbdc = rbd_client_create(ceph_opts);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700691
Alex Elder9d3997f2012-10-25 23:34:42 -0500692 return rbdc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700693}
694
695/*
696 * Destroy ceph client
Alex Elderd23a4b32012-01-29 13:57:43 -0600697 *
Alex Elder432b8582012-01-29 13:57:44 -0600698 * Caller must hold rbd_client_list_lock.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700699 */
700static void rbd_client_release(struct kref *kref)
701{
702 struct rbd_client *rbdc = container_of(kref, struct rbd_client, kref);
703
Alex Elder37206ee2013-02-20 17:32:08 -0600704 dout("%s: rbdc %p\n", __func__, rbdc);
Alex Eldercd9d9f52012-04-04 13:35:44 -0500705 spin_lock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700706 list_del(&rbdc->node);
Alex Eldercd9d9f52012-04-04 13:35:44 -0500707 spin_unlock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700708
709 ceph_destroy_client(rbdc->client);
710 kfree(rbdc);
711}
712
713/*
714 * Drop reference to ceph client node. If it's not referenced anymore, release
715 * it.
716 */
Alex Elder9d3997f2012-10-25 23:34:42 -0500717static void rbd_put_client(struct rbd_client *rbdc)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700718{
Alex Elderc53d5892012-10-25 23:34:42 -0500719 if (rbdc)
720 kref_put(&rbdc->kref, rbd_client_release);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700721}
722
Alex Eldera30b71b2012-07-10 20:30:11 -0500723static bool rbd_image_format_valid(u32 image_format)
724{
725 return image_format == 1 || image_format == 2;
726}
727
Alex Elder8e94af82012-07-25 09:32:40 -0500728static bool rbd_dev_ondisk_valid(struct rbd_image_header_ondisk *ondisk)
729{
Alex Elder103a1502012-08-02 11:29:45 -0500730 size_t size;
731 u32 snap_count;
732
733 /* The header has to start with the magic rbd header text */
734 if (memcmp(&ondisk->text, RBD_HEADER_TEXT, sizeof (RBD_HEADER_TEXT)))
735 return false;
736
Alex Elderdb2388b2012-10-20 22:17:27 -0500737 /* The bio layer requires at least sector-sized I/O */
738
739 if (ondisk->options.order < SECTOR_SHIFT)
740 return false;
741
742 /* If we use u64 in a few spots we may be able to loosen this */
743
744 if (ondisk->options.order > 8 * sizeof (int) - 1)
745 return false;
746
Alex Elder103a1502012-08-02 11:29:45 -0500747 /*
748 * The size of a snapshot header has to fit in a size_t, and
749 * that limits the number of snapshots.
750 */
751 snap_count = le32_to_cpu(ondisk->snap_count);
752 size = SIZE_MAX - sizeof (struct ceph_snap_context);
753 if (snap_count > size / sizeof (__le64))
754 return false;
755
756 /*
757 * Not only that, but the size of the entire the snapshot
758 * header must also be representable in a size_t.
759 */
760 size -= snap_count * sizeof (__le64);
761 if ((u64) size < le64_to_cpu(ondisk->snap_names_len))
762 return false;
763
764 return true;
Alex Elder8e94af82012-07-25 09:32:40 -0500765}
766
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700767/*
Alex Elderbb23e372013-05-06 09:51:29 -0500768 * Fill an rbd image header with information from the given format 1
769 * on-disk header.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700770 */
Alex Elder662518b2013-05-06 09:51:29 -0500771static int rbd_header_from_disk(struct rbd_device *rbd_dev,
Alex Elder4156d9982012-08-02 11:29:46 -0500772 struct rbd_image_header_ondisk *ondisk)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700773{
Alex Elder662518b2013-05-06 09:51:29 -0500774 struct rbd_image_header *header = &rbd_dev->header;
Alex Elderbb23e372013-05-06 09:51:29 -0500775 bool first_time = header->object_prefix == NULL;
776 struct ceph_snap_context *snapc;
777 char *object_prefix = NULL;
778 char *snap_names = NULL;
779 u64 *snap_sizes = NULL;
Alex Elderccece232012-07-10 20:30:10 -0500780 u32 snap_count;
Alex Elderd2bb24e2012-07-26 23:37:14 -0500781 size_t size;
Alex Elderbb23e372013-05-06 09:51:29 -0500782 int ret = -ENOMEM;
Alex Elder621901d2012-08-23 23:22:06 -0500783 u32 i;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700784
Alex Elderbb23e372013-05-06 09:51:29 -0500785 /* Allocate this now to avoid having to handle failure below */
786
787 if (first_time) {
788 size_t len;
789
790 len = strnlen(ondisk->object_prefix,
791 sizeof (ondisk->object_prefix));
792 object_prefix = kmalloc(len + 1, GFP_KERNEL);
793 if (!object_prefix)
794 return -ENOMEM;
795 memcpy(object_prefix, ondisk->object_prefix, len);
796 object_prefix[len] = '\0';
797 }
798
799 /* Allocate the snapshot context and fill it in */
800
Alex Elder103a1502012-08-02 11:29:45 -0500801 snap_count = le32_to_cpu(ondisk->snap_count);
Alex Elderbb23e372013-05-06 09:51:29 -0500802 snapc = ceph_create_snap_context(snap_count, GFP_KERNEL);
803 if (!snapc)
804 goto out_err;
805 snapc->seq = le64_to_cpu(ondisk->snap_seq);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700806 if (snap_count) {
Alex Elderbb23e372013-05-06 09:51:29 -0500807 struct rbd_image_snap_ondisk *snaps;
Alex Elderf785cc12012-08-23 23:22:06 -0500808 u64 snap_names_len = le64_to_cpu(ondisk->snap_names_len);
809
Alex Elderbb23e372013-05-06 09:51:29 -0500810 /* We'll keep a copy of the snapshot names... */
Alex Elder621901d2012-08-23 23:22:06 -0500811
Alex Elderbb23e372013-05-06 09:51:29 -0500812 if (snap_names_len > (u64)SIZE_MAX)
813 goto out_2big;
814 snap_names = kmalloc(snap_names_len, GFP_KERNEL);
815 if (!snap_names)
Alex Elder6a523252012-07-19 17:12:59 -0500816 goto out_err;
Alex Elderbb23e372013-05-06 09:51:29 -0500817
818 /* ...as well as the array of their sizes. */
819
820 size = snap_count * sizeof (*header->snap_sizes);
821 snap_sizes = kmalloc(size, GFP_KERNEL);
822 if (!snap_sizes)
823 goto out_err;
824
Alex Elderf785cc12012-08-23 23:22:06 -0500825 /*
Alex Elderbb23e372013-05-06 09:51:29 -0500826 * Copy the names, and fill in each snapshot's id
827 * and size.
828 *
Alex Elder99a41eb2013-05-06 09:51:30 -0500829 * Note that rbd_dev_v1_header_info() guarantees the
Alex Elderbb23e372013-05-06 09:51:29 -0500830 * ondisk buffer we're working with has
Alex Elderf785cc12012-08-23 23:22:06 -0500831 * snap_names_len bytes beyond the end of the
832 * snapshot id array, this memcpy() is safe.
833 */
Alex Elderbb23e372013-05-06 09:51:29 -0500834 memcpy(snap_names, &ondisk->snaps[snap_count], snap_names_len);
835 snaps = ondisk->snaps;
836 for (i = 0; i < snap_count; i++) {
837 snapc->snaps[i] = le64_to_cpu(snaps[i].id);
838 snap_sizes[i] = le64_to_cpu(snaps[i].image_size);
839 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700840 }
Alex Elder849b4262012-07-09 21:04:24 -0500841
Alex Elderbb23e372013-05-06 09:51:29 -0500842 /* We won't fail any more, fill in the header */
Alex Elder6a523252012-07-19 17:12:59 -0500843
Alex Elder662518b2013-05-06 09:51:29 -0500844 down_write(&rbd_dev->header_rwsem);
Alex Elderbb23e372013-05-06 09:51:29 -0500845 if (first_time) {
846 header->object_prefix = object_prefix;
847 header->obj_order = ondisk->options.order;
848 header->crypt_type = ondisk->options.crypt_type;
849 header->comp_type = ondisk->options.comp_type;
850 /* The rest aren't used for format 1 images */
851 header->stripe_unit = 0;
852 header->stripe_count = 0;
853 header->features = 0;
Alex Elder662518b2013-05-06 09:51:29 -0500854 } else {
855 ceph_put_snap_context(header->snapc);
856 kfree(header->snap_names);
857 kfree(header->snap_sizes);
Alex Elderbb23e372013-05-06 09:51:29 -0500858 }
859
860 /* The remaining fields always get updated (when we refresh) */
Alex Elder621901d2012-08-23 23:22:06 -0500861
Alex Elderf84344f2012-08-31 17:29:51 -0500862 header->image_size = le64_to_cpu(ondisk->image_size);
Alex Elderbb23e372013-05-06 09:51:29 -0500863 header->snapc = snapc;
864 header->snap_names = snap_names;
865 header->snap_sizes = snap_sizes;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700866
Alex Elder662518b2013-05-06 09:51:29 -0500867 /* Make sure mapping size is consistent with header info */
868
869 if (rbd_dev->spec->snap_id == CEPH_NOSNAP || first_time)
870 if (rbd_dev->mapping.size != header->image_size)
871 rbd_dev->mapping.size = header->image_size;
872
873 up_write(&rbd_dev->header_rwsem);
874
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700875 return 0;
Alex Elderbb23e372013-05-06 09:51:29 -0500876out_2big:
877 ret = -EIO;
Alex Elder6a523252012-07-19 17:12:59 -0500878out_err:
Alex Elderbb23e372013-05-06 09:51:29 -0500879 kfree(snap_sizes);
880 kfree(snap_names);
881 ceph_put_snap_context(snapc);
882 kfree(object_prefix);
Alex Elderccece232012-07-10 20:30:10 -0500883
Alex Elderbb23e372013-05-06 09:51:29 -0500884 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700885}
886
Alex Elder9682fc62013-04-30 00:44:33 -0500887static const char *_rbd_dev_v1_snap_name(struct rbd_device *rbd_dev, u32 which)
888{
889 const char *snap_name;
890
891 rbd_assert(which < rbd_dev->header.snapc->num_snaps);
892
893 /* Skip over names until we find the one we are looking for */
894
895 snap_name = rbd_dev->header.snap_names;
896 while (which--)
897 snap_name += strlen(snap_name) + 1;
898
899 return kstrdup(snap_name, GFP_KERNEL);
900}
901
Alex Elder30d1cff2013-05-01 12:43:03 -0500902/*
903 * Snapshot id comparison function for use with qsort()/bsearch().
904 * Note that result is for snapshots in *descending* order.
905 */
906static int snapid_compare_reverse(const void *s1, const void *s2)
907{
908 u64 snap_id1 = *(u64 *)s1;
909 u64 snap_id2 = *(u64 *)s2;
910
911 if (snap_id1 < snap_id2)
912 return 1;
913 return snap_id1 == snap_id2 ? 0 : -1;
914}
915
916/*
917 * Search a snapshot context to see if the given snapshot id is
918 * present.
919 *
920 * Returns the position of the snapshot id in the array if it's found,
921 * or BAD_SNAP_INDEX otherwise.
922 *
923 * Note: The snapshot array is in kept sorted (by the osd) in
924 * reverse order, highest snapshot id first.
925 */
Alex Elder9682fc62013-04-30 00:44:33 -0500926static u32 rbd_dev_snap_index(struct rbd_device *rbd_dev, u64 snap_id)
927{
928 struct ceph_snap_context *snapc = rbd_dev->header.snapc;
Alex Elder30d1cff2013-05-01 12:43:03 -0500929 u64 *found;
Alex Elder9682fc62013-04-30 00:44:33 -0500930
Alex Elder30d1cff2013-05-01 12:43:03 -0500931 found = bsearch(&snap_id, &snapc->snaps, snapc->num_snaps,
932 sizeof (snap_id), snapid_compare_reverse);
Alex Elder9682fc62013-04-30 00:44:33 -0500933
Alex Elder30d1cff2013-05-01 12:43:03 -0500934 return found ? (u32)(found - &snapc->snaps[0]) : BAD_SNAP_INDEX;
Alex Elder9682fc62013-04-30 00:44:33 -0500935}
936
Alex Elder2ad3d712013-04-30 00:44:33 -0500937static const char *rbd_dev_v1_snap_name(struct rbd_device *rbd_dev,
938 u64 snap_id)
Alex Elder54cac612013-04-30 00:44:33 -0500939{
940 u32 which;
941
942 which = rbd_dev_snap_index(rbd_dev, snap_id);
943 if (which == BAD_SNAP_INDEX)
944 return NULL;
945
946 return _rbd_dev_v1_snap_name(rbd_dev, which);
947}
948
Alex Elder9e15b772012-10-30 19:40:33 -0500949static const char *rbd_snap_name(struct rbd_device *rbd_dev, u64 snap_id)
950{
Alex Elder9e15b772012-10-30 19:40:33 -0500951 if (snap_id == CEPH_NOSNAP)
952 return RBD_SNAP_HEAD_NAME;
953
Alex Elder54cac612013-04-30 00:44:33 -0500954 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
955 if (rbd_dev->image_format == 1)
956 return rbd_dev_v1_snap_name(rbd_dev, snap_id);
Alex Elder9e15b772012-10-30 19:40:33 -0500957
Alex Elder54cac612013-04-30 00:44:33 -0500958 return rbd_dev_v2_snap_name(rbd_dev, snap_id);
Alex Elder9e15b772012-10-30 19:40:33 -0500959}
960
Alex Elder2ad3d712013-04-30 00:44:33 -0500961static int rbd_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
962 u64 *snap_size)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700963{
Alex Elder2ad3d712013-04-30 00:44:33 -0500964 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
965 if (snap_id == CEPH_NOSNAP) {
966 *snap_size = rbd_dev->header.image_size;
967 } else if (rbd_dev->image_format == 1) {
968 u32 which;
Alex Elder00f1f362012-02-07 12:03:36 -0600969
Alex Elder2ad3d712013-04-30 00:44:33 -0500970 which = rbd_dev_snap_index(rbd_dev, snap_id);
971 if (which == BAD_SNAP_INDEX)
972 return -ENOENT;
Alex Elder00f1f362012-02-07 12:03:36 -0600973
Alex Elder2ad3d712013-04-30 00:44:33 -0500974 *snap_size = rbd_dev->header.snap_sizes[which];
975 } else {
976 u64 size = 0;
977 int ret;
978
979 ret = _rbd_dev_v2_snap_size(rbd_dev, snap_id, NULL, &size);
980 if (ret)
981 return ret;
982
983 *snap_size = size;
984 }
985 return 0;
986}
987
988static int rbd_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
989 u64 *snap_features)
990{
991 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
992 if (snap_id == CEPH_NOSNAP) {
993 *snap_features = rbd_dev->header.features;
994 } else if (rbd_dev->image_format == 1) {
995 *snap_features = 0; /* No features for format 1 */
996 } else {
997 u64 features = 0;
998 int ret;
999
1000 ret = _rbd_dev_v2_snap_features(rbd_dev, snap_id, &features);
1001 if (ret)
1002 return ret;
1003
1004 *snap_features = features;
1005 }
1006 return 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001007}
1008
Alex Elderd1cf5782013-04-27 09:59:30 -05001009static int rbd_dev_mapping_set(struct rbd_device *rbd_dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001010{
Alex Elder8f4b7d92013-05-06 07:40:30 -05001011 u64 snap_id = rbd_dev->spec->snap_id;
Alex Elder2ad3d712013-04-30 00:44:33 -05001012 u64 size = 0;
1013 u64 features = 0;
1014 int ret;
Alex Elder8b0241f2013-04-25 23:15:08 -05001015
Alex Elder2ad3d712013-04-30 00:44:33 -05001016 ret = rbd_snap_size(rbd_dev, snap_id, &size);
1017 if (ret)
1018 return ret;
1019 ret = rbd_snap_features(rbd_dev, snap_id, &features);
1020 if (ret)
1021 return ret;
1022
1023 rbd_dev->mapping.size = size;
1024 rbd_dev->mapping.features = features;
1025
Alex Elder8b0241f2013-04-25 23:15:08 -05001026 return 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001027}
1028
Alex Elderd1cf5782013-04-27 09:59:30 -05001029static void rbd_dev_mapping_clear(struct rbd_device *rbd_dev)
1030{
1031 rbd_dev->mapping.size = 0;
1032 rbd_dev->mapping.features = 0;
Alex Elderd1cf5782013-04-27 09:59:30 -05001033}
1034
Alex Elder98571b52013-01-20 14:44:42 -06001035static const char *rbd_segment_name(struct rbd_device *rbd_dev, u64 offset)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001036{
Alex Elder65ccfe22012-08-09 10:33:26 -07001037 char *name;
1038 u64 segment;
1039 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001040
Alex Elder78c2a442013-05-01 12:43:04 -05001041 name = kmem_cache_alloc(rbd_segment_name_cache, GFP_NOIO);
Alex Elder65ccfe22012-08-09 10:33:26 -07001042 if (!name)
1043 return NULL;
1044 segment = offset >> rbd_dev->header.obj_order;
Alex Elder2fd82b92012-11-09 15:05:54 -06001045 ret = snprintf(name, MAX_OBJ_NAME_SIZE + 1, "%s.%012llx",
Alex Elder65ccfe22012-08-09 10:33:26 -07001046 rbd_dev->header.object_prefix, segment);
Alex Elder2fd82b92012-11-09 15:05:54 -06001047 if (ret < 0 || ret > MAX_OBJ_NAME_SIZE) {
Alex Elder65ccfe22012-08-09 10:33:26 -07001048 pr_err("error formatting segment name for #%llu (%d)\n",
1049 segment, ret);
1050 kfree(name);
1051 name = NULL;
1052 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001053
Alex Elder65ccfe22012-08-09 10:33:26 -07001054 return name;
1055}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001056
Alex Elder78c2a442013-05-01 12:43:04 -05001057static void rbd_segment_name_free(const char *name)
1058{
1059 /* The explicit cast here is needed to drop the const qualifier */
1060
1061 kmem_cache_free(rbd_segment_name_cache, (void *)name);
1062}
1063
Alex Elder65ccfe22012-08-09 10:33:26 -07001064static u64 rbd_segment_offset(struct rbd_device *rbd_dev, u64 offset)
1065{
1066 u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001067
Alex Elder65ccfe22012-08-09 10:33:26 -07001068 return offset & (segment_size - 1);
1069}
1070
1071static u64 rbd_segment_length(struct rbd_device *rbd_dev,
1072 u64 offset, u64 length)
1073{
1074 u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
1075
1076 offset &= segment_size - 1;
1077
Alex Elderaafb2302012-09-06 16:00:54 -05001078 rbd_assert(length <= U64_MAX - offset);
Alex Elder65ccfe22012-08-09 10:33:26 -07001079 if (offset + length > segment_size)
1080 length = segment_size - offset;
1081
1082 return length;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001083}
1084
1085/*
Josh Durgin029bcbd2011-07-22 11:35:23 -07001086 * returns the size of an object in the image
1087 */
1088static u64 rbd_obj_bytes(struct rbd_image_header *header)
1089{
1090 return 1 << header->obj_order;
1091}
1092
1093/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001094 * bio helpers
1095 */
1096
1097static void bio_chain_put(struct bio *chain)
1098{
1099 struct bio *tmp;
1100
1101 while (chain) {
1102 tmp = chain;
1103 chain = chain->bi_next;
1104 bio_put(tmp);
1105 }
1106}
1107
1108/*
1109 * zeros a bio chain, starting at specific offset
1110 */
1111static void zero_bio_chain(struct bio *chain, int start_ofs)
1112{
1113 struct bio_vec *bv;
1114 unsigned long flags;
1115 void *buf;
1116 int i;
1117 int pos = 0;
1118
1119 while (chain) {
1120 bio_for_each_segment(bv, chain, i) {
1121 if (pos + bv->bv_len > start_ofs) {
1122 int remainder = max(start_ofs - pos, 0);
1123 buf = bvec_kmap_irq(bv, &flags);
1124 memset(buf + remainder, 0,
1125 bv->bv_len - remainder);
Dan Carpenter85b5aaa2010-10-11 21:15:11 +02001126 bvec_kunmap_irq(buf, &flags);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001127 }
1128 pos += bv->bv_len;
1129 }
1130
1131 chain = chain->bi_next;
1132 }
1133}
1134
1135/*
Alex Elderb9434c52013-04-19 15:34:50 -05001136 * similar to zero_bio_chain(), zeros data defined by a page array,
1137 * starting at the given byte offset from the start of the array and
1138 * continuing up to the given end offset. The pages array is
1139 * assumed to be big enough to hold all bytes up to the end.
1140 */
1141static void zero_pages(struct page **pages, u64 offset, u64 end)
1142{
1143 struct page **page = &pages[offset >> PAGE_SHIFT];
1144
1145 rbd_assert(end > offset);
1146 rbd_assert(end - offset <= (u64)SIZE_MAX);
1147 while (offset < end) {
1148 size_t page_offset;
1149 size_t length;
1150 unsigned long flags;
1151 void *kaddr;
1152
1153 page_offset = (size_t)(offset & ~PAGE_MASK);
1154 length = min(PAGE_SIZE - page_offset, (size_t)(end - offset));
1155 local_irq_save(flags);
1156 kaddr = kmap_atomic(*page);
1157 memset(kaddr + page_offset, 0, length);
1158 kunmap_atomic(kaddr);
1159 local_irq_restore(flags);
1160
1161 offset += length;
1162 page++;
1163 }
1164}
1165
1166/*
Alex Elderf7760da2012-10-20 22:17:27 -05001167 * Clone a portion of a bio, starting at the given byte offset
1168 * and continuing for the number of bytes indicated.
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001169 */
Alex Elderf7760da2012-10-20 22:17:27 -05001170static struct bio *bio_clone_range(struct bio *bio_src,
1171 unsigned int offset,
1172 unsigned int len,
1173 gfp_t gfpmask)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001174{
Alex Elderf7760da2012-10-20 22:17:27 -05001175 struct bio_vec *bv;
1176 unsigned int resid;
1177 unsigned short idx;
1178 unsigned int voff;
1179 unsigned short end_idx;
1180 unsigned short vcnt;
1181 struct bio *bio;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001182
Alex Elderf7760da2012-10-20 22:17:27 -05001183 /* Handle the easy case for the caller */
1184
1185 if (!offset && len == bio_src->bi_size)
1186 return bio_clone(bio_src, gfpmask);
1187
1188 if (WARN_ON_ONCE(!len))
1189 return NULL;
1190 if (WARN_ON_ONCE(len > bio_src->bi_size))
1191 return NULL;
1192 if (WARN_ON_ONCE(offset > bio_src->bi_size - len))
1193 return NULL;
1194
1195 /* Find first affected segment... */
1196
1197 resid = offset;
1198 __bio_for_each_segment(bv, bio_src, idx, 0) {
1199 if (resid < bv->bv_len)
1200 break;
1201 resid -= bv->bv_len;
1202 }
1203 voff = resid;
1204
1205 /* ...and the last affected segment */
1206
1207 resid += len;
1208 __bio_for_each_segment(bv, bio_src, end_idx, idx) {
1209 if (resid <= bv->bv_len)
1210 break;
1211 resid -= bv->bv_len;
1212 }
1213 vcnt = end_idx - idx + 1;
1214
1215 /* Build the clone */
1216
1217 bio = bio_alloc(gfpmask, (unsigned int) vcnt);
1218 if (!bio)
1219 return NULL; /* ENOMEM */
1220
1221 bio->bi_bdev = bio_src->bi_bdev;
1222 bio->bi_sector = bio_src->bi_sector + (offset >> SECTOR_SHIFT);
1223 bio->bi_rw = bio_src->bi_rw;
1224 bio->bi_flags |= 1 << BIO_CLONED;
1225
1226 /*
1227 * Copy over our part of the bio_vec, then update the first
1228 * and last (or only) entries.
1229 */
1230 memcpy(&bio->bi_io_vec[0], &bio_src->bi_io_vec[idx],
1231 vcnt * sizeof (struct bio_vec));
1232 bio->bi_io_vec[0].bv_offset += voff;
1233 if (vcnt > 1) {
1234 bio->bi_io_vec[0].bv_len -= voff;
1235 bio->bi_io_vec[vcnt - 1].bv_len = resid;
1236 } else {
1237 bio->bi_io_vec[0].bv_len = len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001238 }
1239
Alex Elderf7760da2012-10-20 22:17:27 -05001240 bio->bi_vcnt = vcnt;
1241 bio->bi_size = len;
1242 bio->bi_idx = 0;
Alex Elder542582f2012-08-09 10:33:25 -07001243
Alex Elderf7760da2012-10-20 22:17:27 -05001244 return bio;
1245}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001246
Alex Elderf7760da2012-10-20 22:17:27 -05001247/*
1248 * Clone a portion of a bio chain, starting at the given byte offset
1249 * into the first bio in the source chain and continuing for the
1250 * number of bytes indicated. The result is another bio chain of
1251 * exactly the given length, or a null pointer on error.
1252 *
1253 * The bio_src and offset parameters are both in-out. On entry they
1254 * refer to the first source bio and the offset into that bio where
1255 * the start of data to be cloned is located.
1256 *
1257 * On return, bio_src is updated to refer to the bio in the source
1258 * chain that contains first un-cloned byte, and *offset will
1259 * contain the offset of that byte within that bio.
1260 */
1261static struct bio *bio_chain_clone_range(struct bio **bio_src,
1262 unsigned int *offset,
1263 unsigned int len,
1264 gfp_t gfpmask)
1265{
1266 struct bio *bi = *bio_src;
1267 unsigned int off = *offset;
1268 struct bio *chain = NULL;
1269 struct bio **end;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001270
Alex Elderf7760da2012-10-20 22:17:27 -05001271 /* Build up a chain of clone bios up to the limit */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001272
Alex Elderf7760da2012-10-20 22:17:27 -05001273 if (!bi || off >= bi->bi_size || !len)
1274 return NULL; /* Nothing to clone */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001275
Alex Elderf7760da2012-10-20 22:17:27 -05001276 end = &chain;
1277 while (len) {
1278 unsigned int bi_size;
1279 struct bio *bio;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001280
Alex Elderf5400b72012-11-01 10:17:15 -05001281 if (!bi) {
1282 rbd_warn(NULL, "bio_chain exhausted with %u left", len);
Alex Elderf7760da2012-10-20 22:17:27 -05001283 goto out_err; /* EINVAL; ran out of bio's */
Alex Elderf5400b72012-11-01 10:17:15 -05001284 }
Alex Elderf7760da2012-10-20 22:17:27 -05001285 bi_size = min_t(unsigned int, bi->bi_size - off, len);
1286 bio = bio_clone_range(bi, off, bi_size, gfpmask);
1287 if (!bio)
1288 goto out_err; /* ENOMEM */
1289
1290 *end = bio;
1291 end = &bio->bi_next;
1292
1293 off += bi_size;
1294 if (off == bi->bi_size) {
1295 bi = bi->bi_next;
1296 off = 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001297 }
Alex Elderf7760da2012-10-20 22:17:27 -05001298 len -= bi_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001299 }
Alex Elderf7760da2012-10-20 22:17:27 -05001300 *bio_src = bi;
1301 *offset = off;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001302
Alex Elderf7760da2012-10-20 22:17:27 -05001303 return chain;
1304out_err:
1305 bio_chain_put(chain);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001306
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001307 return NULL;
1308}
1309
Alex Elder926f9b32013-02-11 12:33:24 -06001310/*
1311 * The default/initial value for all object request flags is 0. For
1312 * each flag, once its value is set to 1 it is never reset to 0
1313 * again.
1314 */
Alex Elder6365d332013-02-11 12:33:24 -06001315static void obj_request_img_data_set(struct rbd_obj_request *obj_request)
1316{
1317 if (test_and_set_bit(OBJ_REQ_IMG_DATA, &obj_request->flags)) {
Alex Elder6365d332013-02-11 12:33:24 -06001318 struct rbd_device *rbd_dev;
1319
Alex Elder57acbaa2013-02-11 12:33:24 -06001320 rbd_dev = obj_request->img_request->rbd_dev;
Alex Elder6365d332013-02-11 12:33:24 -06001321 rbd_warn(rbd_dev, "obj_request %p already marked img_data\n",
1322 obj_request);
1323 }
1324}
1325
1326static bool obj_request_img_data_test(struct rbd_obj_request *obj_request)
1327{
1328 smp_mb();
1329 return test_bit(OBJ_REQ_IMG_DATA, &obj_request->flags) != 0;
1330}
1331
Alex Elder57acbaa2013-02-11 12:33:24 -06001332static void obj_request_done_set(struct rbd_obj_request *obj_request)
1333{
1334 if (test_and_set_bit(OBJ_REQ_DONE, &obj_request->flags)) {
1335 struct rbd_device *rbd_dev = NULL;
1336
1337 if (obj_request_img_data_test(obj_request))
1338 rbd_dev = obj_request->img_request->rbd_dev;
1339 rbd_warn(rbd_dev, "obj_request %p already marked done\n",
1340 obj_request);
1341 }
1342}
1343
1344static bool obj_request_done_test(struct rbd_obj_request *obj_request)
1345{
1346 smp_mb();
1347 return test_bit(OBJ_REQ_DONE, &obj_request->flags) != 0;
1348}
1349
Alex Elder5679c592013-02-11 12:33:24 -06001350/*
1351 * This sets the KNOWN flag after (possibly) setting the EXISTS
1352 * flag. The latter is set based on the "exists" value provided.
1353 *
1354 * Note that for our purposes once an object exists it never goes
1355 * away again. It's possible that the response from two existence
1356 * checks are separated by the creation of the target object, and
1357 * the first ("doesn't exist") response arrives *after* the second
1358 * ("does exist"). In that case we ignore the second one.
1359 */
1360static void obj_request_existence_set(struct rbd_obj_request *obj_request,
1361 bool exists)
1362{
1363 if (exists)
1364 set_bit(OBJ_REQ_EXISTS, &obj_request->flags);
1365 set_bit(OBJ_REQ_KNOWN, &obj_request->flags);
1366 smp_mb();
1367}
1368
1369static bool obj_request_known_test(struct rbd_obj_request *obj_request)
1370{
1371 smp_mb();
1372 return test_bit(OBJ_REQ_KNOWN, &obj_request->flags) != 0;
1373}
1374
1375static bool obj_request_exists_test(struct rbd_obj_request *obj_request)
1376{
1377 smp_mb();
1378 return test_bit(OBJ_REQ_EXISTS, &obj_request->flags) != 0;
1379}
1380
Alex Elderbf0d5f502012-11-22 00:00:08 -06001381static void rbd_obj_request_get(struct rbd_obj_request *obj_request)
1382{
Alex Elder37206ee2013-02-20 17:32:08 -06001383 dout("%s: obj %p (was %d)\n", __func__, obj_request,
1384 atomic_read(&obj_request->kref.refcount));
Alex Elderbf0d5f502012-11-22 00:00:08 -06001385 kref_get(&obj_request->kref);
1386}
1387
1388static void rbd_obj_request_destroy(struct kref *kref);
1389static void rbd_obj_request_put(struct rbd_obj_request *obj_request)
1390{
1391 rbd_assert(obj_request != NULL);
Alex Elder37206ee2013-02-20 17:32:08 -06001392 dout("%s: obj %p (was %d)\n", __func__, obj_request,
1393 atomic_read(&obj_request->kref.refcount));
Alex Elderbf0d5f502012-11-22 00:00:08 -06001394 kref_put(&obj_request->kref, rbd_obj_request_destroy);
1395}
1396
Alex Eldere93f3152013-05-08 22:50:04 -05001397static bool img_request_child_test(struct rbd_img_request *img_request);
1398static void rbd_parent_request_destroy(struct kref *kref);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001399static void rbd_img_request_destroy(struct kref *kref);
1400static void rbd_img_request_put(struct rbd_img_request *img_request)
1401{
1402 rbd_assert(img_request != NULL);
Alex Elder37206ee2013-02-20 17:32:08 -06001403 dout("%s: img %p (was %d)\n", __func__, img_request,
1404 atomic_read(&img_request->kref.refcount));
Alex Eldere93f3152013-05-08 22:50:04 -05001405 if (img_request_child_test(img_request))
1406 kref_put(&img_request->kref, rbd_parent_request_destroy);
1407 else
1408 kref_put(&img_request->kref, rbd_img_request_destroy);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001409}
1410
1411static inline void rbd_img_obj_request_add(struct rbd_img_request *img_request,
1412 struct rbd_obj_request *obj_request)
1413{
Alex Elder25dcf952013-01-25 17:08:55 -06001414 rbd_assert(obj_request->img_request == NULL);
1415
Alex Elderb155e862013-04-15 14:50:37 -05001416 /* Image request now owns object's original reference */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001417 obj_request->img_request = img_request;
Alex Elder25dcf952013-01-25 17:08:55 -06001418 obj_request->which = img_request->obj_request_count;
Alex Elder6365d332013-02-11 12:33:24 -06001419 rbd_assert(!obj_request_img_data_test(obj_request));
1420 obj_request_img_data_set(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001421 rbd_assert(obj_request->which != BAD_WHICH);
Alex Elder25dcf952013-01-25 17:08:55 -06001422 img_request->obj_request_count++;
1423 list_add_tail(&obj_request->links, &img_request->obj_requests);
Alex Elder37206ee2013-02-20 17:32:08 -06001424 dout("%s: img %p obj %p w=%u\n", __func__, img_request, obj_request,
1425 obj_request->which);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001426}
1427
1428static inline void rbd_img_obj_request_del(struct rbd_img_request *img_request,
1429 struct rbd_obj_request *obj_request)
1430{
1431 rbd_assert(obj_request->which != BAD_WHICH);
Alex Elder25dcf952013-01-25 17:08:55 -06001432
Alex Elder37206ee2013-02-20 17:32:08 -06001433 dout("%s: img %p obj %p w=%u\n", __func__, img_request, obj_request,
1434 obj_request->which);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001435 list_del(&obj_request->links);
Alex Elder25dcf952013-01-25 17:08:55 -06001436 rbd_assert(img_request->obj_request_count > 0);
1437 img_request->obj_request_count--;
1438 rbd_assert(obj_request->which == img_request->obj_request_count);
1439 obj_request->which = BAD_WHICH;
Alex Elder6365d332013-02-11 12:33:24 -06001440 rbd_assert(obj_request_img_data_test(obj_request));
Alex Elderbf0d5f502012-11-22 00:00:08 -06001441 rbd_assert(obj_request->img_request == img_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001442 obj_request->img_request = NULL;
Alex Elder25dcf952013-01-25 17:08:55 -06001443 obj_request->callback = NULL;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001444 rbd_obj_request_put(obj_request);
1445}
1446
1447static bool obj_request_type_valid(enum obj_request_type type)
1448{
1449 switch (type) {
Alex Elder9969ebc2013-01-18 12:31:10 -06001450 case OBJ_REQUEST_NODATA:
Alex Elderbf0d5f502012-11-22 00:00:08 -06001451 case OBJ_REQUEST_BIO:
Alex Elder788e2df2013-01-17 12:25:27 -06001452 case OBJ_REQUEST_PAGES:
Alex Elderbf0d5f502012-11-22 00:00:08 -06001453 return true;
1454 default:
1455 return false;
1456 }
1457}
1458
Alex Elderbf0d5f502012-11-22 00:00:08 -06001459static int rbd_obj_request_submit(struct ceph_osd_client *osdc,
1460 struct rbd_obj_request *obj_request)
1461{
Alex Elder37206ee2013-02-20 17:32:08 -06001462 dout("%s: osdc %p obj %p\n", __func__, osdc, obj_request);
1463
Alex Elderbf0d5f502012-11-22 00:00:08 -06001464 return ceph_osdc_start_request(osdc, obj_request->osd_req, false);
1465}
1466
1467static void rbd_img_request_complete(struct rbd_img_request *img_request)
1468{
Alex Elder55f27e02013-04-10 12:34:25 -05001469
Alex Elder37206ee2013-02-20 17:32:08 -06001470 dout("%s: img %p\n", __func__, img_request);
Alex Elder55f27e02013-04-10 12:34:25 -05001471
1472 /*
1473 * If no error occurred, compute the aggregate transfer
1474 * count for the image request. We could instead use
1475 * atomic64_cmpxchg() to update it as each object request
1476 * completes; not clear which way is better off hand.
1477 */
1478 if (!img_request->result) {
1479 struct rbd_obj_request *obj_request;
1480 u64 xferred = 0;
1481
1482 for_each_obj_request(img_request, obj_request)
1483 xferred += obj_request->xferred;
1484 img_request->xferred = xferred;
1485 }
1486
Alex Elderbf0d5f502012-11-22 00:00:08 -06001487 if (img_request->callback)
1488 img_request->callback(img_request);
1489 else
1490 rbd_img_request_put(img_request);
1491}
1492
Alex Elder788e2df2013-01-17 12:25:27 -06001493/* Caller is responsible for rbd_obj_request_destroy(obj_request) */
1494
1495static int rbd_obj_request_wait(struct rbd_obj_request *obj_request)
1496{
Alex Elder37206ee2013-02-20 17:32:08 -06001497 dout("%s: obj %p\n", __func__, obj_request);
1498
Alex Elder788e2df2013-01-17 12:25:27 -06001499 return wait_for_completion_interruptible(&obj_request->completion);
1500}
1501
Alex Elder0c425242013-02-08 09:55:49 -06001502/*
1503 * The default/initial value for all image request flags is 0. Each
1504 * is conditionally set to 1 at image request initialization time
1505 * and currently never change thereafter.
1506 */
1507static void img_request_write_set(struct rbd_img_request *img_request)
1508{
1509 set_bit(IMG_REQ_WRITE, &img_request->flags);
1510 smp_mb();
1511}
1512
1513static bool img_request_write_test(struct rbd_img_request *img_request)
1514{
1515 smp_mb();
1516 return test_bit(IMG_REQ_WRITE, &img_request->flags) != 0;
1517}
1518
Alex Elder9849e982013-01-24 16:13:36 -06001519static void img_request_child_set(struct rbd_img_request *img_request)
1520{
1521 set_bit(IMG_REQ_CHILD, &img_request->flags);
1522 smp_mb();
1523}
1524
Alex Eldere93f3152013-05-08 22:50:04 -05001525static void img_request_child_clear(struct rbd_img_request *img_request)
1526{
1527 clear_bit(IMG_REQ_CHILD, &img_request->flags);
1528 smp_mb();
1529}
1530
Alex Elder9849e982013-01-24 16:13:36 -06001531static bool img_request_child_test(struct rbd_img_request *img_request)
1532{
1533 smp_mb();
1534 return test_bit(IMG_REQ_CHILD, &img_request->flags) != 0;
1535}
1536
Alex Elderd0b2e942013-01-24 16:13:36 -06001537static void img_request_layered_set(struct rbd_img_request *img_request)
1538{
1539 set_bit(IMG_REQ_LAYERED, &img_request->flags);
1540 smp_mb();
1541}
1542
Alex Eldera2acd002013-05-08 22:50:04 -05001543static void img_request_layered_clear(struct rbd_img_request *img_request)
1544{
1545 clear_bit(IMG_REQ_LAYERED, &img_request->flags);
1546 smp_mb();
1547}
1548
Alex Elderd0b2e942013-01-24 16:13:36 -06001549static bool img_request_layered_test(struct rbd_img_request *img_request)
1550{
1551 smp_mb();
1552 return test_bit(IMG_REQ_LAYERED, &img_request->flags) != 0;
1553}
1554
Alex Elder6e2a4502013-03-27 09:16:30 -05001555static void
1556rbd_img_obj_request_read_callback(struct rbd_obj_request *obj_request)
1557{
Alex Elderb9434c52013-04-19 15:34:50 -05001558 u64 xferred = obj_request->xferred;
1559 u64 length = obj_request->length;
1560
Alex Elder6e2a4502013-03-27 09:16:30 -05001561 dout("%s: obj %p img %p result %d %llu/%llu\n", __func__,
1562 obj_request, obj_request->img_request, obj_request->result,
Alex Elderb9434c52013-04-19 15:34:50 -05001563 xferred, length);
Alex Elder6e2a4502013-03-27 09:16:30 -05001564 /*
1565 * ENOENT means a hole in the image. We zero-fill the
1566 * entire length of the request. A short read also implies
1567 * zero-fill to the end of the request. Either way we
1568 * update the xferred count to indicate the whole request
1569 * was satisfied.
1570 */
Alex Elderb9434c52013-04-19 15:34:50 -05001571 rbd_assert(obj_request->type != OBJ_REQUEST_NODATA);
Alex Elder6e2a4502013-03-27 09:16:30 -05001572 if (obj_request->result == -ENOENT) {
Alex Elderb9434c52013-04-19 15:34:50 -05001573 if (obj_request->type == OBJ_REQUEST_BIO)
1574 zero_bio_chain(obj_request->bio_list, 0);
1575 else
1576 zero_pages(obj_request->pages, 0, length);
Alex Elder6e2a4502013-03-27 09:16:30 -05001577 obj_request->result = 0;
Alex Elderb9434c52013-04-19 15:34:50 -05001578 obj_request->xferred = length;
1579 } else if (xferred < length && !obj_request->result) {
1580 if (obj_request->type == OBJ_REQUEST_BIO)
1581 zero_bio_chain(obj_request->bio_list, xferred);
1582 else
1583 zero_pages(obj_request->pages, xferred, length);
1584 obj_request->xferred = length;
Alex Elder6e2a4502013-03-27 09:16:30 -05001585 }
1586 obj_request_done_set(obj_request);
1587}
1588
Alex Elderbf0d5f502012-11-22 00:00:08 -06001589static void rbd_obj_request_complete(struct rbd_obj_request *obj_request)
1590{
Alex Elder37206ee2013-02-20 17:32:08 -06001591 dout("%s: obj %p cb %p\n", __func__, obj_request,
1592 obj_request->callback);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001593 if (obj_request->callback)
1594 obj_request->callback(obj_request);
Alex Elder788e2df2013-01-17 12:25:27 -06001595 else
1596 complete_all(&obj_request->completion);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001597}
1598
Alex Elderc47f9372013-02-26 14:23:07 -06001599static void rbd_osd_trivial_callback(struct rbd_obj_request *obj_request)
Alex Elder39bf2c52013-02-26 14:23:07 -06001600{
1601 dout("%s: obj %p\n", __func__, obj_request);
1602 obj_request_done_set(obj_request);
1603}
1604
Alex Elderc47f9372013-02-26 14:23:07 -06001605static void rbd_osd_read_callback(struct rbd_obj_request *obj_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001606{
Alex Elder57acbaa2013-02-11 12:33:24 -06001607 struct rbd_img_request *img_request = NULL;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05001608 struct rbd_device *rbd_dev = NULL;
Alex Elder57acbaa2013-02-11 12:33:24 -06001609 bool layered = false;
1610
1611 if (obj_request_img_data_test(obj_request)) {
1612 img_request = obj_request->img_request;
1613 layered = img_request && img_request_layered_test(img_request);
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05001614 rbd_dev = img_request->rbd_dev;
Alex Elder57acbaa2013-02-11 12:33:24 -06001615 }
Alex Elder8b3e1a52013-01-24 16:13:36 -06001616
1617 dout("%s: obj %p img %p result %d %llu/%llu\n", __func__,
1618 obj_request, img_request, obj_request->result,
1619 obj_request->xferred, obj_request->length);
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05001620 if (layered && obj_request->result == -ENOENT &&
1621 obj_request->img_offset < rbd_dev->parent_overlap)
Alex Elder8b3e1a52013-01-24 16:13:36 -06001622 rbd_img_parent_read(obj_request);
1623 else if (img_request)
Alex Elder6e2a4502013-03-27 09:16:30 -05001624 rbd_img_obj_request_read_callback(obj_request);
1625 else
1626 obj_request_done_set(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001627}
1628
Alex Elderc47f9372013-02-26 14:23:07 -06001629static void rbd_osd_write_callback(struct rbd_obj_request *obj_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001630{
Sage Weil1b83bef2013-02-25 16:11:12 -08001631 dout("%s: obj %p result %d %llu\n", __func__, obj_request,
1632 obj_request->result, obj_request->length);
1633 /*
Alex Elder8b3e1a52013-01-24 16:13:36 -06001634 * There is no such thing as a successful short write. Set
1635 * it to our originally-requested length.
Sage Weil1b83bef2013-02-25 16:11:12 -08001636 */
1637 obj_request->xferred = obj_request->length;
Alex Elder07741302013-02-05 23:41:50 -06001638 obj_request_done_set(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001639}
1640
Alex Elderfbfab532013-02-08 09:55:48 -06001641/*
1642 * For a simple stat call there's nothing to do. We'll do more if
1643 * this is part of a write sequence for a layered image.
1644 */
Alex Elderc47f9372013-02-26 14:23:07 -06001645static void rbd_osd_stat_callback(struct rbd_obj_request *obj_request)
Alex Elderfbfab532013-02-08 09:55:48 -06001646{
Alex Elder37206ee2013-02-20 17:32:08 -06001647 dout("%s: obj %p\n", __func__, obj_request);
Alex Elderfbfab532013-02-08 09:55:48 -06001648 obj_request_done_set(obj_request);
1649}
1650
Alex Elderbf0d5f502012-11-22 00:00:08 -06001651static void rbd_osd_req_callback(struct ceph_osd_request *osd_req,
1652 struct ceph_msg *msg)
1653{
1654 struct rbd_obj_request *obj_request = osd_req->r_priv;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001655 u16 opcode;
1656
Alex Elder37206ee2013-02-20 17:32:08 -06001657 dout("%s: osd_req %p msg %p\n", __func__, osd_req, msg);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001658 rbd_assert(osd_req == obj_request->osd_req);
Alex Elder57acbaa2013-02-11 12:33:24 -06001659 if (obj_request_img_data_test(obj_request)) {
1660 rbd_assert(obj_request->img_request);
1661 rbd_assert(obj_request->which != BAD_WHICH);
1662 } else {
1663 rbd_assert(obj_request->which == BAD_WHICH);
1664 }
Alex Elderbf0d5f502012-11-22 00:00:08 -06001665
Sage Weil1b83bef2013-02-25 16:11:12 -08001666 if (osd_req->r_result < 0)
1667 obj_request->result = osd_req->r_result;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001668
Alex Elder0eefd472013-04-19 15:34:50 -05001669 BUG_ON(osd_req->r_num_ops > 2);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001670
Alex Elderc47f9372013-02-26 14:23:07 -06001671 /*
1672 * We support a 64-bit length, but ultimately it has to be
1673 * passed to blk_end_request(), which takes an unsigned int.
1674 */
Sage Weil1b83bef2013-02-25 16:11:12 -08001675 obj_request->xferred = osd_req->r_reply_op_len[0];
Alex Elder8b3e1a52013-01-24 16:13:36 -06001676 rbd_assert(obj_request->xferred < (u64)UINT_MAX);
Alex Elder79528732013-04-03 21:32:51 -05001677 opcode = osd_req->r_ops[0].op;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001678 switch (opcode) {
1679 case CEPH_OSD_OP_READ:
Alex Elderc47f9372013-02-26 14:23:07 -06001680 rbd_osd_read_callback(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001681 break;
1682 case CEPH_OSD_OP_WRITE:
Alex Elderc47f9372013-02-26 14:23:07 -06001683 rbd_osd_write_callback(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001684 break;
Alex Elderfbfab532013-02-08 09:55:48 -06001685 case CEPH_OSD_OP_STAT:
Alex Elderc47f9372013-02-26 14:23:07 -06001686 rbd_osd_stat_callback(obj_request);
Alex Elderfbfab532013-02-08 09:55:48 -06001687 break;
Alex Elder36be9a72013-01-19 00:30:28 -06001688 case CEPH_OSD_OP_CALL:
Alex Elderb8d70032012-11-30 17:53:04 -06001689 case CEPH_OSD_OP_NOTIFY_ACK:
Alex Elder9969ebc2013-01-18 12:31:10 -06001690 case CEPH_OSD_OP_WATCH:
Alex Elderc47f9372013-02-26 14:23:07 -06001691 rbd_osd_trivial_callback(obj_request);
Alex Elder9969ebc2013-01-18 12:31:10 -06001692 break;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001693 default:
1694 rbd_warn(NULL, "%s: unsupported op %hu\n",
1695 obj_request->object_name, (unsigned short) opcode);
1696 break;
1697 }
1698
Alex Elder07741302013-02-05 23:41:50 -06001699 if (obj_request_done_test(obj_request))
Alex Elderbf0d5f502012-11-22 00:00:08 -06001700 rbd_obj_request_complete(obj_request);
1701}
1702
Alex Elder9d4df012013-04-19 15:34:50 -05001703static void rbd_osd_req_format_read(struct rbd_obj_request *obj_request)
Alex Elder430c28c2013-04-03 21:32:51 -05001704{
1705 struct rbd_img_request *img_request = obj_request->img_request;
Alex Elder8c042b02013-04-03 01:28:58 -05001706 struct ceph_osd_request *osd_req = obj_request->osd_req;
Alex Elder9d4df012013-04-19 15:34:50 -05001707 u64 snap_id;
Alex Elder430c28c2013-04-03 21:32:51 -05001708
Alex Elder8c042b02013-04-03 01:28:58 -05001709 rbd_assert(osd_req != NULL);
Alex Elder430c28c2013-04-03 21:32:51 -05001710
Alex Elder9d4df012013-04-19 15:34:50 -05001711 snap_id = img_request ? img_request->snap_id : CEPH_NOSNAP;
Alex Elder8c042b02013-04-03 01:28:58 -05001712 ceph_osdc_build_request(osd_req, obj_request->offset,
Alex Elder9d4df012013-04-19 15:34:50 -05001713 NULL, snap_id, NULL);
1714}
1715
1716static void rbd_osd_req_format_write(struct rbd_obj_request *obj_request)
1717{
1718 struct rbd_img_request *img_request = obj_request->img_request;
1719 struct ceph_osd_request *osd_req = obj_request->osd_req;
1720 struct ceph_snap_context *snapc;
1721 struct timespec mtime = CURRENT_TIME;
1722
1723 rbd_assert(osd_req != NULL);
1724
1725 snapc = img_request ? img_request->snapc : NULL;
1726 ceph_osdc_build_request(osd_req, obj_request->offset,
1727 snapc, CEPH_NOSNAP, &mtime);
Alex Elder430c28c2013-04-03 21:32:51 -05001728}
1729
Alex Elderbf0d5f502012-11-22 00:00:08 -06001730static struct ceph_osd_request *rbd_osd_req_create(
1731 struct rbd_device *rbd_dev,
1732 bool write_request,
Alex Elder430c28c2013-04-03 21:32:51 -05001733 struct rbd_obj_request *obj_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001734{
Alex Elderbf0d5f502012-11-22 00:00:08 -06001735 struct ceph_snap_context *snapc = NULL;
1736 struct ceph_osd_client *osdc;
1737 struct ceph_osd_request *osd_req;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001738
Alex Elder6365d332013-02-11 12:33:24 -06001739 if (obj_request_img_data_test(obj_request)) {
1740 struct rbd_img_request *img_request = obj_request->img_request;
1741
Alex Elder0c425242013-02-08 09:55:49 -06001742 rbd_assert(write_request ==
1743 img_request_write_test(img_request));
1744 if (write_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001745 snapc = img_request->snapc;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001746 }
1747
1748 /* Allocate and initialize the request, for the single op */
1749
1750 osdc = &rbd_dev->rbd_client->client->osdc;
1751 osd_req = ceph_osdc_alloc_request(osdc, snapc, 1, false, GFP_ATOMIC);
1752 if (!osd_req)
1753 return NULL; /* ENOMEM */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001754
Alex Elder430c28c2013-04-03 21:32:51 -05001755 if (write_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001756 osd_req->r_flags = CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK;
Alex Elder430c28c2013-04-03 21:32:51 -05001757 else
Alex Elderbf0d5f502012-11-22 00:00:08 -06001758 osd_req->r_flags = CEPH_OSD_FLAG_READ;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001759
1760 osd_req->r_callback = rbd_osd_req_callback;
1761 osd_req->r_priv = obj_request;
1762
1763 osd_req->r_oid_len = strlen(obj_request->object_name);
1764 rbd_assert(osd_req->r_oid_len < sizeof (osd_req->r_oid));
1765 memcpy(osd_req->r_oid, obj_request->object_name, osd_req->r_oid_len);
1766
1767 osd_req->r_file_layout = rbd_dev->layout; /* struct */
1768
Alex Elderbf0d5f502012-11-22 00:00:08 -06001769 return osd_req;
1770}
1771
Alex Elder0eefd472013-04-19 15:34:50 -05001772/*
1773 * Create a copyup osd request based on the information in the
1774 * object request supplied. A copyup request has two osd ops,
1775 * a copyup method call, and a "normal" write request.
1776 */
1777static struct ceph_osd_request *
1778rbd_osd_req_create_copyup(struct rbd_obj_request *obj_request)
1779{
1780 struct rbd_img_request *img_request;
1781 struct ceph_snap_context *snapc;
1782 struct rbd_device *rbd_dev;
1783 struct ceph_osd_client *osdc;
1784 struct ceph_osd_request *osd_req;
1785
1786 rbd_assert(obj_request_img_data_test(obj_request));
1787 img_request = obj_request->img_request;
1788 rbd_assert(img_request);
1789 rbd_assert(img_request_write_test(img_request));
1790
1791 /* Allocate and initialize the request, for the two ops */
1792
1793 snapc = img_request->snapc;
1794 rbd_dev = img_request->rbd_dev;
1795 osdc = &rbd_dev->rbd_client->client->osdc;
1796 osd_req = ceph_osdc_alloc_request(osdc, snapc, 2, false, GFP_ATOMIC);
1797 if (!osd_req)
1798 return NULL; /* ENOMEM */
1799
1800 osd_req->r_flags = CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK;
1801 osd_req->r_callback = rbd_osd_req_callback;
1802 osd_req->r_priv = obj_request;
1803
1804 osd_req->r_oid_len = strlen(obj_request->object_name);
1805 rbd_assert(osd_req->r_oid_len < sizeof (osd_req->r_oid));
1806 memcpy(osd_req->r_oid, obj_request->object_name, osd_req->r_oid_len);
1807
1808 osd_req->r_file_layout = rbd_dev->layout; /* struct */
1809
1810 return osd_req;
1811}
1812
1813
Alex Elderbf0d5f502012-11-22 00:00:08 -06001814static void rbd_osd_req_destroy(struct ceph_osd_request *osd_req)
1815{
1816 ceph_osdc_put_request(osd_req);
1817}
1818
1819/* object_name is assumed to be a non-null pointer and NUL-terminated */
1820
1821static struct rbd_obj_request *rbd_obj_request_create(const char *object_name,
1822 u64 offset, u64 length,
1823 enum obj_request_type type)
1824{
1825 struct rbd_obj_request *obj_request;
1826 size_t size;
1827 char *name;
1828
1829 rbd_assert(obj_request_type_valid(type));
1830
1831 size = strlen(object_name) + 1;
Alex Elderf907ad52013-05-01 12:43:03 -05001832 name = kmalloc(size, GFP_KERNEL);
1833 if (!name)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001834 return NULL;
1835
Alex Elder868311b2013-05-01 12:43:03 -05001836 obj_request = kmem_cache_zalloc(rbd_obj_request_cache, GFP_KERNEL);
Alex Elderf907ad52013-05-01 12:43:03 -05001837 if (!obj_request) {
1838 kfree(name);
1839 return NULL;
1840 }
1841
Alex Elderbf0d5f502012-11-22 00:00:08 -06001842 obj_request->object_name = memcpy(name, object_name, size);
1843 obj_request->offset = offset;
1844 obj_request->length = length;
Alex Elder926f9b32013-02-11 12:33:24 -06001845 obj_request->flags = 0;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001846 obj_request->which = BAD_WHICH;
1847 obj_request->type = type;
1848 INIT_LIST_HEAD(&obj_request->links);
Alex Elder788e2df2013-01-17 12:25:27 -06001849 init_completion(&obj_request->completion);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001850 kref_init(&obj_request->kref);
1851
Alex Elder37206ee2013-02-20 17:32:08 -06001852 dout("%s: \"%s\" %llu/%llu %d -> obj %p\n", __func__, object_name,
1853 offset, length, (int)type, obj_request);
1854
Alex Elderbf0d5f502012-11-22 00:00:08 -06001855 return obj_request;
1856}
1857
1858static void rbd_obj_request_destroy(struct kref *kref)
1859{
1860 struct rbd_obj_request *obj_request;
1861
1862 obj_request = container_of(kref, struct rbd_obj_request, kref);
1863
Alex Elder37206ee2013-02-20 17:32:08 -06001864 dout("%s: obj %p\n", __func__, obj_request);
1865
Alex Elderbf0d5f502012-11-22 00:00:08 -06001866 rbd_assert(obj_request->img_request == NULL);
1867 rbd_assert(obj_request->which == BAD_WHICH);
1868
1869 if (obj_request->osd_req)
1870 rbd_osd_req_destroy(obj_request->osd_req);
1871
1872 rbd_assert(obj_request_type_valid(obj_request->type));
1873 switch (obj_request->type) {
Alex Elder9969ebc2013-01-18 12:31:10 -06001874 case OBJ_REQUEST_NODATA:
1875 break; /* Nothing to do */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001876 case OBJ_REQUEST_BIO:
1877 if (obj_request->bio_list)
1878 bio_chain_put(obj_request->bio_list);
1879 break;
Alex Elder788e2df2013-01-17 12:25:27 -06001880 case OBJ_REQUEST_PAGES:
1881 if (obj_request->pages)
1882 ceph_release_page_vector(obj_request->pages,
1883 obj_request->page_count);
1884 break;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001885 }
1886
Alex Elderf907ad52013-05-01 12:43:03 -05001887 kfree(obj_request->object_name);
Alex Elder868311b2013-05-01 12:43:03 -05001888 obj_request->object_name = NULL;
1889 kmem_cache_free(rbd_obj_request_cache, obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001890}
1891
Alex Elderfb65d2282013-05-08 22:50:04 -05001892/* It's OK to call this for a device with no parent */
1893
1894static void rbd_spec_put(struct rbd_spec *spec);
1895static void rbd_dev_unparent(struct rbd_device *rbd_dev)
1896{
1897 rbd_dev_remove_parent(rbd_dev);
1898 rbd_spec_put(rbd_dev->parent_spec);
1899 rbd_dev->parent_spec = NULL;
1900 rbd_dev->parent_overlap = 0;
1901}
1902
Alex Elderbf0d5f502012-11-22 00:00:08 -06001903/*
Alex Eldera2acd002013-05-08 22:50:04 -05001904 * Parent image reference counting is used to determine when an
1905 * image's parent fields can be safely torn down--after there are no
1906 * more in-flight requests to the parent image. When the last
1907 * reference is dropped, cleaning them up is safe.
1908 */
1909static void rbd_dev_parent_put(struct rbd_device *rbd_dev)
1910{
1911 int counter;
1912
1913 if (!rbd_dev->parent_spec)
1914 return;
1915
1916 counter = atomic_dec_return_safe(&rbd_dev->parent_ref);
1917 if (counter > 0)
1918 return;
1919
1920 /* Last reference; clean up parent data structures */
1921
1922 if (!counter)
1923 rbd_dev_unparent(rbd_dev);
1924 else
1925 rbd_warn(rbd_dev, "parent reference underflow\n");
1926}
1927
1928/*
1929 * If an image has a non-zero parent overlap, get a reference to its
1930 * parent.
1931 *
1932 * Returns true if the rbd device has a parent with a non-zero
1933 * overlap and a reference for it was successfully taken, or
1934 * false otherwise.
1935 */
1936static bool rbd_dev_parent_get(struct rbd_device *rbd_dev)
1937{
1938 int counter;
1939
1940 if (!rbd_dev->parent_spec)
1941 return false;
1942
1943 counter = atomic_inc_return_safe(&rbd_dev->parent_ref);
1944 if (counter > 0 && rbd_dev->parent_overlap)
1945 return true;
1946
1947 /* Image was flattened, but parent is not yet torn down */
1948
1949 if (counter < 0)
1950 rbd_warn(rbd_dev, "parent reference overflow\n");
1951
1952 return false;
1953}
1954
1955/*
Alex Elderbf0d5f502012-11-22 00:00:08 -06001956 * Caller is responsible for filling in the list of object requests
1957 * that comprises the image request, and the Linux request pointer
1958 * (if there is one).
1959 */
Alex Eldercc344fa2013-02-19 12:25:56 -06001960static struct rbd_img_request *rbd_img_request_create(
1961 struct rbd_device *rbd_dev,
Alex Elderbf0d5f502012-11-22 00:00:08 -06001962 u64 offset, u64 length,
Alex Eldere93f3152013-05-08 22:50:04 -05001963 bool write_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001964{
1965 struct rbd_img_request *img_request;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001966
Alex Elder1c2a9df2013-05-01 12:43:03 -05001967 img_request = kmem_cache_alloc(rbd_img_request_cache, GFP_ATOMIC);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001968 if (!img_request)
1969 return NULL;
1970
1971 if (write_request) {
1972 down_read(&rbd_dev->header_rwsem);
Alex Elder812164f82013-04-30 00:44:32 -05001973 ceph_get_snap_context(rbd_dev->header.snapc);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001974 up_read(&rbd_dev->header_rwsem);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001975 }
1976
1977 img_request->rq = NULL;
1978 img_request->rbd_dev = rbd_dev;
1979 img_request->offset = offset;
1980 img_request->length = length;
Alex Elder0c425242013-02-08 09:55:49 -06001981 img_request->flags = 0;
1982 if (write_request) {
1983 img_request_write_set(img_request);
Alex Elder468521c2013-04-26 09:43:47 -05001984 img_request->snapc = rbd_dev->header.snapc;
Alex Elder0c425242013-02-08 09:55:49 -06001985 } else {
Alex Elderbf0d5f502012-11-22 00:00:08 -06001986 img_request->snap_id = rbd_dev->spec->snap_id;
Alex Elder0c425242013-02-08 09:55:49 -06001987 }
Alex Eldera2acd002013-05-08 22:50:04 -05001988 if (rbd_dev_parent_get(rbd_dev))
Alex Elderd0b2e942013-01-24 16:13:36 -06001989 img_request_layered_set(img_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001990 spin_lock_init(&img_request->completion_lock);
1991 img_request->next_completion = 0;
1992 img_request->callback = NULL;
Alex Eldera5a337d2013-01-24 16:13:36 -06001993 img_request->result = 0;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001994 img_request->obj_request_count = 0;
1995 INIT_LIST_HEAD(&img_request->obj_requests);
1996 kref_init(&img_request->kref);
1997
Alex Elder37206ee2013-02-20 17:32:08 -06001998 dout("%s: rbd_dev %p %s %llu/%llu -> img %p\n", __func__, rbd_dev,
1999 write_request ? "write" : "read", offset, length,
2000 img_request);
2001
Alex Elderbf0d5f502012-11-22 00:00:08 -06002002 return img_request;
2003}
2004
2005static void rbd_img_request_destroy(struct kref *kref)
2006{
2007 struct rbd_img_request *img_request;
2008 struct rbd_obj_request *obj_request;
2009 struct rbd_obj_request *next_obj_request;
2010
2011 img_request = container_of(kref, struct rbd_img_request, kref);
2012
Alex Elder37206ee2013-02-20 17:32:08 -06002013 dout("%s: img %p\n", __func__, img_request);
2014
Alex Elderbf0d5f502012-11-22 00:00:08 -06002015 for_each_obj_request_safe(img_request, obj_request, next_obj_request)
2016 rbd_img_obj_request_del(img_request, obj_request);
Alex Elder25dcf952013-01-25 17:08:55 -06002017 rbd_assert(img_request->obj_request_count == 0);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002018
Alex Eldera2acd002013-05-08 22:50:04 -05002019 if (img_request_layered_test(img_request)) {
2020 img_request_layered_clear(img_request);
2021 rbd_dev_parent_put(img_request->rbd_dev);
2022 }
2023
Alex Elder0c425242013-02-08 09:55:49 -06002024 if (img_request_write_test(img_request))
Alex Elder812164f82013-04-30 00:44:32 -05002025 ceph_put_snap_context(img_request->snapc);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002026
Alex Elder1c2a9df2013-05-01 12:43:03 -05002027 kmem_cache_free(rbd_img_request_cache, img_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002028}
2029
Alex Eldere93f3152013-05-08 22:50:04 -05002030static struct rbd_img_request *rbd_parent_request_create(
2031 struct rbd_obj_request *obj_request,
2032 u64 img_offset, u64 length)
2033{
2034 struct rbd_img_request *parent_request;
2035 struct rbd_device *rbd_dev;
2036
2037 rbd_assert(obj_request->img_request);
2038 rbd_dev = obj_request->img_request->rbd_dev;
2039
2040 parent_request = rbd_img_request_create(rbd_dev->parent,
2041 img_offset, length, false);
2042 if (!parent_request)
2043 return NULL;
2044
2045 img_request_child_set(parent_request);
2046 rbd_obj_request_get(obj_request);
2047 parent_request->obj_request = obj_request;
2048
2049 return parent_request;
2050}
2051
2052static void rbd_parent_request_destroy(struct kref *kref)
2053{
2054 struct rbd_img_request *parent_request;
2055 struct rbd_obj_request *orig_request;
2056
2057 parent_request = container_of(kref, struct rbd_img_request, kref);
2058 orig_request = parent_request->obj_request;
2059
2060 parent_request->obj_request = NULL;
2061 rbd_obj_request_put(orig_request);
2062 img_request_child_clear(parent_request);
2063
2064 rbd_img_request_destroy(kref);
2065}
2066
Alex Elder12178572013-02-08 09:55:49 -06002067static bool rbd_img_obj_end_request(struct rbd_obj_request *obj_request)
2068{
Alex Elder6365d332013-02-11 12:33:24 -06002069 struct rbd_img_request *img_request;
Alex Elder12178572013-02-08 09:55:49 -06002070 unsigned int xferred;
2071 int result;
Alex Elder8b3e1a52013-01-24 16:13:36 -06002072 bool more;
Alex Elder12178572013-02-08 09:55:49 -06002073
Alex Elder6365d332013-02-11 12:33:24 -06002074 rbd_assert(obj_request_img_data_test(obj_request));
2075 img_request = obj_request->img_request;
2076
Alex Elder12178572013-02-08 09:55:49 -06002077 rbd_assert(obj_request->xferred <= (u64)UINT_MAX);
2078 xferred = (unsigned int)obj_request->xferred;
2079 result = obj_request->result;
2080 if (result) {
2081 struct rbd_device *rbd_dev = img_request->rbd_dev;
2082
2083 rbd_warn(rbd_dev, "%s %llx at %llx (%llx)\n",
2084 img_request_write_test(img_request) ? "write" : "read",
2085 obj_request->length, obj_request->img_offset,
2086 obj_request->offset);
2087 rbd_warn(rbd_dev, " result %d xferred %x\n",
2088 result, xferred);
2089 if (!img_request->result)
2090 img_request->result = result;
2091 }
2092
Alex Elderf1a47392013-04-19 15:34:50 -05002093 /* Image object requests don't own their page array */
2094
2095 if (obj_request->type == OBJ_REQUEST_PAGES) {
2096 obj_request->pages = NULL;
2097 obj_request->page_count = 0;
2098 }
2099
Alex Elder8b3e1a52013-01-24 16:13:36 -06002100 if (img_request_child_test(img_request)) {
2101 rbd_assert(img_request->obj_request != NULL);
2102 more = obj_request->which < img_request->obj_request_count - 1;
2103 } else {
2104 rbd_assert(img_request->rq != NULL);
2105 more = blk_end_request(img_request->rq, result, xferred);
2106 }
2107
2108 return more;
Alex Elder12178572013-02-08 09:55:49 -06002109}
2110
Alex Elder21692382013-04-05 01:27:12 -05002111static void rbd_img_obj_callback(struct rbd_obj_request *obj_request)
2112{
2113 struct rbd_img_request *img_request;
2114 u32 which = obj_request->which;
2115 bool more = true;
2116
Alex Elder6365d332013-02-11 12:33:24 -06002117 rbd_assert(obj_request_img_data_test(obj_request));
Alex Elder21692382013-04-05 01:27:12 -05002118 img_request = obj_request->img_request;
2119
2120 dout("%s: img %p obj %p\n", __func__, img_request, obj_request);
2121 rbd_assert(img_request != NULL);
Alex Elder21692382013-04-05 01:27:12 -05002122 rbd_assert(img_request->obj_request_count > 0);
2123 rbd_assert(which != BAD_WHICH);
2124 rbd_assert(which < img_request->obj_request_count);
2125 rbd_assert(which >= img_request->next_completion);
2126
2127 spin_lock_irq(&img_request->completion_lock);
2128 if (which != img_request->next_completion)
2129 goto out;
2130
2131 for_each_obj_request_from(img_request, obj_request) {
Alex Elder21692382013-04-05 01:27:12 -05002132 rbd_assert(more);
2133 rbd_assert(which < img_request->obj_request_count);
2134
2135 if (!obj_request_done_test(obj_request))
2136 break;
Alex Elder12178572013-02-08 09:55:49 -06002137 more = rbd_img_obj_end_request(obj_request);
Alex Elder21692382013-04-05 01:27:12 -05002138 which++;
2139 }
2140
2141 rbd_assert(more ^ (which == img_request->obj_request_count));
2142 img_request->next_completion = which;
2143out:
2144 spin_unlock_irq(&img_request->completion_lock);
2145
2146 if (!more)
2147 rbd_img_request_complete(img_request);
2148}
2149
Alex Elderf1a47392013-04-19 15:34:50 -05002150/*
2151 * Split up an image request into one or more object requests, each
2152 * to a different object. The "type" parameter indicates whether
2153 * "data_desc" is the pointer to the head of a list of bio
2154 * structures, or the base of a page array. In either case this
2155 * function assumes data_desc describes memory sufficient to hold
2156 * all data described by the image request.
2157 */
2158static int rbd_img_request_fill(struct rbd_img_request *img_request,
2159 enum obj_request_type type,
2160 void *data_desc)
Alex Elderbf0d5f502012-11-22 00:00:08 -06002161{
2162 struct rbd_device *rbd_dev = img_request->rbd_dev;
2163 struct rbd_obj_request *obj_request = NULL;
2164 struct rbd_obj_request *next_obj_request;
Alex Elder0c425242013-02-08 09:55:49 -06002165 bool write_request = img_request_write_test(img_request);
Alex Elderf1a47392013-04-19 15:34:50 -05002166 struct bio *bio_list;
2167 unsigned int bio_offset = 0;
2168 struct page **pages;
Alex Elder7da22d22013-01-24 16:13:36 -06002169 u64 img_offset;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002170 u64 resid;
2171 u16 opcode;
2172
Alex Elderf1a47392013-04-19 15:34:50 -05002173 dout("%s: img %p type %d data_desc %p\n", __func__, img_request,
2174 (int)type, data_desc);
Alex Elder37206ee2013-02-20 17:32:08 -06002175
Alex Elder430c28c2013-04-03 21:32:51 -05002176 opcode = write_request ? CEPH_OSD_OP_WRITE : CEPH_OSD_OP_READ;
Alex Elder7da22d22013-01-24 16:13:36 -06002177 img_offset = img_request->offset;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002178 resid = img_request->length;
Alex Elder4dda41d2013-02-20 21:59:33 -06002179 rbd_assert(resid > 0);
Alex Elderf1a47392013-04-19 15:34:50 -05002180
2181 if (type == OBJ_REQUEST_BIO) {
2182 bio_list = data_desc;
2183 rbd_assert(img_offset == bio_list->bi_sector << SECTOR_SHIFT);
2184 } else {
2185 rbd_assert(type == OBJ_REQUEST_PAGES);
2186 pages = data_desc;
2187 }
2188
Alex Elderbf0d5f502012-11-22 00:00:08 -06002189 while (resid) {
Alex Elder2fa12322013-04-05 01:27:12 -05002190 struct ceph_osd_request *osd_req;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002191 const char *object_name;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002192 u64 offset;
2193 u64 length;
2194
Alex Elder7da22d22013-01-24 16:13:36 -06002195 object_name = rbd_segment_name(rbd_dev, img_offset);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002196 if (!object_name)
2197 goto out_unwind;
Alex Elder7da22d22013-01-24 16:13:36 -06002198 offset = rbd_segment_offset(rbd_dev, img_offset);
2199 length = rbd_segment_length(rbd_dev, img_offset, resid);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002200 obj_request = rbd_obj_request_create(object_name,
Alex Elderf1a47392013-04-19 15:34:50 -05002201 offset, length, type);
Alex Elder78c2a442013-05-01 12:43:04 -05002202 /* object request has its own copy of the object name */
2203 rbd_segment_name_free(object_name);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002204 if (!obj_request)
2205 goto out_unwind;
2206
Alex Elderf1a47392013-04-19 15:34:50 -05002207 if (type == OBJ_REQUEST_BIO) {
2208 unsigned int clone_size;
2209
2210 rbd_assert(length <= (u64)UINT_MAX);
2211 clone_size = (unsigned int)length;
2212 obj_request->bio_list =
2213 bio_chain_clone_range(&bio_list,
2214 &bio_offset,
2215 clone_size,
2216 GFP_ATOMIC);
2217 if (!obj_request->bio_list)
2218 goto out_partial;
2219 } else {
2220 unsigned int page_count;
2221
2222 obj_request->pages = pages;
2223 page_count = (u32)calc_pages_for(offset, length);
2224 obj_request->page_count = page_count;
2225 if ((offset + length) & ~PAGE_MASK)
2226 page_count--; /* more on last page */
2227 pages += page_count;
2228 }
Alex Elderbf0d5f502012-11-22 00:00:08 -06002229
Alex Elder2fa12322013-04-05 01:27:12 -05002230 osd_req = rbd_osd_req_create(rbd_dev, write_request,
2231 obj_request);
2232 if (!osd_req)
Alex Elderbf0d5f502012-11-22 00:00:08 -06002233 goto out_partial;
Alex Elder2fa12322013-04-05 01:27:12 -05002234 obj_request->osd_req = osd_req;
Alex Elder21692382013-04-05 01:27:12 -05002235 obj_request->callback = rbd_img_obj_callback;
Alex Elder430c28c2013-04-03 21:32:51 -05002236
Alex Elder2fa12322013-04-05 01:27:12 -05002237 osd_req_op_extent_init(osd_req, 0, opcode, offset, length,
2238 0, 0);
Alex Elderf1a47392013-04-19 15:34:50 -05002239 if (type == OBJ_REQUEST_BIO)
2240 osd_req_op_extent_osd_data_bio(osd_req, 0,
2241 obj_request->bio_list, length);
2242 else
2243 osd_req_op_extent_osd_data_pages(osd_req, 0,
2244 obj_request->pages, length,
2245 offset & ~PAGE_MASK, false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05002246
2247 if (write_request)
2248 rbd_osd_req_format_write(obj_request);
2249 else
2250 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05002251
Alex Elder7da22d22013-01-24 16:13:36 -06002252 obj_request->img_offset = img_offset;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002253 rbd_img_obj_request_add(img_request, obj_request);
2254
Alex Elder7da22d22013-01-24 16:13:36 -06002255 img_offset += length;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002256 resid -= length;
2257 }
2258
2259 return 0;
2260
2261out_partial:
2262 rbd_obj_request_put(obj_request);
2263out_unwind:
2264 for_each_obj_request_safe(img_request, obj_request, next_obj_request)
2265 rbd_obj_request_put(obj_request);
2266
2267 return -ENOMEM;
2268}
2269
Alex Elder3d7efd12013-04-19 15:34:50 -05002270static void
Alex Elder0eefd472013-04-19 15:34:50 -05002271rbd_img_obj_copyup_callback(struct rbd_obj_request *obj_request)
2272{
2273 struct rbd_img_request *img_request;
2274 struct rbd_device *rbd_dev;
Alex Elderebda6402013-05-10 16:29:22 -05002275 struct page **pages;
Alex Elder0eefd472013-04-19 15:34:50 -05002276 u32 page_count;
2277
2278 rbd_assert(obj_request->type == OBJ_REQUEST_BIO);
2279 rbd_assert(obj_request_img_data_test(obj_request));
2280 img_request = obj_request->img_request;
2281 rbd_assert(img_request);
2282
2283 rbd_dev = img_request->rbd_dev;
2284 rbd_assert(rbd_dev);
Alex Elder0eefd472013-04-19 15:34:50 -05002285
Alex Elderebda6402013-05-10 16:29:22 -05002286 pages = obj_request->copyup_pages;
2287 rbd_assert(pages != NULL);
Alex Elder0eefd472013-04-19 15:34:50 -05002288 obj_request->copyup_pages = NULL;
Alex Elderebda6402013-05-10 16:29:22 -05002289 page_count = obj_request->copyup_page_count;
2290 rbd_assert(page_count);
2291 obj_request->copyup_page_count = 0;
2292 ceph_release_page_vector(pages, page_count);
Alex Elder0eefd472013-04-19 15:34:50 -05002293
2294 /*
2295 * We want the transfer count to reflect the size of the
2296 * original write request. There is no such thing as a
2297 * successful short write, so if the request was successful
2298 * we can just set it to the originally-requested length.
2299 */
2300 if (!obj_request->result)
2301 obj_request->xferred = obj_request->length;
2302
2303 /* Finish up with the normal image object callback */
2304
2305 rbd_img_obj_callback(obj_request);
2306}
2307
2308static void
Alex Elder3d7efd12013-04-19 15:34:50 -05002309rbd_img_obj_parent_read_full_callback(struct rbd_img_request *img_request)
2310{
2311 struct rbd_obj_request *orig_request;
Alex Elder0eefd472013-04-19 15:34:50 -05002312 struct ceph_osd_request *osd_req;
2313 struct ceph_osd_client *osdc;
2314 struct rbd_device *rbd_dev;
Alex Elder3d7efd12013-04-19 15:34:50 -05002315 struct page **pages;
Alex Elderebda6402013-05-10 16:29:22 -05002316 u32 page_count;
Alex Elder3d7efd12013-04-19 15:34:50 -05002317 int result;
Alex Elderebda6402013-05-10 16:29:22 -05002318 u64 parent_length;
Alex Elderb91f09f2013-05-10 16:29:22 -05002319 u64 offset;
2320 u64 length;
Alex Elder3d7efd12013-04-19 15:34:50 -05002321
2322 rbd_assert(img_request_child_test(img_request));
2323
2324 /* First get what we need from the image request */
2325
2326 pages = img_request->copyup_pages;
2327 rbd_assert(pages != NULL);
2328 img_request->copyup_pages = NULL;
Alex Elderebda6402013-05-10 16:29:22 -05002329 page_count = img_request->copyup_page_count;
2330 rbd_assert(page_count);
2331 img_request->copyup_page_count = 0;
Alex Elder3d7efd12013-04-19 15:34:50 -05002332
2333 orig_request = img_request->obj_request;
2334 rbd_assert(orig_request != NULL);
Alex Elderb91f09f2013-05-10 16:29:22 -05002335 rbd_assert(obj_request_type_valid(orig_request->type));
Alex Elder3d7efd12013-04-19 15:34:50 -05002336 result = img_request->result;
Alex Elderebda6402013-05-10 16:29:22 -05002337 parent_length = img_request->length;
2338 rbd_assert(parent_length == img_request->xferred);
Alex Elder91c6feb2013-05-06 17:40:32 -05002339 rbd_img_request_put(img_request);
Alex Elder3d7efd12013-04-19 15:34:50 -05002340
Alex Elder91c6feb2013-05-06 17:40:32 -05002341 rbd_assert(orig_request->img_request);
2342 rbd_dev = orig_request->img_request->rbd_dev;
Alex Elder0eefd472013-04-19 15:34:50 -05002343 rbd_assert(rbd_dev);
Alex Elder0eefd472013-04-19 15:34:50 -05002344
Alex Elder0eefd472013-04-19 15:34:50 -05002345 if (result)
2346 goto out_err;
Alex Elder3d7efd12013-04-19 15:34:50 -05002347
Alex Elder8785b1d2013-05-09 10:08:49 -05002348 /*
2349 * The original osd request is of no use to use any more.
2350 * We need a new one that can hold the two ops in a copyup
2351 * request. Allocate the new copyup osd request for the
2352 * original request, and release the old one.
2353 */
Alex Elder0eefd472013-04-19 15:34:50 -05002354 result = -ENOMEM;
Alex Elder0eefd472013-04-19 15:34:50 -05002355 osd_req = rbd_osd_req_create_copyup(orig_request);
2356 if (!osd_req)
2357 goto out_err;
Alex Elder8785b1d2013-05-09 10:08:49 -05002358 rbd_osd_req_destroy(orig_request->osd_req);
Alex Elder0eefd472013-04-19 15:34:50 -05002359 orig_request->osd_req = osd_req;
2360 orig_request->copyup_pages = pages;
Alex Elderebda6402013-05-10 16:29:22 -05002361 orig_request->copyup_page_count = page_count;
Alex Elder3d7efd12013-04-19 15:34:50 -05002362
Alex Elder0eefd472013-04-19 15:34:50 -05002363 /* Initialize the copyup op */
2364
2365 osd_req_op_cls_init(osd_req, 0, CEPH_OSD_OP_CALL, "rbd", "copyup");
Alex Elderebda6402013-05-10 16:29:22 -05002366 osd_req_op_cls_request_data_pages(osd_req, 0, pages, parent_length, 0,
Alex Elder0eefd472013-04-19 15:34:50 -05002367 false, false);
2368
2369 /* Then the original write request op */
2370
Alex Elderb91f09f2013-05-10 16:29:22 -05002371 offset = orig_request->offset;
2372 length = orig_request->length;
Alex Elder0eefd472013-04-19 15:34:50 -05002373 osd_req_op_extent_init(osd_req, 1, CEPH_OSD_OP_WRITE,
Alex Elderb91f09f2013-05-10 16:29:22 -05002374 offset, length, 0, 0);
2375 if (orig_request->type == OBJ_REQUEST_BIO)
2376 osd_req_op_extent_osd_data_bio(osd_req, 1,
2377 orig_request->bio_list, length);
2378 else
2379 osd_req_op_extent_osd_data_pages(osd_req, 1,
2380 orig_request->pages, length,
2381 offset & ~PAGE_MASK, false, false);
Alex Elder0eefd472013-04-19 15:34:50 -05002382
2383 rbd_osd_req_format_write(orig_request);
2384
2385 /* All set, send it off. */
2386
2387 orig_request->callback = rbd_img_obj_copyup_callback;
2388 osdc = &rbd_dev->rbd_client->client->osdc;
2389 result = rbd_obj_request_submit(osdc, orig_request);
2390 if (!result)
2391 return;
2392out_err:
2393 /* Record the error code and complete the request */
2394
2395 orig_request->result = result;
2396 orig_request->xferred = 0;
2397 obj_request_done_set(orig_request);
2398 rbd_obj_request_complete(orig_request);
Alex Elder3d7efd12013-04-19 15:34:50 -05002399}
2400
2401/*
2402 * Read from the parent image the range of data that covers the
2403 * entire target of the given object request. This is used for
2404 * satisfying a layered image write request when the target of an
2405 * object request from the image request does not exist.
2406 *
2407 * A page array big enough to hold the returned data is allocated
2408 * and supplied to rbd_img_request_fill() as the "data descriptor."
2409 * When the read completes, this page array will be transferred to
2410 * the original object request for the copyup operation.
2411 *
2412 * If an error occurs, record it as the result of the original
2413 * object request and mark it done so it gets completed.
2414 */
2415static int rbd_img_obj_parent_read_full(struct rbd_obj_request *obj_request)
2416{
2417 struct rbd_img_request *img_request = NULL;
2418 struct rbd_img_request *parent_request = NULL;
2419 struct rbd_device *rbd_dev;
2420 u64 img_offset;
2421 u64 length;
2422 struct page **pages = NULL;
2423 u32 page_count;
2424 int result;
2425
2426 rbd_assert(obj_request_img_data_test(obj_request));
Alex Elderb91f09f2013-05-10 16:29:22 -05002427 rbd_assert(obj_request_type_valid(obj_request->type));
Alex Elder3d7efd12013-04-19 15:34:50 -05002428
2429 img_request = obj_request->img_request;
2430 rbd_assert(img_request != NULL);
2431 rbd_dev = img_request->rbd_dev;
2432 rbd_assert(rbd_dev->parent != NULL);
2433
2434 /*
2435 * Determine the byte range covered by the object in the
2436 * child image to which the original request was to be sent.
2437 */
2438 img_offset = obj_request->img_offset - obj_request->offset;
2439 length = (u64)1 << rbd_dev->header.obj_order;
2440
2441 /*
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002442 * There is no defined parent data beyond the parent
2443 * overlap, so limit what we read at that boundary if
2444 * necessary.
2445 */
2446 if (img_offset + length > rbd_dev->parent_overlap) {
2447 rbd_assert(img_offset < rbd_dev->parent_overlap);
2448 length = rbd_dev->parent_overlap - img_offset;
2449 }
2450
2451 /*
Alex Elder3d7efd12013-04-19 15:34:50 -05002452 * Allocate a page array big enough to receive the data read
2453 * from the parent.
2454 */
2455 page_count = (u32)calc_pages_for(0, length);
2456 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
2457 if (IS_ERR(pages)) {
2458 result = PTR_ERR(pages);
2459 pages = NULL;
2460 goto out_err;
2461 }
2462
2463 result = -ENOMEM;
Alex Eldere93f3152013-05-08 22:50:04 -05002464 parent_request = rbd_parent_request_create(obj_request,
2465 img_offset, length);
Alex Elder3d7efd12013-04-19 15:34:50 -05002466 if (!parent_request)
2467 goto out_err;
Alex Elder3d7efd12013-04-19 15:34:50 -05002468
2469 result = rbd_img_request_fill(parent_request, OBJ_REQUEST_PAGES, pages);
2470 if (result)
2471 goto out_err;
2472 parent_request->copyup_pages = pages;
Alex Elderebda6402013-05-10 16:29:22 -05002473 parent_request->copyup_page_count = page_count;
Alex Elder3d7efd12013-04-19 15:34:50 -05002474
2475 parent_request->callback = rbd_img_obj_parent_read_full_callback;
2476 result = rbd_img_request_submit(parent_request);
2477 if (!result)
2478 return 0;
2479
2480 parent_request->copyup_pages = NULL;
Alex Elderebda6402013-05-10 16:29:22 -05002481 parent_request->copyup_page_count = 0;
Alex Elder3d7efd12013-04-19 15:34:50 -05002482 parent_request->obj_request = NULL;
2483 rbd_obj_request_put(obj_request);
2484out_err:
2485 if (pages)
2486 ceph_release_page_vector(pages, page_count);
2487 if (parent_request)
2488 rbd_img_request_put(parent_request);
2489 obj_request->result = result;
2490 obj_request->xferred = 0;
2491 obj_request_done_set(obj_request);
2492
2493 return result;
2494}
2495
Alex Elderc5b5ef62013-02-11 12:33:24 -06002496static void rbd_img_obj_exists_callback(struct rbd_obj_request *obj_request)
2497{
Alex Elderc5b5ef62013-02-11 12:33:24 -06002498 struct rbd_obj_request *orig_request;
2499 int result;
2500
2501 rbd_assert(!obj_request_img_data_test(obj_request));
2502
2503 /*
2504 * All we need from the object request is the original
2505 * request and the result of the STAT op. Grab those, then
2506 * we're done with the request.
2507 */
2508 orig_request = obj_request->obj_request;
2509 obj_request->obj_request = NULL;
2510 rbd_assert(orig_request);
2511 rbd_assert(orig_request->img_request);
2512
2513 result = obj_request->result;
2514 obj_request->result = 0;
2515
2516 dout("%s: obj %p for obj %p result %d %llu/%llu\n", __func__,
2517 obj_request, orig_request, result,
2518 obj_request->xferred, obj_request->length);
2519 rbd_obj_request_put(obj_request);
2520
2521 rbd_assert(orig_request);
2522 rbd_assert(orig_request->img_request);
Alex Elderc5b5ef62013-02-11 12:33:24 -06002523
2524 /*
2525 * Our only purpose here is to determine whether the object
2526 * exists, and we don't want to treat the non-existence as
2527 * an error. If something else comes back, transfer the
2528 * error to the original request and complete it now.
2529 */
2530 if (!result) {
2531 obj_request_existence_set(orig_request, true);
2532 } else if (result == -ENOENT) {
2533 obj_request_existence_set(orig_request, false);
2534 } else if (result) {
2535 orig_request->result = result;
Alex Elder3d7efd12013-04-19 15:34:50 -05002536 goto out;
Alex Elderc5b5ef62013-02-11 12:33:24 -06002537 }
2538
2539 /*
2540 * Resubmit the original request now that we have recorded
2541 * whether the target object exists.
2542 */
Alex Elderb454e362013-04-19 15:34:50 -05002543 orig_request->result = rbd_img_obj_request_submit(orig_request);
Alex Elder3d7efd12013-04-19 15:34:50 -05002544out:
Alex Elderc5b5ef62013-02-11 12:33:24 -06002545 if (orig_request->result)
2546 rbd_obj_request_complete(orig_request);
2547 rbd_obj_request_put(orig_request);
2548}
2549
2550static int rbd_img_obj_exists_submit(struct rbd_obj_request *obj_request)
2551{
2552 struct rbd_obj_request *stat_request;
2553 struct rbd_device *rbd_dev;
2554 struct ceph_osd_client *osdc;
2555 struct page **pages = NULL;
2556 u32 page_count;
2557 size_t size;
2558 int ret;
2559
2560 /*
2561 * The response data for a STAT call consists of:
2562 * le64 length;
2563 * struct {
2564 * le32 tv_sec;
2565 * le32 tv_nsec;
2566 * } mtime;
2567 */
2568 size = sizeof (__le64) + sizeof (__le32) + sizeof (__le32);
2569 page_count = (u32)calc_pages_for(0, size);
2570 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
2571 if (IS_ERR(pages))
2572 return PTR_ERR(pages);
2573
2574 ret = -ENOMEM;
2575 stat_request = rbd_obj_request_create(obj_request->object_name, 0, 0,
2576 OBJ_REQUEST_PAGES);
2577 if (!stat_request)
2578 goto out;
2579
2580 rbd_obj_request_get(obj_request);
2581 stat_request->obj_request = obj_request;
2582 stat_request->pages = pages;
2583 stat_request->page_count = page_count;
2584
2585 rbd_assert(obj_request->img_request);
2586 rbd_dev = obj_request->img_request->rbd_dev;
2587 stat_request->osd_req = rbd_osd_req_create(rbd_dev, false,
2588 stat_request);
2589 if (!stat_request->osd_req)
2590 goto out;
2591 stat_request->callback = rbd_img_obj_exists_callback;
2592
2593 osd_req_op_init(stat_request->osd_req, 0, CEPH_OSD_OP_STAT);
2594 osd_req_op_raw_data_in_pages(stat_request->osd_req, 0, pages, size, 0,
2595 false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05002596 rbd_osd_req_format_read(stat_request);
Alex Elderc5b5ef62013-02-11 12:33:24 -06002597
2598 osdc = &rbd_dev->rbd_client->client->osdc;
2599 ret = rbd_obj_request_submit(osdc, stat_request);
2600out:
2601 if (ret)
2602 rbd_obj_request_put(obj_request);
2603
2604 return ret;
2605}
2606
Alex Elderb454e362013-04-19 15:34:50 -05002607static int rbd_img_obj_request_submit(struct rbd_obj_request *obj_request)
2608{
2609 struct rbd_img_request *img_request;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002610 struct rbd_device *rbd_dev;
Alex Elder3d7efd12013-04-19 15:34:50 -05002611 bool known;
Alex Elderb454e362013-04-19 15:34:50 -05002612
2613 rbd_assert(obj_request_img_data_test(obj_request));
2614
2615 img_request = obj_request->img_request;
2616 rbd_assert(img_request);
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002617 rbd_dev = img_request->rbd_dev;
Alex Elderb454e362013-04-19 15:34:50 -05002618
Alex Elderb454e362013-04-19 15:34:50 -05002619 /*
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002620 * Only writes to layered images need special handling.
2621 * Reads and non-layered writes are simple object requests.
2622 * Layered writes that start beyond the end of the overlap
2623 * with the parent have no parent data, so they too are
2624 * simple object requests. Finally, if the target object is
2625 * known to already exist, its parent data has already been
2626 * copied, so a write to the object can also be handled as a
2627 * simple object request.
Alex Elderb454e362013-04-19 15:34:50 -05002628 */
2629 if (!img_request_write_test(img_request) ||
2630 !img_request_layered_test(img_request) ||
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002631 rbd_dev->parent_overlap <= obj_request->img_offset ||
Alex Elder3d7efd12013-04-19 15:34:50 -05002632 ((known = obj_request_known_test(obj_request)) &&
2633 obj_request_exists_test(obj_request))) {
Alex Elderb454e362013-04-19 15:34:50 -05002634
2635 struct rbd_device *rbd_dev;
2636 struct ceph_osd_client *osdc;
2637
2638 rbd_dev = obj_request->img_request->rbd_dev;
2639 osdc = &rbd_dev->rbd_client->client->osdc;
2640
2641 return rbd_obj_request_submit(osdc, obj_request);
2642 }
2643
2644 /*
Alex Elder3d7efd12013-04-19 15:34:50 -05002645 * It's a layered write. The target object might exist but
2646 * we may not know that yet. If we know it doesn't exist,
2647 * start by reading the data for the full target object from
2648 * the parent so we can use it for a copyup to the target.
Alex Elderb454e362013-04-19 15:34:50 -05002649 */
Alex Elder3d7efd12013-04-19 15:34:50 -05002650 if (known)
2651 return rbd_img_obj_parent_read_full(obj_request);
2652
2653 /* We don't know whether the target exists. Go find out. */
Alex Elderb454e362013-04-19 15:34:50 -05002654
2655 return rbd_img_obj_exists_submit(obj_request);
2656}
2657
Alex Elderbf0d5f502012-11-22 00:00:08 -06002658static int rbd_img_request_submit(struct rbd_img_request *img_request)
2659{
Alex Elderbf0d5f502012-11-22 00:00:08 -06002660 struct rbd_obj_request *obj_request;
Alex Elder46faeed2013-04-10 17:47:46 -05002661 struct rbd_obj_request *next_obj_request;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002662
Alex Elder37206ee2013-02-20 17:32:08 -06002663 dout("%s: img %p\n", __func__, img_request);
Alex Elder46faeed2013-04-10 17:47:46 -05002664 for_each_obj_request_safe(img_request, obj_request, next_obj_request) {
Alex Elderbf0d5f502012-11-22 00:00:08 -06002665 int ret;
2666
Alex Elderb454e362013-04-19 15:34:50 -05002667 ret = rbd_img_obj_request_submit(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002668 if (ret)
2669 return ret;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002670 }
2671
2672 return 0;
2673}
2674
Alex Elder8b3e1a52013-01-24 16:13:36 -06002675static void rbd_img_parent_read_callback(struct rbd_img_request *img_request)
2676{
2677 struct rbd_obj_request *obj_request;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002678 struct rbd_device *rbd_dev;
2679 u64 obj_end;
Alex Elder8b3e1a52013-01-24 16:13:36 -06002680
2681 rbd_assert(img_request_child_test(img_request));
2682
2683 obj_request = img_request->obj_request;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002684 rbd_assert(obj_request);
2685 rbd_assert(obj_request->img_request);
Alex Elder8b3e1a52013-01-24 16:13:36 -06002686
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002687 obj_request->result = img_request->result;
2688 if (obj_request->result)
2689 goto out;
2690
2691 /*
2692 * We need to zero anything beyond the parent overlap
2693 * boundary. Since rbd_img_obj_request_read_callback()
2694 * will zero anything beyond the end of a short read, an
2695 * easy way to do this is to pretend the data from the
2696 * parent came up short--ending at the overlap boundary.
2697 */
2698 rbd_assert(obj_request->img_offset < U64_MAX - obj_request->length);
2699 obj_end = obj_request->img_offset + obj_request->length;
2700 rbd_dev = obj_request->img_request->rbd_dev;
2701 if (obj_end > rbd_dev->parent_overlap) {
2702 u64 xferred = 0;
2703
2704 if (obj_request->img_offset < rbd_dev->parent_overlap)
2705 xferred = rbd_dev->parent_overlap -
2706 obj_request->img_offset;
2707
2708 obj_request->xferred = min(img_request->xferred, xferred);
2709 } else {
2710 obj_request->xferred = img_request->xferred;
2711 }
2712out:
Alex Elderb5b09be2013-05-01 21:37:07 -05002713 rbd_img_request_put(img_request);
Alex Elder8b3e1a52013-01-24 16:13:36 -06002714 rbd_img_obj_request_read_callback(obj_request);
2715 rbd_obj_request_complete(obj_request);
2716}
2717
2718static void rbd_img_parent_read(struct rbd_obj_request *obj_request)
2719{
Alex Elder8b3e1a52013-01-24 16:13:36 -06002720 struct rbd_img_request *img_request;
2721 int result;
2722
2723 rbd_assert(obj_request_img_data_test(obj_request));
2724 rbd_assert(obj_request->img_request != NULL);
2725 rbd_assert(obj_request->result == (s32) -ENOENT);
Alex Elder5b2ab722013-05-06 17:40:33 -05002726 rbd_assert(obj_request_type_valid(obj_request->type));
Alex Elder8b3e1a52013-01-24 16:13:36 -06002727
Alex Elder8b3e1a52013-01-24 16:13:36 -06002728 /* rbd_read_finish(obj_request, obj_request->length); */
Alex Eldere93f3152013-05-08 22:50:04 -05002729 img_request = rbd_parent_request_create(obj_request,
Alex Elder8b3e1a52013-01-24 16:13:36 -06002730 obj_request->img_offset,
Alex Eldere93f3152013-05-08 22:50:04 -05002731 obj_request->length);
Alex Elder8b3e1a52013-01-24 16:13:36 -06002732 result = -ENOMEM;
2733 if (!img_request)
2734 goto out_err;
2735
Alex Elder5b2ab722013-05-06 17:40:33 -05002736 if (obj_request->type == OBJ_REQUEST_BIO)
2737 result = rbd_img_request_fill(img_request, OBJ_REQUEST_BIO,
2738 obj_request->bio_list);
2739 else
2740 result = rbd_img_request_fill(img_request, OBJ_REQUEST_PAGES,
2741 obj_request->pages);
Alex Elder8b3e1a52013-01-24 16:13:36 -06002742 if (result)
2743 goto out_err;
2744
2745 img_request->callback = rbd_img_parent_read_callback;
2746 result = rbd_img_request_submit(img_request);
2747 if (result)
2748 goto out_err;
2749
2750 return;
2751out_err:
2752 if (img_request)
2753 rbd_img_request_put(img_request);
2754 obj_request->result = result;
2755 obj_request->xferred = 0;
2756 obj_request_done_set(obj_request);
2757}
2758
Alex Eldercc4a38bd2013-04-30 00:44:33 -05002759static int rbd_obj_notify_ack(struct rbd_device *rbd_dev, u64 notify_id)
Alex Elderb8d70032012-11-30 17:53:04 -06002760{
2761 struct rbd_obj_request *obj_request;
Alex Elder21692382013-04-05 01:27:12 -05002762 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elderb8d70032012-11-30 17:53:04 -06002763 int ret;
2764
2765 obj_request = rbd_obj_request_create(rbd_dev->header_name, 0, 0,
2766 OBJ_REQUEST_NODATA);
2767 if (!obj_request)
2768 return -ENOMEM;
2769
2770 ret = -ENOMEM;
Alex Elder430c28c2013-04-03 21:32:51 -05002771 obj_request->osd_req = rbd_osd_req_create(rbd_dev, false, obj_request);
Alex Elderb8d70032012-11-30 17:53:04 -06002772 if (!obj_request->osd_req)
2773 goto out;
Alex Elder21692382013-04-05 01:27:12 -05002774 obj_request->callback = rbd_obj_request_put;
Alex Elderb8d70032012-11-30 17:53:04 -06002775
Alex Elderc99d2d42013-04-05 01:27:11 -05002776 osd_req_op_watch_init(obj_request->osd_req, 0, CEPH_OSD_OP_NOTIFY_ACK,
Alex Eldercc4a38bd2013-04-30 00:44:33 -05002777 notify_id, 0, 0);
Alex Elder9d4df012013-04-19 15:34:50 -05002778 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05002779
Alex Elderb8d70032012-11-30 17:53:04 -06002780 ret = rbd_obj_request_submit(osdc, obj_request);
Alex Elderb8d70032012-11-30 17:53:04 -06002781out:
Alex Eldercf81b602013-01-17 12:18:46 -06002782 if (ret)
2783 rbd_obj_request_put(obj_request);
Alex Elderb8d70032012-11-30 17:53:04 -06002784
2785 return ret;
2786}
2787
2788static void rbd_watch_cb(u64 ver, u64 notify_id, u8 opcode, void *data)
2789{
2790 struct rbd_device *rbd_dev = (struct rbd_device *)data;
Alex Eldere627db02013-05-06 07:40:30 -05002791 int ret;
Alex Elderb8d70032012-11-30 17:53:04 -06002792
2793 if (!rbd_dev)
2794 return;
2795
Alex Elder37206ee2013-02-20 17:32:08 -06002796 dout("%s: \"%s\" notify_id %llu opcode %u\n", __func__,
Alex Eldercc4a38bd2013-04-30 00:44:33 -05002797 rbd_dev->header_name, (unsigned long long)notify_id,
2798 (unsigned int)opcode);
Alex Eldere627db02013-05-06 07:40:30 -05002799 ret = rbd_dev_refresh(rbd_dev);
2800 if (ret)
2801 rbd_warn(rbd_dev, ": header refresh error (%d)\n", ret);
Alex Elderb8d70032012-11-30 17:53:04 -06002802
Alex Eldercc4a38bd2013-04-30 00:44:33 -05002803 rbd_obj_notify_ack(rbd_dev, notify_id);
Alex Elderb8d70032012-11-30 17:53:04 -06002804}
2805
Alex Elder9969ebc2013-01-18 12:31:10 -06002806/*
2807 * Request sync osd watch/unwatch. The value of "start" determines
2808 * whether a watch request is being initiated or torn down.
2809 */
Alex Elder1f3ef782013-05-06 17:40:33 -05002810static int rbd_dev_header_watch_sync(struct rbd_device *rbd_dev, bool start)
Alex Elder9969ebc2013-01-18 12:31:10 -06002811{
2812 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
2813 struct rbd_obj_request *obj_request;
Alex Elder9969ebc2013-01-18 12:31:10 -06002814 int ret;
2815
2816 rbd_assert(start ^ !!rbd_dev->watch_event);
2817 rbd_assert(start ^ !!rbd_dev->watch_request);
2818
2819 if (start) {
Alex Elder3c663bb2013-02-15 11:42:30 -06002820 ret = ceph_osdc_create_event(osdc, rbd_watch_cb, rbd_dev,
Alex Elder9969ebc2013-01-18 12:31:10 -06002821 &rbd_dev->watch_event);
2822 if (ret < 0)
2823 return ret;
Alex Elder8eb87562013-01-25 17:08:55 -06002824 rbd_assert(rbd_dev->watch_event != NULL);
Alex Elder9969ebc2013-01-18 12:31:10 -06002825 }
2826
2827 ret = -ENOMEM;
2828 obj_request = rbd_obj_request_create(rbd_dev->header_name, 0, 0,
2829 OBJ_REQUEST_NODATA);
2830 if (!obj_request)
2831 goto out_cancel;
2832
Alex Elder430c28c2013-04-03 21:32:51 -05002833 obj_request->osd_req = rbd_osd_req_create(rbd_dev, true, obj_request);
2834 if (!obj_request->osd_req)
2835 goto out_cancel;
2836
Alex Elder8eb87562013-01-25 17:08:55 -06002837 if (start)
Alex Elder975241a2013-01-25 17:08:55 -06002838 ceph_osdc_set_request_linger(osdc, obj_request->osd_req);
Alex Elder8eb87562013-01-25 17:08:55 -06002839 else
Alex Elder6977c3f2013-01-25 17:08:55 -06002840 ceph_osdc_unregister_linger_request(osdc,
Alex Elder975241a2013-01-25 17:08:55 -06002841 rbd_dev->watch_request->osd_req);
Alex Elder21692382013-04-05 01:27:12 -05002842
2843 osd_req_op_watch_init(obj_request->osd_req, 0, CEPH_OSD_OP_WATCH,
Alex Elder1f3ef782013-05-06 17:40:33 -05002844 rbd_dev->watch_event->cookie, 0, start ? 1 : 0);
Alex Elder9d4df012013-04-19 15:34:50 -05002845 rbd_osd_req_format_write(obj_request);
Alex Elder21692382013-04-05 01:27:12 -05002846
Alex Elder9969ebc2013-01-18 12:31:10 -06002847 ret = rbd_obj_request_submit(osdc, obj_request);
2848 if (ret)
2849 goto out_cancel;
2850 ret = rbd_obj_request_wait(obj_request);
2851 if (ret)
2852 goto out_cancel;
Alex Elder9969ebc2013-01-18 12:31:10 -06002853 ret = obj_request->result;
2854 if (ret)
2855 goto out_cancel;
2856
Alex Elder8eb87562013-01-25 17:08:55 -06002857 /*
2858 * A watch request is set to linger, so the underlying osd
2859 * request won't go away until we unregister it. We retain
2860 * a pointer to the object request during that time (in
2861 * rbd_dev->watch_request), so we'll keep a reference to
2862 * it. We'll drop that reference (below) after we've
2863 * unregistered it.
2864 */
2865 if (start) {
2866 rbd_dev->watch_request = obj_request;
2867
2868 return 0;
2869 }
2870
2871 /* We have successfully torn down the watch request */
2872
2873 rbd_obj_request_put(rbd_dev->watch_request);
2874 rbd_dev->watch_request = NULL;
Alex Elder9969ebc2013-01-18 12:31:10 -06002875out_cancel:
2876 /* Cancel the event if we're tearing down, or on error */
2877 ceph_osdc_cancel_event(rbd_dev->watch_event);
2878 rbd_dev->watch_event = NULL;
Alex Elder9969ebc2013-01-18 12:31:10 -06002879 if (obj_request)
2880 rbd_obj_request_put(obj_request);
2881
2882 return ret;
2883}
2884
Alex Elder36be9a72013-01-19 00:30:28 -06002885/*
Alex Elderf40eb342013-04-25 15:09:42 -05002886 * Synchronous osd object method call. Returns the number of bytes
2887 * returned in the outbound buffer, or a negative error code.
Alex Elder36be9a72013-01-19 00:30:28 -06002888 */
2889static int rbd_obj_method_sync(struct rbd_device *rbd_dev,
2890 const char *object_name,
2891 const char *class_name,
2892 const char *method_name,
Alex Elder41579762013-04-21 12:14:45 -05002893 const void *outbound,
Alex Elder36be9a72013-01-19 00:30:28 -06002894 size_t outbound_size,
Alex Elder41579762013-04-21 12:14:45 -05002895 void *inbound,
Alex Eldere2a58ee2013-04-30 00:44:33 -05002896 size_t inbound_size)
Alex Elder36be9a72013-01-19 00:30:28 -06002897{
Alex Elder21692382013-04-05 01:27:12 -05002898 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elder36be9a72013-01-19 00:30:28 -06002899 struct rbd_obj_request *obj_request;
Alex Elder36be9a72013-01-19 00:30:28 -06002900 struct page **pages;
2901 u32 page_count;
2902 int ret;
2903
2904 /*
Alex Elder6010a452013-04-05 01:27:11 -05002905 * Method calls are ultimately read operations. The result
2906 * should placed into the inbound buffer provided. They
2907 * also supply outbound data--parameters for the object
2908 * method. Currently if this is present it will be a
2909 * snapshot id.
Alex Elder36be9a72013-01-19 00:30:28 -06002910 */
Alex Elder57385b52013-04-21 12:14:45 -05002911 page_count = (u32)calc_pages_for(0, inbound_size);
Alex Elder36be9a72013-01-19 00:30:28 -06002912 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
2913 if (IS_ERR(pages))
2914 return PTR_ERR(pages);
2915
2916 ret = -ENOMEM;
Alex Elder6010a452013-04-05 01:27:11 -05002917 obj_request = rbd_obj_request_create(object_name, 0, inbound_size,
Alex Elder36be9a72013-01-19 00:30:28 -06002918 OBJ_REQUEST_PAGES);
2919 if (!obj_request)
2920 goto out;
2921
2922 obj_request->pages = pages;
2923 obj_request->page_count = page_count;
2924
Alex Elder430c28c2013-04-03 21:32:51 -05002925 obj_request->osd_req = rbd_osd_req_create(rbd_dev, false, obj_request);
Alex Elder36be9a72013-01-19 00:30:28 -06002926 if (!obj_request->osd_req)
2927 goto out;
2928
Alex Elderc99d2d42013-04-05 01:27:11 -05002929 osd_req_op_cls_init(obj_request->osd_req, 0, CEPH_OSD_OP_CALL,
Alex Elder04017e22013-04-05 14:46:02 -05002930 class_name, method_name);
2931 if (outbound_size) {
2932 struct ceph_pagelist *pagelist;
2933
2934 pagelist = kmalloc(sizeof (*pagelist), GFP_NOFS);
2935 if (!pagelist)
2936 goto out;
2937
2938 ceph_pagelist_init(pagelist);
2939 ceph_pagelist_append(pagelist, outbound, outbound_size);
2940 osd_req_op_cls_request_data_pagelist(obj_request->osd_req, 0,
2941 pagelist);
2942 }
Alex Eldera4ce40a2013-04-05 01:27:12 -05002943 osd_req_op_cls_response_data_pages(obj_request->osd_req, 0,
2944 obj_request->pages, inbound_size,
Alex Elder44cd1882013-04-05 01:27:12 -05002945 0, false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05002946 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05002947
Alex Elder36be9a72013-01-19 00:30:28 -06002948 ret = rbd_obj_request_submit(osdc, obj_request);
2949 if (ret)
2950 goto out;
2951 ret = rbd_obj_request_wait(obj_request);
2952 if (ret)
2953 goto out;
2954
2955 ret = obj_request->result;
2956 if (ret < 0)
2957 goto out;
Alex Elder57385b52013-04-21 12:14:45 -05002958
2959 rbd_assert(obj_request->xferred < (u64)INT_MAX);
2960 ret = (int)obj_request->xferred;
Alex Elder903bb322013-02-06 13:11:38 -06002961 ceph_copy_from_page_vector(pages, inbound, 0, obj_request->xferred);
Alex Elder36be9a72013-01-19 00:30:28 -06002962out:
2963 if (obj_request)
2964 rbd_obj_request_put(obj_request);
2965 else
2966 ceph_release_page_vector(pages, page_count);
2967
2968 return ret;
2969}
2970
Alex Elderbf0d5f502012-11-22 00:00:08 -06002971static void rbd_request_fn(struct request_queue *q)
Alex Eldercc344fa2013-02-19 12:25:56 -06002972 __releases(q->queue_lock) __acquires(q->queue_lock)
Alex Elderbf0d5f502012-11-22 00:00:08 -06002973{
2974 struct rbd_device *rbd_dev = q->queuedata;
2975 bool read_only = rbd_dev->mapping.read_only;
2976 struct request *rq;
2977 int result;
2978
2979 while ((rq = blk_fetch_request(q))) {
2980 bool write_request = rq_data_dir(rq) == WRITE;
2981 struct rbd_img_request *img_request;
2982 u64 offset;
2983 u64 length;
2984
2985 /* Ignore any non-FS requests that filter through. */
2986
2987 if (rq->cmd_type != REQ_TYPE_FS) {
Alex Elder4dda41d2013-02-20 21:59:33 -06002988 dout("%s: non-fs request type %d\n", __func__,
2989 (int) rq->cmd_type);
2990 __blk_end_request_all(rq, 0);
2991 continue;
2992 }
2993
2994 /* Ignore/skip any zero-length requests */
2995
2996 offset = (u64) blk_rq_pos(rq) << SECTOR_SHIFT;
2997 length = (u64) blk_rq_bytes(rq);
2998
2999 if (!length) {
3000 dout("%s: zero-length request\n", __func__);
Alex Elderbf0d5f502012-11-22 00:00:08 -06003001 __blk_end_request_all(rq, 0);
3002 continue;
3003 }
3004
3005 spin_unlock_irq(q->queue_lock);
3006
3007 /* Disallow writes to a read-only device */
3008
3009 if (write_request) {
3010 result = -EROFS;
3011 if (read_only)
3012 goto end_request;
3013 rbd_assert(rbd_dev->spec->snap_id == CEPH_NOSNAP);
3014 }
3015
Alex Elder6d292902013-01-14 12:43:31 -06003016 /*
3017 * Quit early if the mapped snapshot no longer
3018 * exists. It's still possible the snapshot will
3019 * have disappeared by the time our request arrives
3020 * at the osd, but there's no sense in sending it if
3021 * we already know.
3022 */
3023 if (!test_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags)) {
Alex Elderbf0d5f502012-11-22 00:00:08 -06003024 dout("request for non-existent snapshot");
3025 rbd_assert(rbd_dev->spec->snap_id != CEPH_NOSNAP);
3026 result = -ENXIO;
3027 goto end_request;
3028 }
3029
Alex Elderbf0d5f502012-11-22 00:00:08 -06003030 result = -EINVAL;
Alex Elderc0cd10db2013-04-26 09:43:47 -05003031 if (offset && length > U64_MAX - offset + 1) {
3032 rbd_warn(rbd_dev, "bad request range (%llu~%llu)\n",
3033 offset, length);
Alex Elderbf0d5f502012-11-22 00:00:08 -06003034 goto end_request; /* Shouldn't happen */
Alex Elderc0cd10db2013-04-26 09:43:47 -05003035 }
Alex Elderbf0d5f502012-11-22 00:00:08 -06003036
Alex Elder00a653e2013-05-06 07:40:30 -05003037 result = -EIO;
3038 if (offset + length > rbd_dev->mapping.size) {
3039 rbd_warn(rbd_dev, "beyond EOD (%llu~%llu > %llu)\n",
3040 offset, length, rbd_dev->mapping.size);
3041 goto end_request;
3042 }
3043
Alex Elderbf0d5f502012-11-22 00:00:08 -06003044 result = -ENOMEM;
3045 img_request = rbd_img_request_create(rbd_dev, offset, length,
Alex Eldere93f3152013-05-08 22:50:04 -05003046 write_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06003047 if (!img_request)
3048 goto end_request;
3049
3050 img_request->rq = rq;
3051
Alex Elderf1a47392013-04-19 15:34:50 -05003052 result = rbd_img_request_fill(img_request, OBJ_REQUEST_BIO,
3053 rq->bio);
Alex Elderbf0d5f502012-11-22 00:00:08 -06003054 if (!result)
3055 result = rbd_img_request_submit(img_request);
3056 if (result)
3057 rbd_img_request_put(img_request);
3058end_request:
3059 spin_lock_irq(q->queue_lock);
3060 if (result < 0) {
Alex Elder7da22d22013-01-24 16:13:36 -06003061 rbd_warn(rbd_dev, "%s %llx at %llx result %d\n",
3062 write_request ? "write" : "read",
3063 length, offset, result);
3064
Alex Elderbf0d5f502012-11-22 00:00:08 -06003065 __blk_end_request_all(rq, result);
3066 }
3067 }
3068}
3069
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003070/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003071 * a queue callback. Makes sure that we don't create a bio that spans across
3072 * multiple osd objects. One exception would be with a single page bios,
Alex Elderf7760da2012-10-20 22:17:27 -05003073 * which we handle later at bio_chain_clone_range()
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003074 */
3075static int rbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bmd,
3076 struct bio_vec *bvec)
3077{
3078 struct rbd_device *rbd_dev = q->queuedata;
Alex Eldere5cfeed22012-10-20 22:17:27 -05003079 sector_t sector_offset;
3080 sector_t sectors_per_obj;
3081 sector_t obj_sector_offset;
3082 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003083
Alex Eldere5cfeed22012-10-20 22:17:27 -05003084 /*
3085 * Find how far into its rbd object the partition-relative
3086 * bio start sector is to offset relative to the enclosing
3087 * device.
3088 */
3089 sector_offset = get_start_sect(bmd->bi_bdev) + bmd->bi_sector;
3090 sectors_per_obj = 1 << (rbd_dev->header.obj_order - SECTOR_SHIFT);
3091 obj_sector_offset = sector_offset & (sectors_per_obj - 1);
Alex Elder593a9e72012-02-07 12:03:37 -06003092
Alex Eldere5cfeed22012-10-20 22:17:27 -05003093 /*
3094 * Compute the number of bytes from that offset to the end
3095 * of the object. Account for what's already used by the bio.
3096 */
3097 ret = (int) (sectors_per_obj - obj_sector_offset) << SECTOR_SHIFT;
3098 if (ret > bmd->bi_size)
3099 ret -= bmd->bi_size;
3100 else
3101 ret = 0;
3102
3103 /*
3104 * Don't send back more than was asked for. And if the bio
3105 * was empty, let the whole thing through because: "Note
3106 * that a block device *must* allow a single page to be
3107 * added to an empty bio."
3108 */
3109 rbd_assert(bvec->bv_len <= PAGE_SIZE);
3110 if (ret > (int) bvec->bv_len || !bmd->bi_size)
3111 ret = (int) bvec->bv_len;
3112
3113 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003114}
3115
3116static void rbd_free_disk(struct rbd_device *rbd_dev)
3117{
3118 struct gendisk *disk = rbd_dev->disk;
3119
3120 if (!disk)
3121 return;
3122
Alex Eldera0cab922013-04-25 23:15:08 -05003123 rbd_dev->disk = NULL;
3124 if (disk->flags & GENHD_FL_UP) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003125 del_gendisk(disk);
Alex Eldera0cab922013-04-25 23:15:08 -05003126 if (disk->queue)
3127 blk_cleanup_queue(disk->queue);
3128 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003129 put_disk(disk);
3130}
3131
Alex Elder788e2df2013-01-17 12:25:27 -06003132static int rbd_obj_read_sync(struct rbd_device *rbd_dev,
3133 const char *object_name,
Alex Elder7097f8d2013-04-30 00:44:33 -05003134 u64 offset, u64 length, void *buf)
Alex Elder788e2df2013-01-17 12:25:27 -06003135
3136{
Alex Elder21692382013-04-05 01:27:12 -05003137 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elder788e2df2013-01-17 12:25:27 -06003138 struct rbd_obj_request *obj_request;
Alex Elder788e2df2013-01-17 12:25:27 -06003139 struct page **pages = NULL;
3140 u32 page_count;
Alex Elder1ceae7e2013-02-06 13:11:38 -06003141 size_t size;
Alex Elder788e2df2013-01-17 12:25:27 -06003142 int ret;
3143
3144 page_count = (u32) calc_pages_for(offset, length);
3145 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
3146 if (IS_ERR(pages))
3147 ret = PTR_ERR(pages);
3148
3149 ret = -ENOMEM;
3150 obj_request = rbd_obj_request_create(object_name, offset, length,
Alex Elder36be9a72013-01-19 00:30:28 -06003151 OBJ_REQUEST_PAGES);
Alex Elder788e2df2013-01-17 12:25:27 -06003152 if (!obj_request)
3153 goto out;
3154
3155 obj_request->pages = pages;
3156 obj_request->page_count = page_count;
3157
Alex Elder430c28c2013-04-03 21:32:51 -05003158 obj_request->osd_req = rbd_osd_req_create(rbd_dev, false, obj_request);
Alex Elder788e2df2013-01-17 12:25:27 -06003159 if (!obj_request->osd_req)
3160 goto out;
3161
Alex Elderc99d2d42013-04-05 01:27:11 -05003162 osd_req_op_extent_init(obj_request->osd_req, 0, CEPH_OSD_OP_READ,
3163 offset, length, 0, 0);
Alex Elder406e2c92013-04-15 14:50:36 -05003164 osd_req_op_extent_osd_data_pages(obj_request->osd_req, 0,
Alex Eldera4ce40a2013-04-05 01:27:12 -05003165 obj_request->pages,
Alex Elder44cd1882013-04-05 01:27:12 -05003166 obj_request->length,
3167 obj_request->offset & ~PAGE_MASK,
3168 false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05003169 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05003170
Alex Elder788e2df2013-01-17 12:25:27 -06003171 ret = rbd_obj_request_submit(osdc, obj_request);
3172 if (ret)
3173 goto out;
3174 ret = rbd_obj_request_wait(obj_request);
3175 if (ret)
3176 goto out;
3177
3178 ret = obj_request->result;
3179 if (ret < 0)
3180 goto out;
Alex Elder1ceae7e2013-02-06 13:11:38 -06003181
3182 rbd_assert(obj_request->xferred <= (u64) SIZE_MAX);
3183 size = (size_t) obj_request->xferred;
Alex Elder903bb322013-02-06 13:11:38 -06003184 ceph_copy_from_page_vector(pages, buf, 0, size);
Alex Elder7097f8d2013-04-30 00:44:33 -05003185 rbd_assert(size <= (size_t)INT_MAX);
3186 ret = (int)size;
Alex Elder788e2df2013-01-17 12:25:27 -06003187out:
3188 if (obj_request)
3189 rbd_obj_request_put(obj_request);
3190 else
3191 ceph_release_page_vector(pages, page_count);
3192
3193 return ret;
3194}
3195
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003196/*
Alex Elder662518b2013-05-06 09:51:29 -05003197 * Read the complete header for the given rbd device. On successful
3198 * return, the rbd_dev->header field will contain up-to-date
3199 * information about the image.
Alex Elder4156d9982012-08-02 11:29:46 -05003200 */
Alex Elder99a41eb2013-05-06 09:51:30 -05003201static int rbd_dev_v1_header_info(struct rbd_device *rbd_dev)
Alex Elder4156d9982012-08-02 11:29:46 -05003202{
3203 struct rbd_image_header_ondisk *ondisk = NULL;
3204 u32 snap_count = 0;
3205 u64 names_size = 0;
3206 u32 want_count;
3207 int ret;
3208
3209 /*
3210 * The complete header will include an array of its 64-bit
3211 * snapshot ids, followed by the names of those snapshots as
3212 * a contiguous block of NUL-terminated strings. Note that
3213 * the number of snapshots could change by the time we read
3214 * it in, in which case we re-read it.
3215 */
3216 do {
3217 size_t size;
3218
3219 kfree(ondisk);
3220
3221 size = sizeof (*ondisk);
3222 size += snap_count * sizeof (struct rbd_image_snap_ondisk);
3223 size += names_size;
3224 ondisk = kmalloc(size, GFP_KERNEL);
3225 if (!ondisk)
Alex Elder662518b2013-05-06 09:51:29 -05003226 return -ENOMEM;
Alex Elder4156d9982012-08-02 11:29:46 -05003227
Alex Elder788e2df2013-01-17 12:25:27 -06003228 ret = rbd_obj_read_sync(rbd_dev, rbd_dev->header_name,
Alex Elder7097f8d2013-04-30 00:44:33 -05003229 0, size, ondisk);
Alex Elder4156d9982012-08-02 11:29:46 -05003230 if (ret < 0)
Alex Elder662518b2013-05-06 09:51:29 -05003231 goto out;
Alex Elderc0cd10db2013-04-26 09:43:47 -05003232 if ((size_t)ret < size) {
Alex Elder4156d9982012-08-02 11:29:46 -05003233 ret = -ENXIO;
Alex Elder06ecc6c2012-11-01 10:17:15 -05003234 rbd_warn(rbd_dev, "short header read (want %zd got %d)",
3235 size, ret);
Alex Elder662518b2013-05-06 09:51:29 -05003236 goto out;
Alex Elder4156d9982012-08-02 11:29:46 -05003237 }
3238 if (!rbd_dev_ondisk_valid(ondisk)) {
3239 ret = -ENXIO;
Alex Elder06ecc6c2012-11-01 10:17:15 -05003240 rbd_warn(rbd_dev, "invalid header");
Alex Elder662518b2013-05-06 09:51:29 -05003241 goto out;
Alex Elder4156d9982012-08-02 11:29:46 -05003242 }
3243
3244 names_size = le64_to_cpu(ondisk->snap_names_len);
3245 want_count = snap_count;
3246 snap_count = le32_to_cpu(ondisk->snap_count);
3247 } while (snap_count != want_count);
3248
Alex Elder662518b2013-05-06 09:51:29 -05003249 ret = rbd_header_from_disk(rbd_dev, ondisk);
3250out:
Alex Elder4156d9982012-08-02 11:29:46 -05003251 kfree(ondisk);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003252
Alex Elder4156d9982012-08-02 11:29:46 -05003253 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003254}
3255
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003256/*
Alex Elder15228ed2013-05-01 12:43:03 -05003257 * Clear the rbd device's EXISTS flag if the snapshot it's mapped to
3258 * has disappeared from the (just updated) snapshot context.
3259 */
3260static void rbd_exists_validate(struct rbd_device *rbd_dev)
3261{
3262 u64 snap_id;
3263
3264 if (!test_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags))
3265 return;
3266
3267 snap_id = rbd_dev->spec->snap_id;
3268 if (snap_id == CEPH_NOSNAP)
3269 return;
3270
3271 if (rbd_dev_snap_index(rbd_dev, snap_id) == BAD_SNAP_INDEX)
3272 clear_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags);
3273}
3274
Alex Eldercc4a38bd2013-04-30 00:44:33 -05003275static int rbd_dev_refresh(struct rbd_device *rbd_dev)
Alex Elder1fe5e992012-07-25 09:32:41 -05003276{
Alex Eldere627db02013-05-06 07:40:30 -05003277 u64 mapping_size;
Alex Elder1fe5e992012-07-25 09:32:41 -05003278 int ret;
3279
Alex Elder117973f2012-08-31 17:29:55 -05003280 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
Alex Eldere627db02013-05-06 07:40:30 -05003281 mapping_size = rbd_dev->mapping.size;
Alex Elder1fe5e992012-07-25 09:32:41 -05003282 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Alex Elder117973f2012-08-31 17:29:55 -05003283 if (rbd_dev->image_format == 1)
Alex Elder99a41eb2013-05-06 09:51:30 -05003284 ret = rbd_dev_v1_header_info(rbd_dev);
Alex Elder117973f2012-08-31 17:29:55 -05003285 else
Alex Elder2df3fac2013-05-06 09:51:30 -05003286 ret = rbd_dev_v2_header_info(rbd_dev);
Alex Elder15228ed2013-05-01 12:43:03 -05003287
3288 /* If it's a mapped snapshot, validate its EXISTS flag */
3289
3290 rbd_exists_validate(rbd_dev);
Alex Elder1fe5e992012-07-25 09:32:41 -05003291 mutex_unlock(&ctl_mutex);
Alex Elder00a653e2013-05-06 07:40:30 -05003292 if (mapping_size != rbd_dev->mapping.size) {
3293 sector_t size;
3294
3295 size = (sector_t)rbd_dev->mapping.size / SECTOR_SIZE;
3296 dout("setting size to %llu sectors", (unsigned long long)size);
3297 set_capacity(rbd_dev->disk, size);
Alex Eldera3fbe5d2013-04-30 00:44:32 -05003298 revalidate_disk(rbd_dev->disk);
Alex Elder00a653e2013-05-06 07:40:30 -05003299 }
Alex Elder1fe5e992012-07-25 09:32:41 -05003300
3301 return ret;
3302}
3303
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003304static int rbd_init_disk(struct rbd_device *rbd_dev)
3305{
3306 struct gendisk *disk;
3307 struct request_queue *q;
Alex Elder593a9e72012-02-07 12:03:37 -06003308 u64 segment_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003309
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003310 /* create gendisk info */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003311 disk = alloc_disk(RBD_MINORS_PER_MAJOR);
3312 if (!disk)
Alex Elder1fcdb8a2012-08-29 17:11:06 -05003313 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003314
Alex Elderf0f8cef2012-01-29 13:57:44 -06003315 snprintf(disk->disk_name, sizeof(disk->disk_name), RBD_DRV_NAME "%d",
Alex Elderde71a292012-07-03 16:01:19 -05003316 rbd_dev->dev_id);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003317 disk->major = rbd_dev->major;
3318 disk->first_minor = 0;
3319 disk->fops = &rbd_bd_ops;
3320 disk->private_data = rbd_dev;
3321
Alex Elderbf0d5f502012-11-22 00:00:08 -06003322 q = blk_init_queue(rbd_request_fn, &rbd_dev->lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003323 if (!q)
3324 goto out_disk;
Josh Durgin029bcbd2011-07-22 11:35:23 -07003325
Alex Elder593a9e72012-02-07 12:03:37 -06003326 /* We use the default size, but let's be explicit about it. */
3327 blk_queue_physical_block_size(q, SECTOR_SIZE);
3328
Josh Durgin029bcbd2011-07-22 11:35:23 -07003329 /* set io sizes to object size */
Alex Elder593a9e72012-02-07 12:03:37 -06003330 segment_size = rbd_obj_bytes(&rbd_dev->header);
3331 blk_queue_max_hw_sectors(q, segment_size / SECTOR_SIZE);
3332 blk_queue_max_segment_size(q, segment_size);
3333 blk_queue_io_min(q, segment_size);
3334 blk_queue_io_opt(q, segment_size);
Josh Durgin029bcbd2011-07-22 11:35:23 -07003335
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003336 blk_queue_merge_bvec(q, rbd_merge_bvec);
3337 disk->queue = q;
3338
3339 q->queuedata = rbd_dev;
3340
3341 rbd_dev->disk = disk;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003342
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003343 return 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003344out_disk:
3345 put_disk(disk);
Alex Elder1fcdb8a2012-08-29 17:11:06 -05003346
3347 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003348}
3349
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003350/*
3351 sysfs
3352*/
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003353
Alex Elder593a9e72012-02-07 12:03:37 -06003354static struct rbd_device *dev_to_rbd_dev(struct device *dev)
3355{
3356 return container_of(dev, struct rbd_device, dev);
3357}
3358
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003359static ssize_t rbd_size_show(struct device *dev,
3360 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003361{
Alex Elder593a9e72012-02-07 12:03:37 -06003362 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003363
Alex Elderfc71d832013-04-26 15:44:36 -05003364 return sprintf(buf, "%llu\n",
3365 (unsigned long long)rbd_dev->mapping.size);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003366}
3367
Alex Elder34b13182012-07-13 20:35:12 -05003368/*
3369 * Note this shows the features for whatever's mapped, which is not
3370 * necessarily the base image.
3371 */
3372static ssize_t rbd_features_show(struct device *dev,
3373 struct device_attribute *attr, char *buf)
3374{
3375 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3376
3377 return sprintf(buf, "0x%016llx\n",
Alex Elderfc71d832013-04-26 15:44:36 -05003378 (unsigned long long)rbd_dev->mapping.features);
Alex Elder34b13182012-07-13 20:35:12 -05003379}
3380
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003381static ssize_t rbd_major_show(struct device *dev,
3382 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003383{
Alex Elder593a9e72012-02-07 12:03:37 -06003384 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003385
Alex Elderfc71d832013-04-26 15:44:36 -05003386 if (rbd_dev->major)
3387 return sprintf(buf, "%d\n", rbd_dev->major);
3388
3389 return sprintf(buf, "(none)\n");
3390
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003391}
3392
3393static ssize_t rbd_client_id_show(struct device *dev,
3394 struct device_attribute *attr, char *buf)
3395{
Alex Elder593a9e72012-02-07 12:03:37 -06003396 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003397
Alex Elder1dbb4392012-01-24 10:08:37 -06003398 return sprintf(buf, "client%lld\n",
3399 ceph_client_id(rbd_dev->rbd_client->client));
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003400}
3401
3402static ssize_t rbd_pool_show(struct device *dev,
3403 struct device_attribute *attr, char *buf)
3404{
Alex Elder593a9e72012-02-07 12:03:37 -06003405 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003406
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003407 return sprintf(buf, "%s\n", rbd_dev->spec->pool_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003408}
3409
Alex Elder9bb2f332012-07-12 10:46:35 -05003410static ssize_t rbd_pool_id_show(struct device *dev,
3411 struct device_attribute *attr, char *buf)
3412{
3413 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3414
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003415 return sprintf(buf, "%llu\n",
Alex Elderfc71d832013-04-26 15:44:36 -05003416 (unsigned long long) rbd_dev->spec->pool_id);
Alex Elder9bb2f332012-07-12 10:46:35 -05003417}
3418
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003419static ssize_t rbd_name_show(struct device *dev,
3420 struct device_attribute *attr, char *buf)
3421{
Alex Elder593a9e72012-02-07 12:03:37 -06003422 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003423
Alex Eldera92ffdf2012-10-30 19:40:33 -05003424 if (rbd_dev->spec->image_name)
3425 return sprintf(buf, "%s\n", rbd_dev->spec->image_name);
3426
3427 return sprintf(buf, "(unknown)\n");
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003428}
3429
Alex Elder589d30e2012-07-10 20:30:11 -05003430static ssize_t rbd_image_id_show(struct device *dev,
3431 struct device_attribute *attr, char *buf)
3432{
3433 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3434
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003435 return sprintf(buf, "%s\n", rbd_dev->spec->image_id);
Alex Elder589d30e2012-07-10 20:30:11 -05003436}
3437
Alex Elder34b13182012-07-13 20:35:12 -05003438/*
3439 * Shows the name of the currently-mapped snapshot (or
3440 * RBD_SNAP_HEAD_NAME for the base image).
3441 */
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003442static ssize_t rbd_snap_show(struct device *dev,
3443 struct device_attribute *attr,
3444 char *buf)
3445{
Alex Elder593a9e72012-02-07 12:03:37 -06003446 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003447
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003448 return sprintf(buf, "%s\n", rbd_dev->spec->snap_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003449}
3450
Alex Elder86b00e02012-10-25 23:34:42 -05003451/*
3452 * For an rbd v2 image, shows the pool id, image id, and snapshot id
3453 * for the parent image. If there is no parent, simply shows
3454 * "(no parent image)".
3455 */
3456static ssize_t rbd_parent_show(struct device *dev,
3457 struct device_attribute *attr,
3458 char *buf)
3459{
3460 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3461 struct rbd_spec *spec = rbd_dev->parent_spec;
3462 int count;
3463 char *bufp = buf;
3464
3465 if (!spec)
3466 return sprintf(buf, "(no parent image)\n");
3467
3468 count = sprintf(bufp, "pool_id %llu\npool_name %s\n",
3469 (unsigned long long) spec->pool_id, spec->pool_name);
3470 if (count < 0)
3471 return count;
3472 bufp += count;
3473
3474 count = sprintf(bufp, "image_id %s\nimage_name %s\n", spec->image_id,
3475 spec->image_name ? spec->image_name : "(unknown)");
3476 if (count < 0)
3477 return count;
3478 bufp += count;
3479
3480 count = sprintf(bufp, "snap_id %llu\nsnap_name %s\n",
3481 (unsigned long long) spec->snap_id, spec->snap_name);
3482 if (count < 0)
3483 return count;
3484 bufp += count;
3485
3486 count = sprintf(bufp, "overlap %llu\n", rbd_dev->parent_overlap);
3487 if (count < 0)
3488 return count;
3489 bufp += count;
3490
3491 return (ssize_t) (bufp - buf);
3492}
3493
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003494static ssize_t rbd_image_refresh(struct device *dev,
3495 struct device_attribute *attr,
3496 const char *buf,
3497 size_t size)
3498{
Alex Elder593a9e72012-02-07 12:03:37 -06003499 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Alex Elderb8136232012-07-25 09:32:41 -05003500 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003501
Alex Eldercc4a38bd2013-04-30 00:44:33 -05003502 ret = rbd_dev_refresh(rbd_dev);
Alex Eldere627db02013-05-06 07:40:30 -05003503 if (ret)
3504 rbd_warn(rbd_dev, ": manual header refresh error (%d)\n", ret);
Alex Elderb8136232012-07-25 09:32:41 -05003505
3506 return ret < 0 ? ret : size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003507}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003508
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003509static DEVICE_ATTR(size, S_IRUGO, rbd_size_show, NULL);
Alex Elder34b13182012-07-13 20:35:12 -05003510static DEVICE_ATTR(features, S_IRUGO, rbd_features_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003511static DEVICE_ATTR(major, S_IRUGO, rbd_major_show, NULL);
3512static DEVICE_ATTR(client_id, S_IRUGO, rbd_client_id_show, NULL);
3513static DEVICE_ATTR(pool, S_IRUGO, rbd_pool_show, NULL);
Alex Elder9bb2f332012-07-12 10:46:35 -05003514static DEVICE_ATTR(pool_id, S_IRUGO, rbd_pool_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003515static DEVICE_ATTR(name, S_IRUGO, rbd_name_show, NULL);
Alex Elder589d30e2012-07-10 20:30:11 -05003516static DEVICE_ATTR(image_id, S_IRUGO, rbd_image_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003517static DEVICE_ATTR(refresh, S_IWUSR, NULL, rbd_image_refresh);
3518static DEVICE_ATTR(current_snap, S_IRUGO, rbd_snap_show, NULL);
Alex Elder86b00e02012-10-25 23:34:42 -05003519static DEVICE_ATTR(parent, S_IRUGO, rbd_parent_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003520
3521static struct attribute *rbd_attrs[] = {
3522 &dev_attr_size.attr,
Alex Elder34b13182012-07-13 20:35:12 -05003523 &dev_attr_features.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003524 &dev_attr_major.attr,
3525 &dev_attr_client_id.attr,
3526 &dev_attr_pool.attr,
Alex Elder9bb2f332012-07-12 10:46:35 -05003527 &dev_attr_pool_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003528 &dev_attr_name.attr,
Alex Elder589d30e2012-07-10 20:30:11 -05003529 &dev_attr_image_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003530 &dev_attr_current_snap.attr,
Alex Elder86b00e02012-10-25 23:34:42 -05003531 &dev_attr_parent.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003532 &dev_attr_refresh.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003533 NULL
3534};
3535
3536static struct attribute_group rbd_attr_group = {
3537 .attrs = rbd_attrs,
3538};
3539
3540static const struct attribute_group *rbd_attr_groups[] = {
3541 &rbd_attr_group,
3542 NULL
3543};
3544
3545static void rbd_sysfs_dev_release(struct device *dev)
3546{
3547}
3548
3549static struct device_type rbd_device_type = {
3550 .name = "rbd",
3551 .groups = rbd_attr_groups,
3552 .release = rbd_sysfs_dev_release,
3553};
3554
Alex Elder8b8fb992012-10-26 17:25:24 -05003555static struct rbd_spec *rbd_spec_get(struct rbd_spec *spec)
3556{
3557 kref_get(&spec->kref);
3558
3559 return spec;
3560}
3561
3562static void rbd_spec_free(struct kref *kref);
3563static void rbd_spec_put(struct rbd_spec *spec)
3564{
3565 if (spec)
3566 kref_put(&spec->kref, rbd_spec_free);
3567}
3568
3569static struct rbd_spec *rbd_spec_alloc(void)
3570{
3571 struct rbd_spec *spec;
3572
3573 spec = kzalloc(sizeof (*spec), GFP_KERNEL);
3574 if (!spec)
3575 return NULL;
3576 kref_init(&spec->kref);
3577
Alex Elder8b8fb992012-10-26 17:25:24 -05003578 return spec;
3579}
3580
3581static void rbd_spec_free(struct kref *kref)
3582{
3583 struct rbd_spec *spec = container_of(kref, struct rbd_spec, kref);
3584
3585 kfree(spec->pool_name);
3586 kfree(spec->image_id);
3587 kfree(spec->image_name);
3588 kfree(spec->snap_name);
3589 kfree(spec);
3590}
3591
Alex Eldercc344fa2013-02-19 12:25:56 -06003592static struct rbd_device *rbd_dev_create(struct rbd_client *rbdc,
Alex Elderc53d5892012-10-25 23:34:42 -05003593 struct rbd_spec *spec)
3594{
3595 struct rbd_device *rbd_dev;
3596
3597 rbd_dev = kzalloc(sizeof (*rbd_dev), GFP_KERNEL);
3598 if (!rbd_dev)
3599 return NULL;
3600
3601 spin_lock_init(&rbd_dev->lock);
Alex Elder6d292902013-01-14 12:43:31 -06003602 rbd_dev->flags = 0;
Alex Eldera2acd002013-05-08 22:50:04 -05003603 atomic_set(&rbd_dev->parent_ref, 0);
Alex Elderc53d5892012-10-25 23:34:42 -05003604 INIT_LIST_HEAD(&rbd_dev->node);
Alex Elderc53d5892012-10-25 23:34:42 -05003605 init_rwsem(&rbd_dev->header_rwsem);
3606
3607 rbd_dev->spec = spec;
3608 rbd_dev->rbd_client = rbdc;
3609
Alex Elder0903e872012-11-14 12:25:19 -06003610 /* Initialize the layout used for all rbd requests */
3611
3612 rbd_dev->layout.fl_stripe_unit = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
3613 rbd_dev->layout.fl_stripe_count = cpu_to_le32(1);
3614 rbd_dev->layout.fl_object_size = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
3615 rbd_dev->layout.fl_pg_pool = cpu_to_le32((u32) spec->pool_id);
3616
Alex Elderc53d5892012-10-25 23:34:42 -05003617 return rbd_dev;
3618}
3619
3620static void rbd_dev_destroy(struct rbd_device *rbd_dev)
3621{
Alex Elderc53d5892012-10-25 23:34:42 -05003622 rbd_put_client(rbd_dev->rbd_client);
3623 rbd_spec_put(rbd_dev->spec);
3624 kfree(rbd_dev);
3625}
3626
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003627/*
Alex Elder9d475de52012-07-03 16:01:19 -05003628 * Get the size and object order for an image snapshot, or if
3629 * snap_id is CEPH_NOSNAP, gets this information for the base
3630 * image.
3631 */
3632static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
3633 u8 *order, u64 *snap_size)
3634{
3635 __le64 snapid = cpu_to_le64(snap_id);
3636 int ret;
3637 struct {
3638 u8 order;
3639 __le64 size;
3640 } __attribute__ ((packed)) size_buf = { 0 };
3641
Alex Elder36be9a72013-01-19 00:30:28 -06003642 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder9d475de52012-07-03 16:01:19 -05003643 "rbd", "get_size",
Alex Elder41579762013-04-21 12:14:45 -05003644 &snapid, sizeof (snapid),
Alex Eldere2a58ee2013-04-30 00:44:33 -05003645 &size_buf, sizeof (size_buf));
Alex Elder36be9a72013-01-19 00:30:28 -06003646 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder9d475de52012-07-03 16:01:19 -05003647 if (ret < 0)
3648 return ret;
Alex Elder57385b52013-04-21 12:14:45 -05003649 if (ret < sizeof (size_buf))
3650 return -ERANGE;
Alex Elder9d475de52012-07-03 16:01:19 -05003651
Alex Elderc86f86e2013-04-25 15:09:41 -05003652 if (order)
3653 *order = size_buf.order;
Alex Elder9d475de52012-07-03 16:01:19 -05003654 *snap_size = le64_to_cpu(size_buf.size);
3655
3656 dout(" snap_id 0x%016llx order = %u, snap_size = %llu\n",
Alex Elder57385b52013-04-21 12:14:45 -05003657 (unsigned long long)snap_id, (unsigned int)*order,
3658 (unsigned long long)*snap_size);
Alex Elder9d475de52012-07-03 16:01:19 -05003659
3660 return 0;
3661}
3662
3663static int rbd_dev_v2_image_size(struct rbd_device *rbd_dev)
3664{
3665 return _rbd_dev_v2_snap_size(rbd_dev, CEPH_NOSNAP,
3666 &rbd_dev->header.obj_order,
3667 &rbd_dev->header.image_size);
3668}
3669
Alex Elder1e130192012-07-03 16:01:19 -05003670static int rbd_dev_v2_object_prefix(struct rbd_device *rbd_dev)
3671{
3672 void *reply_buf;
3673 int ret;
3674 void *p;
3675
3676 reply_buf = kzalloc(RBD_OBJ_PREFIX_LEN_MAX, GFP_KERNEL);
3677 if (!reply_buf)
3678 return -ENOMEM;
3679
Alex Elder36be9a72013-01-19 00:30:28 -06003680 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder41579762013-04-21 12:14:45 -05003681 "rbd", "get_object_prefix", NULL, 0,
Alex Eldere2a58ee2013-04-30 00:44:33 -05003682 reply_buf, RBD_OBJ_PREFIX_LEN_MAX);
Alex Elder36be9a72013-01-19 00:30:28 -06003683 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder1e130192012-07-03 16:01:19 -05003684 if (ret < 0)
3685 goto out;
3686
3687 p = reply_buf;
3688 rbd_dev->header.object_prefix = ceph_extract_encoded_string(&p,
Alex Elder57385b52013-04-21 12:14:45 -05003689 p + ret, NULL, GFP_NOIO);
3690 ret = 0;
Alex Elder1e130192012-07-03 16:01:19 -05003691
3692 if (IS_ERR(rbd_dev->header.object_prefix)) {
3693 ret = PTR_ERR(rbd_dev->header.object_prefix);
3694 rbd_dev->header.object_prefix = NULL;
3695 } else {
3696 dout(" object_prefix = %s\n", rbd_dev->header.object_prefix);
3697 }
Alex Elder1e130192012-07-03 16:01:19 -05003698out:
3699 kfree(reply_buf);
3700
3701 return ret;
3702}
3703
Alex Elderb1b54022012-07-03 16:01:19 -05003704static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
3705 u64 *snap_features)
3706{
3707 __le64 snapid = cpu_to_le64(snap_id);
3708 struct {
3709 __le64 features;
3710 __le64 incompat;
Alex Elder41579762013-04-21 12:14:45 -05003711 } __attribute__ ((packed)) features_buf = { 0 };
Alex Elderd8891402012-10-09 13:50:17 -07003712 u64 incompat;
Alex Elderb1b54022012-07-03 16:01:19 -05003713 int ret;
3714
Alex Elder36be9a72013-01-19 00:30:28 -06003715 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elderb1b54022012-07-03 16:01:19 -05003716 "rbd", "get_features",
Alex Elder41579762013-04-21 12:14:45 -05003717 &snapid, sizeof (snapid),
Alex Eldere2a58ee2013-04-30 00:44:33 -05003718 &features_buf, sizeof (features_buf));
Alex Elder36be9a72013-01-19 00:30:28 -06003719 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elderb1b54022012-07-03 16:01:19 -05003720 if (ret < 0)
3721 return ret;
Alex Elder57385b52013-04-21 12:14:45 -05003722 if (ret < sizeof (features_buf))
3723 return -ERANGE;
Alex Elderd8891402012-10-09 13:50:17 -07003724
3725 incompat = le64_to_cpu(features_buf.incompat);
Alex Elder5cbf6f122013-04-11 09:29:48 -05003726 if (incompat & ~RBD_FEATURES_SUPPORTED)
Alex Elderb8f5c6e2012-11-01 08:39:26 -05003727 return -ENXIO;
Alex Elderd8891402012-10-09 13:50:17 -07003728
Alex Elderb1b54022012-07-03 16:01:19 -05003729 *snap_features = le64_to_cpu(features_buf.features);
3730
3731 dout(" snap_id 0x%016llx features = 0x%016llx incompat = 0x%016llx\n",
Alex Elder57385b52013-04-21 12:14:45 -05003732 (unsigned long long)snap_id,
3733 (unsigned long long)*snap_features,
3734 (unsigned long long)le64_to_cpu(features_buf.incompat));
Alex Elderb1b54022012-07-03 16:01:19 -05003735
3736 return 0;
3737}
3738
3739static int rbd_dev_v2_features(struct rbd_device *rbd_dev)
3740{
3741 return _rbd_dev_v2_snap_features(rbd_dev, CEPH_NOSNAP,
3742 &rbd_dev->header.features);
3743}
3744
Alex Elder86b00e02012-10-25 23:34:42 -05003745static int rbd_dev_v2_parent_info(struct rbd_device *rbd_dev)
3746{
3747 struct rbd_spec *parent_spec;
3748 size_t size;
3749 void *reply_buf = NULL;
3750 __le64 snapid;
3751 void *p;
3752 void *end;
Alex Elder642a2532013-05-06 17:40:33 -05003753 u64 pool_id;
Alex Elder86b00e02012-10-25 23:34:42 -05003754 char *image_id;
3755 u64 overlap;
Alex Elder86b00e02012-10-25 23:34:42 -05003756 int ret;
3757
3758 parent_spec = rbd_spec_alloc();
3759 if (!parent_spec)
3760 return -ENOMEM;
3761
3762 size = sizeof (__le64) + /* pool_id */
3763 sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX + /* image_id */
3764 sizeof (__le64) + /* snap_id */
3765 sizeof (__le64); /* overlap */
3766 reply_buf = kmalloc(size, GFP_KERNEL);
3767 if (!reply_buf) {
3768 ret = -ENOMEM;
3769 goto out_err;
3770 }
3771
3772 snapid = cpu_to_le64(CEPH_NOSNAP);
Alex Elder36be9a72013-01-19 00:30:28 -06003773 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder86b00e02012-10-25 23:34:42 -05003774 "rbd", "get_parent",
Alex Elder41579762013-04-21 12:14:45 -05003775 &snapid, sizeof (snapid),
Alex Eldere2a58ee2013-04-30 00:44:33 -05003776 reply_buf, size);
Alex Elder36be9a72013-01-19 00:30:28 -06003777 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder86b00e02012-10-25 23:34:42 -05003778 if (ret < 0)
3779 goto out_err;
3780
Alex Elder86b00e02012-10-25 23:34:42 -05003781 p = reply_buf;
Alex Elder57385b52013-04-21 12:14:45 -05003782 end = reply_buf + ret;
3783 ret = -ERANGE;
Alex Elder642a2532013-05-06 17:40:33 -05003784 ceph_decode_64_safe(&p, end, pool_id, out_err);
3785 if (pool_id == CEPH_NOPOOL)
Alex Elder86b00e02012-10-25 23:34:42 -05003786 goto out; /* No parent? No problem. */
3787
Alex Elder0903e872012-11-14 12:25:19 -06003788 /* The ceph file layout needs to fit pool id in 32 bits */
3789
3790 ret = -EIO;
Alex Elder642a2532013-05-06 17:40:33 -05003791 if (pool_id > (u64)U32_MAX) {
Alex Elderc0cd10db2013-04-26 09:43:47 -05003792 rbd_warn(NULL, "parent pool id too large (%llu > %u)\n",
Alex Elder642a2532013-05-06 17:40:33 -05003793 (unsigned long long)pool_id, U32_MAX);
Alex Elder57385b52013-04-21 12:14:45 -05003794 goto out_err;
Alex Elderc0cd10db2013-04-26 09:43:47 -05003795 }
Alex Elder642a2532013-05-06 17:40:33 -05003796 parent_spec->pool_id = pool_id;
Alex Elder0903e872012-11-14 12:25:19 -06003797
Alex Elder979ed482012-11-01 08:39:26 -05003798 image_id = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
Alex Elder86b00e02012-10-25 23:34:42 -05003799 if (IS_ERR(image_id)) {
3800 ret = PTR_ERR(image_id);
3801 goto out_err;
3802 }
3803 parent_spec->image_id = image_id;
3804 ceph_decode_64_safe(&p, end, parent_spec->snap_id, out_err);
3805 ceph_decode_64_safe(&p, end, overlap, out_err);
3806
Alex Elder70cf49c2013-05-06 17:40:33 -05003807 if (overlap) {
Alex Elder642a2532013-05-06 17:40:33 -05003808 rbd_spec_put(rbd_dev->parent_spec);
Alex Elder70cf49c2013-05-06 17:40:33 -05003809 rbd_dev->parent_spec = parent_spec;
3810 parent_spec = NULL; /* rbd_dev now owns this */
3811 rbd_dev->parent_overlap = overlap;
3812 } else {
3813 rbd_warn(rbd_dev, "ignoring parent of clone with overlap 0\n");
3814 }
Alex Elder86b00e02012-10-25 23:34:42 -05003815out:
3816 ret = 0;
3817out_err:
3818 kfree(reply_buf);
3819 rbd_spec_put(parent_spec);
3820
3821 return ret;
3822}
3823
Alex Eldercc070d52013-04-21 12:14:45 -05003824static int rbd_dev_v2_striping_info(struct rbd_device *rbd_dev)
3825{
3826 struct {
3827 __le64 stripe_unit;
3828 __le64 stripe_count;
3829 } __attribute__ ((packed)) striping_info_buf = { 0 };
3830 size_t size = sizeof (striping_info_buf);
3831 void *p;
3832 u64 obj_size;
3833 u64 stripe_unit;
3834 u64 stripe_count;
3835 int ret;
3836
3837 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
3838 "rbd", "get_stripe_unit_count", NULL, 0,
Alex Eldere2a58ee2013-04-30 00:44:33 -05003839 (char *)&striping_info_buf, size);
Alex Eldercc070d52013-04-21 12:14:45 -05003840 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
3841 if (ret < 0)
3842 return ret;
3843 if (ret < size)
3844 return -ERANGE;
3845
3846 /*
3847 * We don't actually support the "fancy striping" feature
3848 * (STRIPINGV2) yet, but if the striping sizes are the
3849 * defaults the behavior is the same as before. So find
3850 * out, and only fail if the image has non-default values.
3851 */
3852 ret = -EINVAL;
3853 obj_size = (u64)1 << rbd_dev->header.obj_order;
3854 p = &striping_info_buf;
3855 stripe_unit = ceph_decode_64(&p);
3856 if (stripe_unit != obj_size) {
3857 rbd_warn(rbd_dev, "unsupported stripe unit "
3858 "(got %llu want %llu)",
3859 stripe_unit, obj_size);
3860 return -EINVAL;
3861 }
3862 stripe_count = ceph_decode_64(&p);
3863 if (stripe_count != 1) {
3864 rbd_warn(rbd_dev, "unsupported stripe count "
3865 "(got %llu want 1)", stripe_count);
3866 return -EINVAL;
3867 }
Alex Elder500d0c0f2013-04-26 09:43:47 -05003868 rbd_dev->header.stripe_unit = stripe_unit;
3869 rbd_dev->header.stripe_count = stripe_count;
Alex Eldercc070d52013-04-21 12:14:45 -05003870
3871 return 0;
3872}
3873
Alex Elder9e15b772012-10-30 19:40:33 -05003874static char *rbd_dev_image_name(struct rbd_device *rbd_dev)
3875{
3876 size_t image_id_size;
3877 char *image_id;
3878 void *p;
3879 void *end;
3880 size_t size;
3881 void *reply_buf = NULL;
3882 size_t len = 0;
3883 char *image_name = NULL;
3884 int ret;
3885
3886 rbd_assert(!rbd_dev->spec->image_name);
3887
Alex Elder69e7a022012-11-01 08:39:26 -05003888 len = strlen(rbd_dev->spec->image_id);
3889 image_id_size = sizeof (__le32) + len;
Alex Elder9e15b772012-10-30 19:40:33 -05003890 image_id = kmalloc(image_id_size, GFP_KERNEL);
3891 if (!image_id)
3892 return NULL;
3893
3894 p = image_id;
Alex Elder41579762013-04-21 12:14:45 -05003895 end = image_id + image_id_size;
Alex Elder57385b52013-04-21 12:14:45 -05003896 ceph_encode_string(&p, end, rbd_dev->spec->image_id, (u32)len);
Alex Elder9e15b772012-10-30 19:40:33 -05003897
3898 size = sizeof (__le32) + RBD_IMAGE_NAME_LEN_MAX;
3899 reply_buf = kmalloc(size, GFP_KERNEL);
3900 if (!reply_buf)
3901 goto out;
3902
Alex Elder36be9a72013-01-19 00:30:28 -06003903 ret = rbd_obj_method_sync(rbd_dev, RBD_DIRECTORY,
Alex Elder9e15b772012-10-30 19:40:33 -05003904 "rbd", "dir_get_name",
3905 image_id, image_id_size,
Alex Eldere2a58ee2013-04-30 00:44:33 -05003906 reply_buf, size);
Alex Elder9e15b772012-10-30 19:40:33 -05003907 if (ret < 0)
3908 goto out;
3909 p = reply_buf;
Alex Elderf40eb342013-04-25 15:09:42 -05003910 end = reply_buf + ret;
3911
Alex Elder9e15b772012-10-30 19:40:33 -05003912 image_name = ceph_extract_encoded_string(&p, end, &len, GFP_KERNEL);
3913 if (IS_ERR(image_name))
3914 image_name = NULL;
3915 else
3916 dout("%s: name is %s len is %zd\n", __func__, image_name, len);
3917out:
3918 kfree(reply_buf);
3919 kfree(image_id);
3920
3921 return image_name;
3922}
3923
Alex Elder2ad3d712013-04-30 00:44:33 -05003924static u64 rbd_v1_snap_id_by_name(struct rbd_device *rbd_dev, const char *name)
3925{
3926 struct ceph_snap_context *snapc = rbd_dev->header.snapc;
3927 const char *snap_name;
3928 u32 which = 0;
3929
3930 /* Skip over names until we find the one we are looking for */
3931
3932 snap_name = rbd_dev->header.snap_names;
3933 while (which < snapc->num_snaps) {
3934 if (!strcmp(name, snap_name))
3935 return snapc->snaps[which];
3936 snap_name += strlen(snap_name) + 1;
3937 which++;
3938 }
3939 return CEPH_NOSNAP;
3940}
3941
3942static u64 rbd_v2_snap_id_by_name(struct rbd_device *rbd_dev, const char *name)
3943{
3944 struct ceph_snap_context *snapc = rbd_dev->header.snapc;
3945 u32 which;
3946 bool found = false;
3947 u64 snap_id;
3948
3949 for (which = 0; !found && which < snapc->num_snaps; which++) {
3950 const char *snap_name;
3951
3952 snap_id = snapc->snaps[which];
3953 snap_name = rbd_dev_v2_snap_name(rbd_dev, snap_id);
3954 if (IS_ERR(snap_name))
3955 break;
3956 found = !strcmp(name, snap_name);
3957 kfree(snap_name);
3958 }
3959 return found ? snap_id : CEPH_NOSNAP;
3960}
3961
3962/*
3963 * Assumes name is never RBD_SNAP_HEAD_NAME; returns CEPH_NOSNAP if
3964 * no snapshot by that name is found, or if an error occurs.
3965 */
3966static u64 rbd_snap_id_by_name(struct rbd_device *rbd_dev, const char *name)
3967{
3968 if (rbd_dev->image_format == 1)
3969 return rbd_v1_snap_id_by_name(rbd_dev, name);
3970
3971 return rbd_v2_snap_id_by_name(rbd_dev, name);
3972}
3973
Alex Elder9e15b772012-10-30 19:40:33 -05003974/*
Alex Elder2e9f7f12013-04-26 09:43:48 -05003975 * When an rbd image has a parent image, it is identified by the
3976 * pool, image, and snapshot ids (not names). This function fills
3977 * in the names for those ids. (It's OK if we can't figure out the
3978 * name for an image id, but the pool and snapshot ids should always
3979 * exist and have names.) All names in an rbd spec are dynamically
3980 * allocated.
Alex Eldere1d42132013-04-25 23:15:08 -05003981 *
3982 * When an image being mapped (not a parent) is probed, we have the
3983 * pool name and pool id, image name and image id, and the snapshot
3984 * name. The only thing we're missing is the snapshot id.
Alex Elder9e15b772012-10-30 19:40:33 -05003985 */
Alex Elder2e9f7f12013-04-26 09:43:48 -05003986static int rbd_dev_spec_update(struct rbd_device *rbd_dev)
Alex Elder9e15b772012-10-30 19:40:33 -05003987{
Alex Elder2e9f7f12013-04-26 09:43:48 -05003988 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
3989 struct rbd_spec *spec = rbd_dev->spec;
3990 const char *pool_name;
3991 const char *image_name;
3992 const char *snap_name;
Alex Elder9e15b772012-10-30 19:40:33 -05003993 int ret;
3994
Alex Eldere1d42132013-04-25 23:15:08 -05003995 /*
3996 * An image being mapped will have the pool name (etc.), but
3997 * we need to look up the snapshot id.
3998 */
Alex Elder2e9f7f12013-04-26 09:43:48 -05003999 if (spec->pool_name) {
4000 if (strcmp(spec->snap_name, RBD_SNAP_HEAD_NAME)) {
Alex Elder2ad3d712013-04-30 00:44:33 -05004001 u64 snap_id;
Alex Eldere1d42132013-04-25 23:15:08 -05004002
Alex Elder2ad3d712013-04-30 00:44:33 -05004003 snap_id = rbd_snap_id_by_name(rbd_dev, spec->snap_name);
4004 if (snap_id == CEPH_NOSNAP)
Alex Eldere1d42132013-04-25 23:15:08 -05004005 return -ENOENT;
Alex Elder2ad3d712013-04-30 00:44:33 -05004006 spec->snap_id = snap_id;
Alex Eldere1d42132013-04-25 23:15:08 -05004007 } else {
Alex Elder2e9f7f12013-04-26 09:43:48 -05004008 spec->snap_id = CEPH_NOSNAP;
Alex Eldere1d42132013-04-25 23:15:08 -05004009 }
4010
4011 return 0;
4012 }
Alex Elder9e15b772012-10-30 19:40:33 -05004013
Alex Elder2e9f7f12013-04-26 09:43:48 -05004014 /* Get the pool name; we have to make our own copy of this */
Alex Elder9e15b772012-10-30 19:40:33 -05004015
Alex Elder2e9f7f12013-04-26 09:43:48 -05004016 pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, spec->pool_id);
4017 if (!pool_name) {
4018 rbd_warn(rbd_dev, "no pool with id %llu", spec->pool_id);
Alex Elder935dc892012-11-01 10:17:15 -05004019 return -EIO;
4020 }
Alex Elder2e9f7f12013-04-26 09:43:48 -05004021 pool_name = kstrdup(pool_name, GFP_KERNEL);
4022 if (!pool_name)
Alex Elder9e15b772012-10-30 19:40:33 -05004023 return -ENOMEM;
4024
4025 /* Fetch the image name; tolerate failure here */
4026
Alex Elder2e9f7f12013-04-26 09:43:48 -05004027 image_name = rbd_dev_image_name(rbd_dev);
4028 if (!image_name)
Alex Elder06ecc6c2012-11-01 10:17:15 -05004029 rbd_warn(rbd_dev, "unable to get image name");
Alex Elder9e15b772012-10-30 19:40:33 -05004030
Alex Elder2e9f7f12013-04-26 09:43:48 -05004031 /* Look up the snapshot name, and make a copy */
Alex Elder9e15b772012-10-30 19:40:33 -05004032
Alex Elder2e9f7f12013-04-26 09:43:48 -05004033 snap_name = rbd_snap_name(rbd_dev, spec->snap_id);
4034 if (!snap_name) {
Alex Elder2e9f7f12013-04-26 09:43:48 -05004035 ret = -ENOMEM;
Alex Elder9e15b772012-10-30 19:40:33 -05004036 goto out_err;
Alex Elder2e9f7f12013-04-26 09:43:48 -05004037 }
4038
4039 spec->pool_name = pool_name;
4040 spec->image_name = image_name;
4041 spec->snap_name = snap_name;
Alex Elder9e15b772012-10-30 19:40:33 -05004042
4043 return 0;
4044out_err:
Alex Elder2e9f7f12013-04-26 09:43:48 -05004045 kfree(image_name);
4046 kfree(pool_name);
Alex Elder9e15b772012-10-30 19:40:33 -05004047
4048 return ret;
4049}
4050
Alex Eldercc4a38bd2013-04-30 00:44:33 -05004051static int rbd_dev_v2_snap_context(struct rbd_device *rbd_dev)
Alex Elder35d489f2012-07-03 16:01:19 -05004052{
4053 size_t size;
4054 int ret;
4055 void *reply_buf;
4056 void *p;
4057 void *end;
4058 u64 seq;
4059 u32 snap_count;
4060 struct ceph_snap_context *snapc;
4061 u32 i;
4062
4063 /*
4064 * We'll need room for the seq value (maximum snapshot id),
4065 * snapshot count, and array of that many snapshot ids.
4066 * For now we have a fixed upper limit on the number we're
4067 * prepared to receive.
4068 */
4069 size = sizeof (__le64) + sizeof (__le32) +
4070 RBD_MAX_SNAP_COUNT * sizeof (__le64);
4071 reply_buf = kzalloc(size, GFP_KERNEL);
4072 if (!reply_buf)
4073 return -ENOMEM;
4074
Alex Elder36be9a72013-01-19 00:30:28 -06004075 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder41579762013-04-21 12:14:45 -05004076 "rbd", "get_snapcontext", NULL, 0,
Alex Eldere2a58ee2013-04-30 00:44:33 -05004077 reply_buf, size);
Alex Elder36be9a72013-01-19 00:30:28 -06004078 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder35d489f2012-07-03 16:01:19 -05004079 if (ret < 0)
4080 goto out;
4081
Alex Elder35d489f2012-07-03 16:01:19 -05004082 p = reply_buf;
Alex Elder57385b52013-04-21 12:14:45 -05004083 end = reply_buf + ret;
4084 ret = -ERANGE;
Alex Elder35d489f2012-07-03 16:01:19 -05004085 ceph_decode_64_safe(&p, end, seq, out);
4086 ceph_decode_32_safe(&p, end, snap_count, out);
4087
4088 /*
4089 * Make sure the reported number of snapshot ids wouldn't go
4090 * beyond the end of our buffer. But before checking that,
4091 * make sure the computed size of the snapshot context we
4092 * allocate is representable in a size_t.
4093 */
4094 if (snap_count > (SIZE_MAX - sizeof (struct ceph_snap_context))
4095 / sizeof (u64)) {
4096 ret = -EINVAL;
4097 goto out;
4098 }
4099 if (!ceph_has_room(&p, end, snap_count * sizeof (__le64)))
4100 goto out;
Alex Elder468521c2013-04-26 09:43:47 -05004101 ret = 0;
Alex Elder35d489f2012-07-03 16:01:19 -05004102
Alex Elder812164f82013-04-30 00:44:32 -05004103 snapc = ceph_create_snap_context(snap_count, GFP_KERNEL);
Alex Elder35d489f2012-07-03 16:01:19 -05004104 if (!snapc) {
4105 ret = -ENOMEM;
4106 goto out;
4107 }
Alex Elder35d489f2012-07-03 16:01:19 -05004108 snapc->seq = seq;
Alex Elder35d489f2012-07-03 16:01:19 -05004109 for (i = 0; i < snap_count; i++)
4110 snapc->snaps[i] = ceph_decode_64(&p);
4111
Alex Elder49ece552013-05-06 08:37:00 -05004112 ceph_put_snap_context(rbd_dev->header.snapc);
Alex Elder35d489f2012-07-03 16:01:19 -05004113 rbd_dev->header.snapc = snapc;
4114
4115 dout(" snap context seq = %llu, snap_count = %u\n",
Alex Elder57385b52013-04-21 12:14:45 -05004116 (unsigned long long)seq, (unsigned int)snap_count);
Alex Elder35d489f2012-07-03 16:01:19 -05004117out:
4118 kfree(reply_buf);
4119
Alex Elder57385b52013-04-21 12:14:45 -05004120 return ret;
Alex Elder35d489f2012-07-03 16:01:19 -05004121}
4122
Alex Elder54cac612013-04-30 00:44:33 -05004123static const char *rbd_dev_v2_snap_name(struct rbd_device *rbd_dev,
4124 u64 snap_id)
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004125{
4126 size_t size;
4127 void *reply_buf;
Alex Elder54cac612013-04-30 00:44:33 -05004128 __le64 snapid;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004129 int ret;
4130 void *p;
4131 void *end;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004132 char *snap_name;
4133
4134 size = sizeof (__le32) + RBD_MAX_SNAP_NAME_LEN;
4135 reply_buf = kmalloc(size, GFP_KERNEL);
4136 if (!reply_buf)
4137 return ERR_PTR(-ENOMEM);
4138
Alex Elder54cac612013-04-30 00:44:33 -05004139 snapid = cpu_to_le64(snap_id);
Alex Elder36be9a72013-01-19 00:30:28 -06004140 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004141 "rbd", "get_snapshot_name",
Alex Elder54cac612013-04-30 00:44:33 -05004142 &snapid, sizeof (snapid),
Alex Eldere2a58ee2013-04-30 00:44:33 -05004143 reply_buf, size);
Alex Elder36be9a72013-01-19 00:30:28 -06004144 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elderf40eb342013-04-25 15:09:42 -05004145 if (ret < 0) {
4146 snap_name = ERR_PTR(ret);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004147 goto out;
Alex Elderf40eb342013-04-25 15:09:42 -05004148 }
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004149
4150 p = reply_buf;
Alex Elderf40eb342013-04-25 15:09:42 -05004151 end = reply_buf + ret;
Alex Eldere5c35532012-10-25 23:34:41 -05004152 snap_name = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
Alex Elderf40eb342013-04-25 15:09:42 -05004153 if (IS_ERR(snap_name))
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004154 goto out;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004155
Alex Elderf40eb342013-04-25 15:09:42 -05004156 dout(" snap_id 0x%016llx snap_name = %s\n",
Alex Elder54cac612013-04-30 00:44:33 -05004157 (unsigned long long)snap_id, snap_name);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004158out:
4159 kfree(reply_buf);
4160
Alex Elderf40eb342013-04-25 15:09:42 -05004161 return snap_name;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004162}
4163
Alex Elder2df3fac2013-05-06 09:51:30 -05004164static int rbd_dev_v2_header_info(struct rbd_device *rbd_dev)
Alex Elder117973f2012-08-31 17:29:55 -05004165{
Alex Elder2df3fac2013-05-06 09:51:30 -05004166 bool first_time = rbd_dev->header.object_prefix == NULL;
Alex Elder117973f2012-08-31 17:29:55 -05004167 int ret;
Alex Elder117973f2012-08-31 17:29:55 -05004168
4169 down_write(&rbd_dev->header_rwsem);
4170
Alex Elder2df3fac2013-05-06 09:51:30 -05004171 if (first_time) {
4172 ret = rbd_dev_v2_header_onetime(rbd_dev);
4173 if (ret)
4174 goto out;
4175 }
4176
Alex Elder642a2532013-05-06 17:40:33 -05004177 /*
4178 * If the image supports layering, get the parent info. We
4179 * need to probe the first time regardless. Thereafter we
4180 * only need to if there's a parent, to see if it has
4181 * disappeared due to the mapped image getting flattened.
4182 */
4183 if (rbd_dev->header.features & RBD_FEATURE_LAYERING &&
4184 (first_time || rbd_dev->parent_spec)) {
4185 bool warn;
4186
4187 ret = rbd_dev_v2_parent_info(rbd_dev);
4188 if (ret)
4189 goto out;
4190
4191 /*
4192 * Print a warning if this is the initial probe and
4193 * the image has a parent. Don't print it if the
4194 * image now being probed is itself a parent. We
4195 * can tell at this point because we won't know its
4196 * pool name yet (just its pool id).
4197 */
4198 warn = rbd_dev->parent_spec && rbd_dev->spec->pool_name;
4199 if (first_time && warn)
4200 rbd_warn(rbd_dev, "WARNING: kernel layering "
4201 "is EXPERIMENTAL!");
4202 }
4203
Alex Elder117973f2012-08-31 17:29:55 -05004204 ret = rbd_dev_v2_image_size(rbd_dev);
4205 if (ret)
4206 goto out;
Alex Elder642a2532013-05-06 17:40:33 -05004207
Alex Elder29334ba2013-05-06 07:40:30 -05004208 if (rbd_dev->spec->snap_id == CEPH_NOSNAP)
4209 if (rbd_dev->mapping.size != rbd_dev->header.image_size)
4210 rbd_dev->mapping.size = rbd_dev->header.image_size;
Alex Elder117973f2012-08-31 17:29:55 -05004211
Alex Eldercc4a38bd2013-04-30 00:44:33 -05004212 ret = rbd_dev_v2_snap_context(rbd_dev);
Alex Elder117973f2012-08-31 17:29:55 -05004213 dout("rbd_dev_v2_snap_context returned %d\n", ret);
Alex Elder117973f2012-08-31 17:29:55 -05004214out:
4215 up_write(&rbd_dev->header_rwsem);
4216
4217 return ret;
4218}
4219
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004220static int rbd_bus_add_dev(struct rbd_device *rbd_dev)
4221{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004222 struct device *dev;
Alex Eldercd789ab2012-08-30 00:16:38 -05004223 int ret;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004224
4225 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004226
Alex Eldercd789ab2012-08-30 00:16:38 -05004227 dev = &rbd_dev->dev;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004228 dev->bus = &rbd_bus_type;
4229 dev->type = &rbd_device_type;
4230 dev->parent = &rbd_root_dev;
Alex Elder200a6a82013-04-28 23:32:34 -05004231 dev->release = rbd_dev_device_release;
Alex Elderde71a292012-07-03 16:01:19 -05004232 dev_set_name(dev, "%d", rbd_dev->dev_id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004233 ret = device_register(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004234
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004235 mutex_unlock(&ctl_mutex);
Alex Eldercd789ab2012-08-30 00:16:38 -05004236
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004237 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004238}
4239
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004240static void rbd_bus_del_dev(struct rbd_device *rbd_dev)
4241{
4242 device_unregister(&rbd_dev->dev);
4243}
4244
Alex Eldere2839302012-08-29 17:11:06 -05004245static atomic64_t rbd_dev_id_max = ATOMIC64_INIT(0);
Alex Elder1ddbe942012-01-29 13:57:44 -06004246
4247/*
Alex Elder499afd52012-02-02 08:13:29 -06004248 * Get a unique rbd identifier for the given new rbd_dev, and add
4249 * the rbd_dev to the global list. The minimum rbd id is 1.
Alex Elder1ddbe942012-01-29 13:57:44 -06004250 */
Alex Eldere2839302012-08-29 17:11:06 -05004251static void rbd_dev_id_get(struct rbd_device *rbd_dev)
Alex Elderb7f23c32012-01-29 13:57:43 -06004252{
Alex Eldere2839302012-08-29 17:11:06 -05004253 rbd_dev->dev_id = atomic64_inc_return(&rbd_dev_id_max);
Alex Elder499afd52012-02-02 08:13:29 -06004254
4255 spin_lock(&rbd_dev_list_lock);
4256 list_add_tail(&rbd_dev->node, &rbd_dev_list);
4257 spin_unlock(&rbd_dev_list_lock);
Alex Eldere2839302012-08-29 17:11:06 -05004258 dout("rbd_dev %p given dev id %llu\n", rbd_dev,
4259 (unsigned long long) rbd_dev->dev_id);
Alex Elder1ddbe942012-01-29 13:57:44 -06004260}
Alex Elderb7f23c32012-01-29 13:57:43 -06004261
Alex Elder1ddbe942012-01-29 13:57:44 -06004262/*
Alex Elder499afd52012-02-02 08:13:29 -06004263 * Remove an rbd_dev from the global list, and record that its
4264 * identifier is no longer in use.
Alex Elder1ddbe942012-01-29 13:57:44 -06004265 */
Alex Eldere2839302012-08-29 17:11:06 -05004266static void rbd_dev_id_put(struct rbd_device *rbd_dev)
Alex Elder1ddbe942012-01-29 13:57:44 -06004267{
Alex Elderd184f6b2012-01-29 13:57:44 -06004268 struct list_head *tmp;
Alex Elderde71a292012-07-03 16:01:19 -05004269 int rbd_id = rbd_dev->dev_id;
Alex Elderd184f6b2012-01-29 13:57:44 -06004270 int max_id;
4271
Alex Elderaafb2302012-09-06 16:00:54 -05004272 rbd_assert(rbd_id > 0);
Alex Elder499afd52012-02-02 08:13:29 -06004273
Alex Eldere2839302012-08-29 17:11:06 -05004274 dout("rbd_dev %p released dev id %llu\n", rbd_dev,
4275 (unsigned long long) rbd_dev->dev_id);
Alex Elder499afd52012-02-02 08:13:29 -06004276 spin_lock(&rbd_dev_list_lock);
4277 list_del_init(&rbd_dev->node);
Alex Elderd184f6b2012-01-29 13:57:44 -06004278
4279 /*
4280 * If the id being "put" is not the current maximum, there
4281 * is nothing special we need to do.
4282 */
Alex Eldere2839302012-08-29 17:11:06 -05004283 if (rbd_id != atomic64_read(&rbd_dev_id_max)) {
Alex Elderd184f6b2012-01-29 13:57:44 -06004284 spin_unlock(&rbd_dev_list_lock);
4285 return;
4286 }
4287
4288 /*
4289 * We need to update the current maximum id. Search the
4290 * list to find out what it is. We're more likely to find
4291 * the maximum at the end, so search the list backward.
4292 */
4293 max_id = 0;
4294 list_for_each_prev(tmp, &rbd_dev_list) {
4295 struct rbd_device *rbd_dev;
4296
4297 rbd_dev = list_entry(tmp, struct rbd_device, node);
Alex Elderb213e0b2012-10-10 21:19:13 -07004298 if (rbd_dev->dev_id > max_id)
4299 max_id = rbd_dev->dev_id;
Alex Elderd184f6b2012-01-29 13:57:44 -06004300 }
Alex Elder499afd52012-02-02 08:13:29 -06004301 spin_unlock(&rbd_dev_list_lock);
Alex Elderb7f23c32012-01-29 13:57:43 -06004302
Alex Elder1ddbe942012-01-29 13:57:44 -06004303 /*
Alex Eldere2839302012-08-29 17:11:06 -05004304 * The max id could have been updated by rbd_dev_id_get(), in
Alex Elderd184f6b2012-01-29 13:57:44 -06004305 * which case it now accurately reflects the new maximum.
4306 * Be careful not to overwrite the maximum value in that
4307 * case.
Alex Elder1ddbe942012-01-29 13:57:44 -06004308 */
Alex Eldere2839302012-08-29 17:11:06 -05004309 atomic64_cmpxchg(&rbd_dev_id_max, rbd_id, max_id);
4310 dout(" max dev id has been reset\n");
Alex Elderb7f23c32012-01-29 13:57:43 -06004311}
4312
Alex Eldera725f65e2012-02-02 08:13:30 -06004313/*
Alex Eldere28fff262012-02-02 08:13:30 -06004314 * Skips over white space at *buf, and updates *buf to point to the
4315 * first found non-space character (if any). Returns the length of
Alex Elder593a9e72012-02-07 12:03:37 -06004316 * the token (string of non-white space characters) found. Note
4317 * that *buf must be terminated with '\0'.
Alex Eldere28fff262012-02-02 08:13:30 -06004318 */
4319static inline size_t next_token(const char **buf)
4320{
4321 /*
4322 * These are the characters that produce nonzero for
4323 * isspace() in the "C" and "POSIX" locales.
4324 */
4325 const char *spaces = " \f\n\r\t\v";
4326
4327 *buf += strspn(*buf, spaces); /* Find start of token */
4328
4329 return strcspn(*buf, spaces); /* Return token length */
4330}
4331
4332/*
4333 * Finds the next token in *buf, and if the provided token buffer is
4334 * big enough, copies the found token into it. The result, if
Alex Elder593a9e72012-02-07 12:03:37 -06004335 * copied, is guaranteed to be terminated with '\0'. Note that *buf
4336 * must be terminated with '\0' on entry.
Alex Eldere28fff262012-02-02 08:13:30 -06004337 *
4338 * Returns the length of the token found (not including the '\0').
4339 * Return value will be 0 if no token is found, and it will be >=
4340 * token_size if the token would not fit.
4341 *
Alex Elder593a9e72012-02-07 12:03:37 -06004342 * The *buf pointer will be updated to point beyond the end of the
Alex Eldere28fff262012-02-02 08:13:30 -06004343 * found token. Note that this occurs even if the token buffer is
4344 * too small to hold it.
4345 */
4346static inline size_t copy_token(const char **buf,
4347 char *token,
4348 size_t token_size)
4349{
4350 size_t len;
4351
4352 len = next_token(buf);
4353 if (len < token_size) {
4354 memcpy(token, *buf, len);
4355 *(token + len) = '\0';
4356 }
4357 *buf += len;
4358
4359 return len;
4360}
4361
4362/*
Alex Elderea3352f2012-07-09 21:04:23 -05004363 * Finds the next token in *buf, dynamically allocates a buffer big
4364 * enough to hold a copy of it, and copies the token into the new
4365 * buffer. The copy is guaranteed to be terminated with '\0'. Note
4366 * that a duplicate buffer is created even for a zero-length token.
4367 *
4368 * Returns a pointer to the newly-allocated duplicate, or a null
4369 * pointer if memory for the duplicate was not available. If
4370 * the lenp argument is a non-null pointer, the length of the token
4371 * (not including the '\0') is returned in *lenp.
4372 *
4373 * If successful, the *buf pointer will be updated to point beyond
4374 * the end of the found token.
4375 *
4376 * Note: uses GFP_KERNEL for allocation.
4377 */
4378static inline char *dup_token(const char **buf, size_t *lenp)
4379{
4380 char *dup;
4381 size_t len;
4382
4383 len = next_token(buf);
Alex Elder4caf35f2012-11-01 08:39:27 -05004384 dup = kmemdup(*buf, len + 1, GFP_KERNEL);
Alex Elderea3352f2012-07-09 21:04:23 -05004385 if (!dup)
4386 return NULL;
Alex Elderea3352f2012-07-09 21:04:23 -05004387 *(dup + len) = '\0';
4388 *buf += len;
4389
4390 if (lenp)
4391 *lenp = len;
4392
4393 return dup;
4394}
4395
4396/*
Alex Elder859c31d2012-10-25 23:34:42 -05004397 * Parse the options provided for an "rbd add" (i.e., rbd image
4398 * mapping) request. These arrive via a write to /sys/bus/rbd/add,
4399 * and the data written is passed here via a NUL-terminated buffer.
4400 * Returns 0 if successful or an error code otherwise.
Alex Elderd22f76e2012-07-12 10:46:35 -05004401 *
Alex Elder859c31d2012-10-25 23:34:42 -05004402 * The information extracted from these options is recorded in
4403 * the other parameters which return dynamically-allocated
4404 * structures:
4405 * ceph_opts
4406 * The address of a pointer that will refer to a ceph options
4407 * structure. Caller must release the returned pointer using
4408 * ceph_destroy_options() when it is no longer needed.
4409 * rbd_opts
4410 * Address of an rbd options pointer. Fully initialized by
4411 * this function; caller must release with kfree().
4412 * spec
4413 * Address of an rbd image specification pointer. Fully
4414 * initialized by this function based on parsed options.
4415 * Caller must release with rbd_spec_put().
4416 *
4417 * The options passed take this form:
4418 * <mon_addrs> <options> <pool_name> <image_name> [<snap_id>]
4419 * where:
4420 * <mon_addrs>
4421 * A comma-separated list of one or more monitor addresses.
4422 * A monitor address is an ip address, optionally followed
4423 * by a port number (separated by a colon).
4424 * I.e.: ip1[:port1][,ip2[:port2]...]
4425 * <options>
4426 * A comma-separated list of ceph and/or rbd options.
4427 * <pool_name>
4428 * The name of the rados pool containing the rbd image.
4429 * <image_name>
4430 * The name of the image in that pool to map.
4431 * <snap_id>
4432 * An optional snapshot id. If provided, the mapping will
4433 * present data from the image at the time that snapshot was
4434 * created. The image head is used if no snapshot id is
4435 * provided. Snapshot mappings are always read-only.
Alex Eldera725f65e2012-02-02 08:13:30 -06004436 */
Alex Elder859c31d2012-10-25 23:34:42 -05004437static int rbd_add_parse_args(const char *buf,
Alex Elderdc79b112012-10-25 23:34:41 -05004438 struct ceph_options **ceph_opts,
Alex Elder859c31d2012-10-25 23:34:42 -05004439 struct rbd_options **opts,
4440 struct rbd_spec **rbd_spec)
Alex Eldera725f65e2012-02-02 08:13:30 -06004441{
Alex Elderd22f76e2012-07-12 10:46:35 -05004442 size_t len;
Alex Elder859c31d2012-10-25 23:34:42 -05004443 char *options;
Alex Elder0ddebc02012-10-25 23:34:41 -05004444 const char *mon_addrs;
Alex Elderecb4dc222013-04-26 09:43:47 -05004445 char *snap_name;
Alex Elder0ddebc02012-10-25 23:34:41 -05004446 size_t mon_addrs_size;
Alex Elder859c31d2012-10-25 23:34:42 -05004447 struct rbd_spec *spec = NULL;
Alex Elder4e9afeba2012-10-25 23:34:41 -05004448 struct rbd_options *rbd_opts = NULL;
Alex Elder859c31d2012-10-25 23:34:42 -05004449 struct ceph_options *copts;
Alex Elderdc79b112012-10-25 23:34:41 -05004450 int ret;
Alex Eldere28fff262012-02-02 08:13:30 -06004451
4452 /* The first four tokens are required */
4453
Alex Elder7ef32142012-02-02 08:13:30 -06004454 len = next_token(&buf);
Alex Elder4fb5d6712012-11-01 10:17:15 -05004455 if (!len) {
4456 rbd_warn(NULL, "no monitor address(es) provided");
4457 return -EINVAL;
4458 }
Alex Elder0ddebc02012-10-25 23:34:41 -05004459 mon_addrs = buf;
Alex Elderf28e5652012-10-25 23:34:41 -05004460 mon_addrs_size = len + 1;
Alex Elder7ef32142012-02-02 08:13:30 -06004461 buf += len;
Alex Eldera725f65e2012-02-02 08:13:30 -06004462
Alex Elderdc79b112012-10-25 23:34:41 -05004463 ret = -EINVAL;
Alex Elderf28e5652012-10-25 23:34:41 -05004464 options = dup_token(&buf, NULL);
4465 if (!options)
Alex Elderdc79b112012-10-25 23:34:41 -05004466 return -ENOMEM;
Alex Elder4fb5d6712012-11-01 10:17:15 -05004467 if (!*options) {
4468 rbd_warn(NULL, "no options provided");
4469 goto out_err;
4470 }
Alex Eldera725f65e2012-02-02 08:13:30 -06004471
Alex Elder859c31d2012-10-25 23:34:42 -05004472 spec = rbd_spec_alloc();
4473 if (!spec)
Alex Elderf28e5652012-10-25 23:34:41 -05004474 goto out_mem;
Alex Elder859c31d2012-10-25 23:34:42 -05004475
4476 spec->pool_name = dup_token(&buf, NULL);
4477 if (!spec->pool_name)
4478 goto out_mem;
Alex Elder4fb5d6712012-11-01 10:17:15 -05004479 if (!*spec->pool_name) {
4480 rbd_warn(NULL, "no pool name provided");
4481 goto out_err;
4482 }
Alex Eldere28fff262012-02-02 08:13:30 -06004483
Alex Elder69e7a022012-11-01 08:39:26 -05004484 spec->image_name = dup_token(&buf, NULL);
Alex Elder859c31d2012-10-25 23:34:42 -05004485 if (!spec->image_name)
Alex Elderf28e5652012-10-25 23:34:41 -05004486 goto out_mem;
Alex Elder4fb5d6712012-11-01 10:17:15 -05004487 if (!*spec->image_name) {
4488 rbd_warn(NULL, "no image name provided");
4489 goto out_err;
4490 }
Alex Eldere28fff262012-02-02 08:13:30 -06004491
Alex Elderf28e5652012-10-25 23:34:41 -05004492 /*
4493 * Snapshot name is optional; default is to use "-"
4494 * (indicating the head/no snapshot).
4495 */
Alex Elder3feeb8942012-08-31 17:29:52 -05004496 len = next_token(&buf);
Alex Elder820a5f32012-07-09 21:04:24 -05004497 if (!len) {
Alex Elder3feeb8942012-08-31 17:29:52 -05004498 buf = RBD_SNAP_HEAD_NAME; /* No snapshot supplied */
4499 len = sizeof (RBD_SNAP_HEAD_NAME) - 1;
Alex Elderf28e5652012-10-25 23:34:41 -05004500 } else if (len > RBD_MAX_SNAP_NAME_LEN) {
Alex Elderdc79b112012-10-25 23:34:41 -05004501 ret = -ENAMETOOLONG;
Alex Elderf28e5652012-10-25 23:34:41 -05004502 goto out_err;
Alex Elder849b4262012-07-09 21:04:24 -05004503 }
Alex Elderecb4dc222013-04-26 09:43:47 -05004504 snap_name = kmemdup(buf, len + 1, GFP_KERNEL);
4505 if (!snap_name)
Alex Elderf28e5652012-10-25 23:34:41 -05004506 goto out_mem;
Alex Elderecb4dc222013-04-26 09:43:47 -05004507 *(snap_name + len) = '\0';
4508 spec->snap_name = snap_name;
Alex Eldere5c35532012-10-25 23:34:41 -05004509
Alex Elder0ddebc02012-10-25 23:34:41 -05004510 /* Initialize all rbd options to the defaults */
Alex Eldere28fff262012-02-02 08:13:30 -06004511
Alex Elder4e9afeba2012-10-25 23:34:41 -05004512 rbd_opts = kzalloc(sizeof (*rbd_opts), GFP_KERNEL);
4513 if (!rbd_opts)
4514 goto out_mem;
4515
4516 rbd_opts->read_only = RBD_READ_ONLY_DEFAULT;
Alex Elderd22f76e2012-07-12 10:46:35 -05004517
Alex Elder859c31d2012-10-25 23:34:42 -05004518 copts = ceph_parse_options(options, mon_addrs,
Alex Elder0ddebc02012-10-25 23:34:41 -05004519 mon_addrs + mon_addrs_size - 1,
Alex Elder4e9afeba2012-10-25 23:34:41 -05004520 parse_rbd_opts_token, rbd_opts);
Alex Elder859c31d2012-10-25 23:34:42 -05004521 if (IS_ERR(copts)) {
4522 ret = PTR_ERR(copts);
Alex Elderdc79b112012-10-25 23:34:41 -05004523 goto out_err;
4524 }
Alex Elder859c31d2012-10-25 23:34:42 -05004525 kfree(options);
4526
4527 *ceph_opts = copts;
Alex Elder4e9afeba2012-10-25 23:34:41 -05004528 *opts = rbd_opts;
Alex Elder859c31d2012-10-25 23:34:42 -05004529 *rbd_spec = spec;
Alex Elder0ddebc02012-10-25 23:34:41 -05004530
Alex Elderdc79b112012-10-25 23:34:41 -05004531 return 0;
Alex Elderf28e5652012-10-25 23:34:41 -05004532out_mem:
Alex Elderdc79b112012-10-25 23:34:41 -05004533 ret = -ENOMEM;
Alex Elderd22f76e2012-07-12 10:46:35 -05004534out_err:
Alex Elder859c31d2012-10-25 23:34:42 -05004535 kfree(rbd_opts);
4536 rbd_spec_put(spec);
Alex Elderf28e5652012-10-25 23:34:41 -05004537 kfree(options);
Alex Elderd22f76e2012-07-12 10:46:35 -05004538
Alex Elderdc79b112012-10-25 23:34:41 -05004539 return ret;
Alex Eldera725f65e2012-02-02 08:13:30 -06004540}
4541
Alex Elder589d30e2012-07-10 20:30:11 -05004542/*
4543 * An rbd format 2 image has a unique identifier, distinct from the
4544 * name given to it by the user. Internally, that identifier is
4545 * what's used to specify the names of objects related to the image.
4546 *
4547 * A special "rbd id" object is used to map an rbd image name to its
4548 * id. If that object doesn't exist, then there is no v2 rbd image
4549 * with the supplied name.
4550 *
4551 * This function will record the given rbd_dev's image_id field if
4552 * it can be determined, and in that case will return 0. If any
4553 * errors occur a negative errno will be returned and the rbd_dev's
4554 * image_id field will be unchanged (and should be NULL).
4555 */
4556static int rbd_dev_image_id(struct rbd_device *rbd_dev)
4557{
4558 int ret;
4559 size_t size;
4560 char *object_name;
4561 void *response;
Alex Elderc0fba362013-04-25 23:15:08 -05004562 char *image_id;
Alex Elder2f82ee52012-10-30 19:40:33 -05004563
Alex Elder589d30e2012-07-10 20:30:11 -05004564 /*
Alex Elder2c0d0a12012-10-30 19:40:33 -05004565 * When probing a parent image, the image id is already
4566 * known (and the image name likely is not). There's no
Alex Elderc0fba362013-04-25 23:15:08 -05004567 * need to fetch the image id again in this case. We
4568 * do still need to set the image format though.
Alex Elder2c0d0a12012-10-30 19:40:33 -05004569 */
Alex Elderc0fba362013-04-25 23:15:08 -05004570 if (rbd_dev->spec->image_id) {
4571 rbd_dev->image_format = *rbd_dev->spec->image_id ? 2 : 1;
4572
Alex Elder2c0d0a12012-10-30 19:40:33 -05004573 return 0;
Alex Elderc0fba362013-04-25 23:15:08 -05004574 }
Alex Elder2c0d0a12012-10-30 19:40:33 -05004575
4576 /*
Alex Elder589d30e2012-07-10 20:30:11 -05004577 * First, see if the format 2 image id file exists, and if
4578 * so, get the image's persistent id from it.
4579 */
Alex Elder69e7a022012-11-01 08:39:26 -05004580 size = sizeof (RBD_ID_PREFIX) + strlen(rbd_dev->spec->image_name);
Alex Elder589d30e2012-07-10 20:30:11 -05004581 object_name = kmalloc(size, GFP_NOIO);
4582 if (!object_name)
4583 return -ENOMEM;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05004584 sprintf(object_name, "%s%s", RBD_ID_PREFIX, rbd_dev->spec->image_name);
Alex Elder589d30e2012-07-10 20:30:11 -05004585 dout("rbd id object name is %s\n", object_name);
4586
4587 /* Response will be an encoded string, which includes a length */
4588
4589 size = sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX;
4590 response = kzalloc(size, GFP_NOIO);
4591 if (!response) {
4592 ret = -ENOMEM;
4593 goto out;
4594 }
4595
Alex Elderc0fba362013-04-25 23:15:08 -05004596 /* If it doesn't exist we'll assume it's a format 1 image */
4597
Alex Elder36be9a72013-01-19 00:30:28 -06004598 ret = rbd_obj_method_sync(rbd_dev, object_name,
Alex Elder41579762013-04-21 12:14:45 -05004599 "rbd", "get_id", NULL, 0,
Alex Eldere2a58ee2013-04-30 00:44:33 -05004600 response, RBD_IMAGE_ID_LEN_MAX);
Alex Elder36be9a72013-01-19 00:30:28 -06004601 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elderc0fba362013-04-25 23:15:08 -05004602 if (ret == -ENOENT) {
4603 image_id = kstrdup("", GFP_KERNEL);
4604 ret = image_id ? 0 : -ENOMEM;
4605 if (!ret)
4606 rbd_dev->image_format = 1;
4607 } else if (ret > sizeof (__le32)) {
4608 void *p = response;
Alex Elder589d30e2012-07-10 20:30:11 -05004609
Alex Elderc0fba362013-04-25 23:15:08 -05004610 image_id = ceph_extract_encoded_string(&p, p + ret,
Alex Elder979ed482012-11-01 08:39:26 -05004611 NULL, GFP_NOIO);
Alex Elderc0fba362013-04-25 23:15:08 -05004612 ret = IS_ERR(image_id) ? PTR_ERR(image_id) : 0;
4613 if (!ret)
4614 rbd_dev->image_format = 2;
Alex Elder589d30e2012-07-10 20:30:11 -05004615 } else {
Alex Elderc0fba362013-04-25 23:15:08 -05004616 ret = -EINVAL;
4617 }
4618
4619 if (!ret) {
4620 rbd_dev->spec->image_id = image_id;
4621 dout("image_id is %s\n", image_id);
Alex Elder589d30e2012-07-10 20:30:11 -05004622 }
4623out:
4624 kfree(response);
4625 kfree(object_name);
4626
4627 return ret;
4628}
4629
Alex Elder6fd48b32013-04-28 23:32:34 -05004630/* Undo whatever state changes are made by v1 or v2 image probe */
4631
4632static void rbd_dev_unprobe(struct rbd_device *rbd_dev)
4633{
4634 struct rbd_image_header *header;
4635
Alex Eldera2acd002013-05-08 22:50:04 -05004636 rbd_dev_parent_put(rbd_dev);
Alex Elder6fd48b32013-04-28 23:32:34 -05004637
4638 /* Free dynamic fields from the header, then zero it out */
4639
4640 header = &rbd_dev->header;
Alex Elder812164f82013-04-30 00:44:32 -05004641 ceph_put_snap_context(header->snapc);
Alex Elder6fd48b32013-04-28 23:32:34 -05004642 kfree(header->snap_sizes);
4643 kfree(header->snap_names);
4644 kfree(header->object_prefix);
4645 memset(header, 0, sizeof (*header));
4646}
4647
Alex Elder2df3fac2013-05-06 09:51:30 -05004648static int rbd_dev_v2_header_onetime(struct rbd_device *rbd_dev)
Alex Eldera30b71b2012-07-10 20:30:11 -05004649{
Alex Elder9d475de52012-07-03 16:01:19 -05004650 int ret;
Alex Eldera30b71b2012-07-10 20:30:11 -05004651
Alex Elder1e130192012-07-03 16:01:19 -05004652 ret = rbd_dev_v2_object_prefix(rbd_dev);
Alex Elder57385b52013-04-21 12:14:45 -05004653 if (ret)
Alex Elder1e130192012-07-03 16:01:19 -05004654 goto out_err;
Alex Elderb1b54022012-07-03 16:01:19 -05004655
Alex Elder2df3fac2013-05-06 09:51:30 -05004656 /*
4657 * Get the and check features for the image. Currently the
4658 * features are assumed to never change.
4659 */
Alex Elderb1b54022012-07-03 16:01:19 -05004660 ret = rbd_dev_v2_features(rbd_dev);
Alex Elder57385b52013-04-21 12:14:45 -05004661 if (ret)
Alex Elderb1b54022012-07-03 16:01:19 -05004662 goto out_err;
Alex Elder35d489f2012-07-03 16:01:19 -05004663
Alex Eldercc070d52013-04-21 12:14:45 -05004664 /* If the image supports fancy striping, get its parameters */
4665
4666 if (rbd_dev->header.features & RBD_FEATURE_STRIPINGV2) {
4667 ret = rbd_dev_v2_striping_info(rbd_dev);
4668 if (ret < 0)
4669 goto out_err;
4670 }
Alex Elder2df3fac2013-05-06 09:51:30 -05004671 /* No support for crypto and compression type format 2 images */
Alex Elder6e14b1a2012-07-03 16:01:19 -05004672
Alex Elder35152972012-08-31 17:29:55 -05004673 return 0;
Alex Elder9d475de52012-07-03 16:01:19 -05004674out_err:
Alex Elder642a2532013-05-06 17:40:33 -05004675 rbd_dev->header.features = 0;
Alex Elder1e130192012-07-03 16:01:19 -05004676 kfree(rbd_dev->header.object_prefix);
4677 rbd_dev->header.object_prefix = NULL;
Alex Elder9d475de52012-07-03 16:01:19 -05004678
4679 return ret;
Alex Eldera30b71b2012-07-10 20:30:11 -05004680}
4681
Alex Elder124afba2013-04-26 15:44:36 -05004682static int rbd_dev_probe_parent(struct rbd_device *rbd_dev)
Alex Elder83a06262012-10-30 15:47:17 -05004683{
Alex Elder2f82ee52012-10-30 19:40:33 -05004684 struct rbd_device *parent = NULL;
Alex Elder124afba2013-04-26 15:44:36 -05004685 struct rbd_spec *parent_spec;
4686 struct rbd_client *rbdc;
4687 int ret;
4688
4689 if (!rbd_dev->parent_spec)
4690 return 0;
4691 /*
4692 * We need to pass a reference to the client and the parent
4693 * spec when creating the parent rbd_dev. Images related by
4694 * parent/child relationships always share both.
4695 */
4696 parent_spec = rbd_spec_get(rbd_dev->parent_spec);
4697 rbdc = __rbd_get_client(rbd_dev->rbd_client);
4698
4699 ret = -ENOMEM;
4700 parent = rbd_dev_create(rbdc, parent_spec);
4701 if (!parent)
4702 goto out_err;
4703
Alex Elder1f3ef782013-05-06 17:40:33 -05004704 ret = rbd_dev_image_probe(parent, false);
Alex Elder124afba2013-04-26 15:44:36 -05004705 if (ret < 0)
4706 goto out_err;
4707 rbd_dev->parent = parent;
Alex Eldera2acd002013-05-08 22:50:04 -05004708 atomic_set(&rbd_dev->parent_ref, 1);
Alex Elder124afba2013-04-26 15:44:36 -05004709
4710 return 0;
4711out_err:
4712 if (parent) {
Alex Elderfb65d2282013-05-08 22:50:04 -05004713 rbd_dev_unparent(rbd_dev);
Alex Elder124afba2013-04-26 15:44:36 -05004714 kfree(rbd_dev->header_name);
4715 rbd_dev_destroy(parent);
4716 } else {
4717 rbd_put_client(rbdc);
4718 rbd_spec_put(parent_spec);
4719 }
4720
4721 return ret;
4722}
4723
Alex Elder200a6a82013-04-28 23:32:34 -05004724static int rbd_dev_device_setup(struct rbd_device *rbd_dev)
Alex Elder124afba2013-04-26 15:44:36 -05004725{
Alex Elder83a06262012-10-30 15:47:17 -05004726 int ret;
Alex Elder83a06262012-10-30 15:47:17 -05004727
Alex Elder83a06262012-10-30 15:47:17 -05004728 /* generate unique id: find highest unique id, add one */
4729 rbd_dev_id_get(rbd_dev);
4730
4731 /* Fill in the device name, now that we have its id. */
4732 BUILD_BUG_ON(DEV_NAME_LEN
4733 < sizeof (RBD_DRV_NAME) + MAX_INT_FORMAT_WIDTH);
4734 sprintf(rbd_dev->name, "%s%d", RBD_DRV_NAME, rbd_dev->dev_id);
4735
4736 /* Get our block major device number. */
4737
4738 ret = register_blkdev(0, rbd_dev->name);
4739 if (ret < 0)
4740 goto err_out_id;
4741 rbd_dev->major = ret;
4742
4743 /* Set up the blkdev mapping. */
4744
4745 ret = rbd_init_disk(rbd_dev);
4746 if (ret)
4747 goto err_out_blkdev;
4748
Alex Elderf35a4de2013-05-06 09:51:29 -05004749 ret = rbd_dev_mapping_set(rbd_dev);
Alex Elder83a06262012-10-30 15:47:17 -05004750 if (ret)
4751 goto err_out_disk;
Alex Elderf35a4de2013-05-06 09:51:29 -05004752 set_capacity(rbd_dev->disk, rbd_dev->mapping.size / SECTOR_SIZE);
4753
4754 ret = rbd_bus_add_dev(rbd_dev);
4755 if (ret)
4756 goto err_out_mapping;
Alex Elder83a06262012-10-30 15:47:17 -05004757
Alex Elder83a06262012-10-30 15:47:17 -05004758 /* Everything's ready. Announce the disk to the world. */
4759
Alex Elder129b79d2013-04-26 15:44:36 -05004760 set_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags);
Alex Elder83a06262012-10-30 15:47:17 -05004761 add_disk(rbd_dev->disk);
4762
4763 pr_info("%s: added with size 0x%llx\n", rbd_dev->disk->disk_name,
4764 (unsigned long long) rbd_dev->mapping.size);
4765
4766 return ret;
Alex Elder2f82ee52012-10-30 19:40:33 -05004767
Alex Elderf35a4de2013-05-06 09:51:29 -05004768err_out_mapping:
4769 rbd_dev_mapping_clear(rbd_dev);
Alex Elder83a06262012-10-30 15:47:17 -05004770err_out_disk:
4771 rbd_free_disk(rbd_dev);
4772err_out_blkdev:
4773 unregister_blkdev(rbd_dev->major, rbd_dev->name);
4774err_out_id:
4775 rbd_dev_id_put(rbd_dev);
Alex Elderd1cf5782013-04-27 09:59:30 -05004776 rbd_dev_mapping_clear(rbd_dev);
Alex Elder83a06262012-10-30 15:47:17 -05004777
4778 return ret;
4779}
4780
Alex Elder332bb122013-04-27 09:59:30 -05004781static int rbd_dev_header_name(struct rbd_device *rbd_dev)
4782{
4783 struct rbd_spec *spec = rbd_dev->spec;
4784 size_t size;
4785
4786 /* Record the header object name for this rbd image. */
4787
4788 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
4789
4790 if (rbd_dev->image_format == 1)
4791 size = strlen(spec->image_name) + sizeof (RBD_SUFFIX);
4792 else
4793 size = sizeof (RBD_HEADER_PREFIX) + strlen(spec->image_id);
4794
4795 rbd_dev->header_name = kmalloc(size, GFP_KERNEL);
4796 if (!rbd_dev->header_name)
4797 return -ENOMEM;
4798
4799 if (rbd_dev->image_format == 1)
4800 sprintf(rbd_dev->header_name, "%s%s",
4801 spec->image_name, RBD_SUFFIX);
4802 else
4803 sprintf(rbd_dev->header_name, "%s%s",
4804 RBD_HEADER_PREFIX, spec->image_id);
4805 return 0;
4806}
4807
Alex Elder200a6a82013-04-28 23:32:34 -05004808static void rbd_dev_image_release(struct rbd_device *rbd_dev)
4809{
Alex Elder6fd48b32013-04-28 23:32:34 -05004810 rbd_dev_unprobe(rbd_dev);
Alex Elder200a6a82013-04-28 23:32:34 -05004811 kfree(rbd_dev->header_name);
Alex Elder6fd48b32013-04-28 23:32:34 -05004812 rbd_dev->header_name = NULL;
4813 rbd_dev->image_format = 0;
4814 kfree(rbd_dev->spec->image_id);
4815 rbd_dev->spec->image_id = NULL;
4816
Alex Elder200a6a82013-04-28 23:32:34 -05004817 rbd_dev_destroy(rbd_dev);
4818}
4819
Alex Eldera30b71b2012-07-10 20:30:11 -05004820/*
4821 * Probe for the existence of the header object for the given rbd
Alex Elder1f3ef782013-05-06 17:40:33 -05004822 * device. If this image is the one being mapped (i.e., not a
4823 * parent), initiate a watch on its header object before using that
4824 * object to get detailed information about the rbd image.
Alex Eldera30b71b2012-07-10 20:30:11 -05004825 */
Alex Elder1f3ef782013-05-06 17:40:33 -05004826static int rbd_dev_image_probe(struct rbd_device *rbd_dev, bool mapping)
Alex Eldera30b71b2012-07-10 20:30:11 -05004827{
4828 int ret;
Alex Elderb644de22013-04-27 09:59:31 -05004829 int tmp;
Alex Eldera30b71b2012-07-10 20:30:11 -05004830
4831 /*
4832 * Get the id from the image id object. If it's not a
4833 * format 2 image, we'll get ENOENT back, and we'll assume
4834 * it's a format 1 image.
4835 */
4836 ret = rbd_dev_image_id(rbd_dev);
4837 if (ret)
Alex Elderc0fba362013-04-25 23:15:08 -05004838 return ret;
4839 rbd_assert(rbd_dev->spec->image_id);
4840 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
4841
Alex Elder332bb122013-04-27 09:59:30 -05004842 ret = rbd_dev_header_name(rbd_dev);
4843 if (ret)
4844 goto err_out_format;
4845
Alex Elder1f3ef782013-05-06 17:40:33 -05004846 if (mapping) {
4847 ret = rbd_dev_header_watch_sync(rbd_dev, true);
4848 if (ret)
4849 goto out_header_name;
4850 }
Alex Elderb644de22013-04-27 09:59:31 -05004851
Alex Elderc0fba362013-04-25 23:15:08 -05004852 if (rbd_dev->image_format == 1)
Alex Elder99a41eb2013-05-06 09:51:30 -05004853 ret = rbd_dev_v1_header_info(rbd_dev);
Alex Eldera30b71b2012-07-10 20:30:11 -05004854 else
Alex Elder2df3fac2013-05-06 09:51:30 -05004855 ret = rbd_dev_v2_header_info(rbd_dev);
Alex Elder5655c4d2013-04-25 23:15:08 -05004856 if (ret)
Alex Elderb644de22013-04-27 09:59:31 -05004857 goto err_out_watch;
Alex Elder83a06262012-10-30 15:47:17 -05004858
Alex Elder9bb81c92013-04-27 09:59:30 -05004859 ret = rbd_dev_spec_update(rbd_dev);
4860 if (ret)
Alex Elder33dca392013-04-30 00:44:33 -05004861 goto err_out_probe;
Alex Elder9bb81c92013-04-27 09:59:30 -05004862
4863 ret = rbd_dev_probe_parent(rbd_dev);
Alex Elder30d60ba2013-05-06 09:51:30 -05004864 if (ret)
4865 goto err_out_probe;
Alex Elder83a06262012-10-30 15:47:17 -05004866
Alex Elder30d60ba2013-05-06 09:51:30 -05004867 dout("discovered format %u image, header name is %s\n",
4868 rbd_dev->image_format, rbd_dev->header_name);
4869
4870 return 0;
Alex Elder6fd48b32013-04-28 23:32:34 -05004871err_out_probe:
4872 rbd_dev_unprobe(rbd_dev);
Alex Elderb644de22013-04-27 09:59:31 -05004873err_out_watch:
Alex Elder1f3ef782013-05-06 17:40:33 -05004874 if (mapping) {
4875 tmp = rbd_dev_header_watch_sync(rbd_dev, false);
4876 if (tmp)
4877 rbd_warn(rbd_dev, "unable to tear down "
4878 "watch request (%d)\n", tmp);
4879 }
Alex Elder332bb122013-04-27 09:59:30 -05004880out_header_name:
4881 kfree(rbd_dev->header_name);
4882 rbd_dev->header_name = NULL;
4883err_out_format:
4884 rbd_dev->image_format = 0;
Alex Elder5655c4d2013-04-25 23:15:08 -05004885 kfree(rbd_dev->spec->image_id);
4886 rbd_dev->spec->image_id = NULL;
4887
4888 dout("probe failed, returning %d\n", ret);
4889
4890 return ret;
Alex Eldera30b71b2012-07-10 20:30:11 -05004891}
4892
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07004893static ssize_t rbd_add(struct bus_type *bus,
4894 const char *buf,
4895 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004896{
Alex Eldercb8627c2012-07-09 21:04:23 -05004897 struct rbd_device *rbd_dev = NULL;
Alex Elderdc79b112012-10-25 23:34:41 -05004898 struct ceph_options *ceph_opts = NULL;
Alex Elder4e9afeba2012-10-25 23:34:41 -05004899 struct rbd_options *rbd_opts = NULL;
Alex Elder859c31d2012-10-25 23:34:42 -05004900 struct rbd_spec *spec = NULL;
Alex Elder9d3997f2012-10-25 23:34:42 -05004901 struct rbd_client *rbdc;
Alex Elder27cc2592012-02-02 08:13:30 -06004902 struct ceph_osd_client *osdc;
Alex Elder51344a32013-05-06 07:40:30 -05004903 bool read_only;
Alex Elder27cc2592012-02-02 08:13:30 -06004904 int rc = -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004905
4906 if (!try_module_get(THIS_MODULE))
4907 return -ENODEV;
4908
Alex Eldera725f65e2012-02-02 08:13:30 -06004909 /* parse add command */
Alex Elder859c31d2012-10-25 23:34:42 -05004910 rc = rbd_add_parse_args(buf, &ceph_opts, &rbd_opts, &spec);
Alex Elderdc79b112012-10-25 23:34:41 -05004911 if (rc < 0)
Alex Elderbd4ba652012-10-25 23:34:42 -05004912 goto err_out_module;
Alex Elder51344a32013-05-06 07:40:30 -05004913 read_only = rbd_opts->read_only;
4914 kfree(rbd_opts);
4915 rbd_opts = NULL; /* done with this */
Alex Eldera725f65e2012-02-02 08:13:30 -06004916
Alex Elder9d3997f2012-10-25 23:34:42 -05004917 rbdc = rbd_get_client(ceph_opts);
4918 if (IS_ERR(rbdc)) {
4919 rc = PTR_ERR(rbdc);
Alex Elder0ddebc02012-10-25 23:34:41 -05004920 goto err_out_args;
Alex Elder9d3997f2012-10-25 23:34:42 -05004921 }
Alex Elderc53d5892012-10-25 23:34:42 -05004922 ceph_opts = NULL; /* rbd_dev client now owns this */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004923
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004924 /* pick the pool */
Alex Elder9d3997f2012-10-25 23:34:42 -05004925 osdc = &rbdc->client->osdc;
Alex Elder859c31d2012-10-25 23:34:42 -05004926 rc = ceph_pg_poolid_by_name(osdc->osdmap, spec->pool_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004927 if (rc < 0)
4928 goto err_out_client;
Alex Elderc0cd10db2013-04-26 09:43:47 -05004929 spec->pool_id = (u64)rc;
Alex Elder859c31d2012-10-25 23:34:42 -05004930
Alex Elder0903e872012-11-14 12:25:19 -06004931 /* The ceph file layout needs to fit pool id in 32 bits */
4932
Alex Elderc0cd10db2013-04-26 09:43:47 -05004933 if (spec->pool_id > (u64)U32_MAX) {
4934 rbd_warn(NULL, "pool id too large (%llu > %u)\n",
4935 (unsigned long long)spec->pool_id, U32_MAX);
Alex Elder0903e872012-11-14 12:25:19 -06004936 rc = -EIO;
4937 goto err_out_client;
4938 }
4939
Alex Elderc53d5892012-10-25 23:34:42 -05004940 rbd_dev = rbd_dev_create(rbdc, spec);
Alex Elderbd4ba652012-10-25 23:34:42 -05004941 if (!rbd_dev)
4942 goto err_out_client;
Alex Elderc53d5892012-10-25 23:34:42 -05004943 rbdc = NULL; /* rbd_dev now owns this */
4944 spec = NULL; /* rbd_dev now owns this */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004945
Alex Elder1f3ef782013-05-06 17:40:33 -05004946 rc = rbd_dev_image_probe(rbd_dev, true);
Alex Eldera30b71b2012-07-10 20:30:11 -05004947 if (rc < 0)
Alex Elderc53d5892012-10-25 23:34:42 -05004948 goto err_out_rbd_dev;
Alex Elder05fd6f62012-08-29 17:11:07 -05004949
Alex Elder7ce4eef2013-05-06 17:40:33 -05004950 /* If we are mapping a snapshot it must be marked read-only */
4951
4952 if (rbd_dev->spec->snap_id != CEPH_NOSNAP)
4953 read_only = true;
4954 rbd_dev->mapping.read_only = read_only;
4955
Alex Elderb536f692013-04-28 23:32:34 -05004956 rc = rbd_dev_device_setup(rbd_dev);
4957 if (!rc)
4958 return count;
4959
4960 rbd_dev_image_release(rbd_dev);
Alex Elderc53d5892012-10-25 23:34:42 -05004961err_out_rbd_dev:
4962 rbd_dev_destroy(rbd_dev);
Alex Elderbd4ba652012-10-25 23:34:42 -05004963err_out_client:
Alex Elder9d3997f2012-10-25 23:34:42 -05004964 rbd_put_client(rbdc);
Alex Elder0ddebc02012-10-25 23:34:41 -05004965err_out_args:
Alex Elder78cea762012-10-25 23:34:41 -05004966 if (ceph_opts)
4967 ceph_destroy_options(ceph_opts);
Alex Elder4e9afeba2012-10-25 23:34:41 -05004968 kfree(rbd_opts);
Alex Elder859c31d2012-10-25 23:34:42 -05004969 rbd_spec_put(spec);
Alex Elderbd4ba652012-10-25 23:34:42 -05004970err_out_module:
4971 module_put(THIS_MODULE);
Alex Elder27cc2592012-02-02 08:13:30 -06004972
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004973 dout("Error adding device %s\n", buf);
Alex Elder27cc2592012-02-02 08:13:30 -06004974
Alex Elderc0cd10db2013-04-26 09:43:47 -05004975 return (ssize_t)rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004976}
4977
Alex Elderde71a292012-07-03 16:01:19 -05004978static struct rbd_device *__rbd_get_dev(unsigned long dev_id)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004979{
4980 struct list_head *tmp;
4981 struct rbd_device *rbd_dev;
4982
Alex Eldere124a82f2012-01-29 13:57:44 -06004983 spin_lock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004984 list_for_each(tmp, &rbd_dev_list) {
4985 rbd_dev = list_entry(tmp, struct rbd_device, node);
Alex Elderde71a292012-07-03 16:01:19 -05004986 if (rbd_dev->dev_id == dev_id) {
Alex Eldere124a82f2012-01-29 13:57:44 -06004987 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004988 return rbd_dev;
Alex Eldere124a82f2012-01-29 13:57:44 -06004989 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004990 }
Alex Eldere124a82f2012-01-29 13:57:44 -06004991 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004992 return NULL;
4993}
4994
Alex Elder200a6a82013-04-28 23:32:34 -05004995static void rbd_dev_device_release(struct device *dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004996{
Alex Elder593a9e72012-02-07 12:03:37 -06004997 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004998
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004999 rbd_free_disk(rbd_dev);
Alex Elder200a6a82013-04-28 23:32:34 -05005000 clear_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags);
Alex Elder6d80b132013-05-06 07:40:30 -05005001 rbd_dev_mapping_clear(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005002 unregister_blkdev(rbd_dev->major, rbd_dev->name);
Alex Elder200a6a82013-04-28 23:32:34 -05005003 rbd_dev->major = 0;
Alex Eldere2839302012-08-29 17:11:06 -05005004 rbd_dev_id_put(rbd_dev);
Alex Elderd1cf5782013-04-27 09:59:30 -05005005 rbd_dev_mapping_clear(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005006}
5007
Alex Elder05a46af2013-04-26 15:44:36 -05005008static void rbd_dev_remove_parent(struct rbd_device *rbd_dev)
5009{
Alex Elderad945fc2013-04-26 15:44:36 -05005010 while (rbd_dev->parent) {
Alex Elder05a46af2013-04-26 15:44:36 -05005011 struct rbd_device *first = rbd_dev;
5012 struct rbd_device *second = first->parent;
5013 struct rbd_device *third;
5014
5015 /*
5016 * Follow to the parent with no grandparent and
5017 * remove it.
5018 */
5019 while (second && (third = second->parent)) {
5020 first = second;
5021 second = third;
5022 }
Alex Elderad945fc2013-04-26 15:44:36 -05005023 rbd_assert(second);
Alex Elder8ad42cd2013-04-28 23:32:34 -05005024 rbd_dev_image_release(second);
Alex Elderad945fc2013-04-26 15:44:36 -05005025 first->parent = NULL;
5026 first->parent_overlap = 0;
5027
5028 rbd_assert(first->parent_spec);
Alex Elder05a46af2013-04-26 15:44:36 -05005029 rbd_spec_put(first->parent_spec);
5030 first->parent_spec = NULL;
Alex Elder05a46af2013-04-26 15:44:36 -05005031 }
5032}
5033
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005034static ssize_t rbd_remove(struct bus_type *bus,
5035 const char *buf,
5036 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005037{
5038 struct rbd_device *rbd_dev = NULL;
Alex Elder0d8189e2013-04-27 09:59:30 -05005039 int target_id;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005040 unsigned long ul;
Alex Elder0d8189e2013-04-27 09:59:30 -05005041 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005042
Alex Elder0d8189e2013-04-27 09:59:30 -05005043 ret = strict_strtoul(buf, 10, &ul);
5044 if (ret)
5045 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005046
5047 /* convert to int; abort if we lost anything in the conversion */
5048 target_id = (int) ul;
5049 if (target_id != ul)
5050 return -EINVAL;
5051
5052 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
5053
5054 rbd_dev = __rbd_get_dev(target_id);
5055 if (!rbd_dev) {
5056 ret = -ENOENT;
5057 goto done;
5058 }
5059
Alex Eldera14ea262013-02-05 13:23:12 -06005060 spin_lock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -06005061 if (rbd_dev->open_count)
Alex Elder42382b72012-11-16 09:29:16 -06005062 ret = -EBUSY;
Alex Elderb82d1672013-01-14 12:43:31 -06005063 else
5064 set_bit(RBD_DEV_FLAG_REMOVING, &rbd_dev->flags);
Alex Eldera14ea262013-02-05 13:23:12 -06005065 spin_unlock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -06005066 if (ret < 0)
Alex Elder42382b72012-11-16 09:29:16 -06005067 goto done;
Alex Elderb4808152013-04-26 15:44:36 -05005068 rbd_bus_del_dev(rbd_dev);
Alex Elder1f3ef782013-05-06 17:40:33 -05005069 ret = rbd_dev_header_watch_sync(rbd_dev, false);
5070 if (ret)
5071 rbd_warn(rbd_dev, "failed to cancel watch event (%d)\n", ret);
Alex Elder8ad42cd2013-04-28 23:32:34 -05005072 rbd_dev_image_release(rbd_dev);
Alex Elder79ab7552013-04-28 23:32:34 -05005073 module_put(THIS_MODULE);
Alex Elder1f3ef782013-05-06 17:40:33 -05005074 ret = count;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005075done:
5076 mutex_unlock(&ctl_mutex);
Alex Elderaafb2302012-09-06 16:00:54 -05005077
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005078 return ret;
5079}
5080
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005081/*
5082 * create control files in sysfs
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005083 * /sys/bus/rbd/...
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005084 */
5085static int rbd_sysfs_init(void)
5086{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005087 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005088
Alex Elderfed4c142012-02-07 12:03:36 -06005089 ret = device_register(&rbd_root_dev);
Alex Elder21079782012-01-24 10:08:36 -06005090 if (ret < 0)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005091 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005092
Alex Elderfed4c142012-02-07 12:03:36 -06005093 ret = bus_register(&rbd_bus_type);
5094 if (ret < 0)
5095 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005096
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005097 return ret;
5098}
5099
5100static void rbd_sysfs_cleanup(void)
5101{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005102 bus_unregister(&rbd_bus_type);
Alex Elderfed4c142012-02-07 12:03:36 -06005103 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005104}
5105
Alex Elder1c2a9df2013-05-01 12:43:03 -05005106static int rbd_slab_init(void)
5107{
5108 rbd_assert(!rbd_img_request_cache);
5109 rbd_img_request_cache = kmem_cache_create("rbd_img_request",
5110 sizeof (struct rbd_img_request),
5111 __alignof__(struct rbd_img_request),
5112 0, NULL);
Alex Elder868311b2013-05-01 12:43:03 -05005113 if (!rbd_img_request_cache)
5114 return -ENOMEM;
5115
5116 rbd_assert(!rbd_obj_request_cache);
5117 rbd_obj_request_cache = kmem_cache_create("rbd_obj_request",
5118 sizeof (struct rbd_obj_request),
5119 __alignof__(struct rbd_obj_request),
5120 0, NULL);
Alex Elder78c2a442013-05-01 12:43:04 -05005121 if (!rbd_obj_request_cache)
5122 goto out_err;
5123
5124 rbd_assert(!rbd_segment_name_cache);
5125 rbd_segment_name_cache = kmem_cache_create("rbd_segment_name",
5126 MAX_OBJ_NAME_SIZE + 1, 1, 0, NULL);
5127 if (rbd_segment_name_cache)
Alex Elder1c2a9df2013-05-01 12:43:03 -05005128 return 0;
Alex Elder78c2a442013-05-01 12:43:04 -05005129out_err:
5130 if (rbd_obj_request_cache) {
5131 kmem_cache_destroy(rbd_obj_request_cache);
5132 rbd_obj_request_cache = NULL;
5133 }
Alex Elder1c2a9df2013-05-01 12:43:03 -05005134
Alex Elder868311b2013-05-01 12:43:03 -05005135 kmem_cache_destroy(rbd_img_request_cache);
5136 rbd_img_request_cache = NULL;
5137
Alex Elder1c2a9df2013-05-01 12:43:03 -05005138 return -ENOMEM;
5139}
5140
5141static void rbd_slab_exit(void)
5142{
Alex Elder78c2a442013-05-01 12:43:04 -05005143 rbd_assert(rbd_segment_name_cache);
5144 kmem_cache_destroy(rbd_segment_name_cache);
5145 rbd_segment_name_cache = NULL;
5146
Alex Elder868311b2013-05-01 12:43:03 -05005147 rbd_assert(rbd_obj_request_cache);
5148 kmem_cache_destroy(rbd_obj_request_cache);
5149 rbd_obj_request_cache = NULL;
5150
Alex Elder1c2a9df2013-05-01 12:43:03 -05005151 rbd_assert(rbd_img_request_cache);
5152 kmem_cache_destroy(rbd_img_request_cache);
5153 rbd_img_request_cache = NULL;
5154}
5155
Alex Eldercc344fa2013-02-19 12:25:56 -06005156static int __init rbd_init(void)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005157{
5158 int rc;
5159
Alex Elder1e32d342013-01-30 11:13:33 -06005160 if (!libceph_compatible(NULL)) {
5161 rbd_warn(NULL, "libceph incompatibility (quitting)");
5162
5163 return -EINVAL;
5164 }
Alex Elder1c2a9df2013-05-01 12:43:03 -05005165 rc = rbd_slab_init();
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005166 if (rc)
5167 return rc;
Alex Elder1c2a9df2013-05-01 12:43:03 -05005168 rc = rbd_sysfs_init();
5169 if (rc)
5170 rbd_slab_exit();
5171 else
5172 pr_info("loaded " RBD_DRV_NAME_LONG "\n");
5173
5174 return rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005175}
5176
Alex Eldercc344fa2013-02-19 12:25:56 -06005177static void __exit rbd_exit(void)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005178{
5179 rbd_sysfs_cleanup();
Alex Elder1c2a9df2013-05-01 12:43:03 -05005180 rbd_slab_exit();
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005181}
5182
5183module_init(rbd_init);
5184module_exit(rbd_exit);
5185
5186MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
5187MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
5188MODULE_DESCRIPTION("rados block device");
5189
5190/* following authorship retained from original osdblk.c */
5191MODULE_AUTHOR("Jeff Garzik <jeff@garzik.org>");
5192
5193MODULE_LICENSE("GPL");