blob: 57e56617e45ff043c468e0203561c7bf03393c1e [file] [log] [blame]
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001/*
2 rbd.c -- Export ceph rados objects as a Linux block device
3
4
5 based on drivers/block/osdblk.c:
6
7 Copyright 2009 Red Hat, Inc.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; see the file COPYING. If not, write to
20 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
21
22
23
Yehuda Sadehdfc56062010-11-19 14:51:04 -080024 For usage instructions, please refer to:
Yehuda Sadeh602adf42010-08-12 16:11:25 -070025
Yehuda Sadehdfc56062010-11-19 14:51:04 -080026 Documentation/ABI/testing/sysfs-bus-rbd
Yehuda Sadeh602adf42010-08-12 16:11:25 -070027
28 */
29
30#include <linux/ceph/libceph.h>
31#include <linux/ceph/osd_client.h>
32#include <linux/ceph/mon_client.h>
33#include <linux/ceph/decode.h>
Yehuda Sadeh59c2be12011-03-21 15:10:11 -070034#include <linux/parser.h>
Yehuda Sadeh602adf42010-08-12 16:11:25 -070035
36#include <linux/kernel.h>
37#include <linux/device.h>
38#include <linux/module.h>
39#include <linux/fs.h>
40#include <linux/blkdev.h>
41
42#include "rbd_types.h"
43
Alex Elderaafb2302012-09-06 16:00:54 -050044#define RBD_DEBUG /* Activate rbd_assert() calls */
45
Alex Elder593a9e72012-02-07 12:03:37 -060046/*
47 * The basic unit of block I/O is a sector. It is interpreted in a
48 * number of contexts in Linux (blk, bio, genhd), but the default is
49 * universally 512 bytes. These symbols are just slightly more
50 * meaningful than the bare numbers they represent.
51 */
52#define SECTOR_SHIFT 9
53#define SECTOR_SIZE (1ULL << SECTOR_SHIFT)
54
Alex Elderf0f8cef2012-01-29 13:57:44 -060055#define RBD_DRV_NAME "rbd"
56#define RBD_DRV_NAME_LONG "rbd (rados block device)"
Yehuda Sadeh602adf42010-08-12 16:11:25 -070057
58#define RBD_MINORS_PER_MAJOR 256 /* max minors per blkdev */
59
Alex Elderd4b125e2012-07-03 16:01:19 -050060#define RBD_SNAP_DEV_NAME_PREFIX "snap_"
61#define RBD_MAX_SNAP_NAME_LEN \
62 (NAME_MAX - (sizeof (RBD_SNAP_DEV_NAME_PREFIX) - 1))
63
Alex Elder35d489f2012-07-03 16:01:19 -050064#define RBD_MAX_SNAP_COUNT 510 /* allows max snapc to fit in 4KB */
Yehuda Sadeh602adf42010-08-12 16:11:25 -070065
66#define RBD_SNAP_HEAD_NAME "-"
67
Alex Elder9e15b772012-10-30 19:40:33 -050068/* This allows a single page to hold an image name sent by OSD */
69#define RBD_IMAGE_NAME_LEN_MAX (PAGE_SIZE - sizeof (__le32) - 1)
Alex Elder1e130192012-07-03 16:01:19 -050070#define RBD_IMAGE_ID_LEN_MAX 64
Alex Elder9e15b772012-10-30 19:40:33 -050071
Alex Elder1e130192012-07-03 16:01:19 -050072#define RBD_OBJ_PREFIX_LEN_MAX 64
Alex Elder589d30e2012-07-10 20:30:11 -050073
Alex Elderd8891402012-10-09 13:50:17 -070074/* Feature bits */
75
Alex Elder5cbf6f122013-04-11 09:29:48 -050076#define RBD_FEATURE_LAYERING (1<<0)
77#define RBD_FEATURE_STRIPINGV2 (1<<1)
78#define RBD_FEATURES_ALL \
79 (RBD_FEATURE_LAYERING | RBD_FEATURE_STRIPINGV2)
Alex Elderd8891402012-10-09 13:50:17 -070080
81/* Features supported by this (client software) implementation. */
82
Alex Elder770eba62012-10-25 23:34:40 -050083#define RBD_FEATURES_SUPPORTED (RBD_FEATURES_ALL)
Alex Elderd8891402012-10-09 13:50:17 -070084
Alex Elder81a89792012-02-02 08:13:30 -060085/*
86 * An RBD device name will be "rbd#", where the "rbd" comes from
87 * RBD_DRV_NAME above, and # is a unique integer identifier.
88 * MAX_INT_FORMAT_WIDTH is used in ensuring DEV_NAME_LEN is big
89 * enough to hold all possible device names.
90 */
Yehuda Sadeh602adf42010-08-12 16:11:25 -070091#define DEV_NAME_LEN 32
Alex Elder81a89792012-02-02 08:13:30 -060092#define MAX_INT_FORMAT_WIDTH ((5 * sizeof (int)) / 2 + 1)
Yehuda Sadeh602adf42010-08-12 16:11:25 -070093
94/*
95 * block device image metadata (in-memory version)
96 */
97struct rbd_image_header {
Alex Elderf84344f2012-08-31 17:29:51 -050098 /* These four fields never change for a given rbd image */
Alex Elder849b4262012-07-09 21:04:24 -050099 char *object_prefix;
Alex Elder34b13182012-07-13 20:35:12 -0500100 u64 features;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700101 __u8 obj_order;
102 __u8 crypt_type;
103 __u8 comp_type;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700104
Alex Elderf84344f2012-08-31 17:29:51 -0500105 /* The remaining fields need to be updated occasionally */
106 u64 image_size;
107 struct ceph_snap_context *snapc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700108 char *snap_names;
109 u64 *snap_sizes;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700110
Alex Elder500d0c0f2013-04-26 09:43:47 -0500111 u64 stripe_unit;
112 u64 stripe_count;
113
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700114 u64 obj_version;
115};
116
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500117/*
118 * An rbd image specification.
119 *
120 * The tuple (pool_id, image_id, snap_id) is sufficient to uniquely
Alex Elderc66c6e02012-11-01 08:39:26 -0500121 * identify an image. Each rbd_dev structure includes a pointer to
122 * an rbd_spec structure that encapsulates this identity.
123 *
124 * Each of the id's in an rbd_spec has an associated name. For a
125 * user-mapped image, the names are supplied and the id's associated
126 * with them are looked up. For a layered image, a parent image is
127 * defined by the tuple, and the names are looked up.
128 *
129 * An rbd_dev structure contains a parent_spec pointer which is
130 * non-null if the image it represents is a child in a layered
131 * image. This pointer will refer to the rbd_spec structure used
132 * by the parent rbd_dev for its own identity (i.e., the structure
133 * is shared between the parent and child).
134 *
135 * Since these structures are populated once, during the discovery
136 * phase of image construction, they are effectively immutable so
137 * we make no effort to synchronize access to them.
138 *
139 * Note that code herein does not assume the image name is known (it
140 * could be a null pointer).
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500141 */
142struct rbd_spec {
143 u64 pool_id;
Alex Elderecb4dc222013-04-26 09:43:47 -0500144 const char *pool_name;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500145
Alex Elderecb4dc222013-04-26 09:43:47 -0500146 const char *image_id;
147 const char *image_name;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500148
149 u64 snap_id;
Alex Elderecb4dc222013-04-26 09:43:47 -0500150 const char *snap_name;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500151
152 struct kref kref;
153};
154
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700155/*
Alex Elderf0f8cef2012-01-29 13:57:44 -0600156 * an instance of the client. multiple devices may share an rbd client.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700157 */
158struct rbd_client {
159 struct ceph_client *client;
160 struct kref kref;
161 struct list_head node;
162};
163
Alex Elderbf0d5f502012-11-22 00:00:08 -0600164struct rbd_img_request;
165typedef void (*rbd_img_callback_t)(struct rbd_img_request *);
166
167#define BAD_WHICH U32_MAX /* Good which or bad which, which? */
168
169struct rbd_obj_request;
170typedef void (*rbd_obj_callback_t)(struct rbd_obj_request *);
171
Alex Elder9969ebc2013-01-18 12:31:10 -0600172enum obj_request_type {
173 OBJ_REQUEST_NODATA, OBJ_REQUEST_BIO, OBJ_REQUEST_PAGES
174};
Alex Elderbf0d5f502012-11-22 00:00:08 -0600175
Alex Elder926f9b32013-02-11 12:33:24 -0600176enum obj_req_flags {
177 OBJ_REQ_DONE, /* completion flag: not done = 0, done = 1 */
Alex Elder6365d332013-02-11 12:33:24 -0600178 OBJ_REQ_IMG_DATA, /* object usage: standalone = 0, image = 1 */
Alex Elder5679c592013-02-11 12:33:24 -0600179 OBJ_REQ_KNOWN, /* EXISTS flag valid: no = 0, yes = 1 */
180 OBJ_REQ_EXISTS, /* target exists: no = 0, yes = 1 */
Alex Elder926f9b32013-02-11 12:33:24 -0600181};
182
Alex Elderbf0d5f502012-11-22 00:00:08 -0600183struct rbd_obj_request {
184 const char *object_name;
185 u64 offset; /* object start byte */
186 u64 length; /* bytes from offset */
Alex Elder926f9b32013-02-11 12:33:24 -0600187 unsigned long flags;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600188
Alex Elderc5b5ef62013-02-11 12:33:24 -0600189 /*
190 * An object request associated with an image will have its
191 * img_data flag set; a standalone object request will not.
192 *
193 * A standalone object request will have which == BAD_WHICH
194 * and a null obj_request pointer.
195 *
196 * An object request initiated in support of a layered image
197 * object (to check for its existence before a write) will
198 * have which == BAD_WHICH and a non-null obj_request pointer.
199 *
200 * Finally, an object request for rbd image data will have
201 * which != BAD_WHICH, and will have a non-null img_request
202 * pointer. The value of which will be in the range
203 * 0..(img_request->obj_request_count-1).
204 */
205 union {
206 struct rbd_obj_request *obj_request; /* STAT op */
207 struct {
208 struct rbd_img_request *img_request;
209 u64 img_offset;
210 /* links for img_request->obj_requests list */
211 struct list_head links;
212 };
213 };
Alex Elderbf0d5f502012-11-22 00:00:08 -0600214 u32 which; /* posn image request list */
215
216 enum obj_request_type type;
Alex Elder788e2df2013-01-17 12:25:27 -0600217 union {
218 struct bio *bio_list;
219 struct {
220 struct page **pages;
221 u32 page_count;
222 };
223 };
Alex Elder0eefd472013-04-19 15:34:50 -0500224 struct page **copyup_pages;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600225
226 struct ceph_osd_request *osd_req;
227
228 u64 xferred; /* bytes transferred */
229 u64 version;
Sage Weil1b83bef2013-02-25 16:11:12 -0800230 int result;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600231
232 rbd_obj_callback_t callback;
Alex Elder788e2df2013-01-17 12:25:27 -0600233 struct completion completion;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600234
235 struct kref kref;
236};
237
Alex Elder0c425242013-02-08 09:55:49 -0600238enum img_req_flags {
Alex Elder9849e982013-01-24 16:13:36 -0600239 IMG_REQ_WRITE, /* I/O direction: read = 0, write = 1 */
240 IMG_REQ_CHILD, /* initiator: block = 0, child image = 1 */
Alex Elderd0b2e942013-01-24 16:13:36 -0600241 IMG_REQ_LAYERED, /* ENOENT handling: normal = 0, layered = 1 */
Alex Elder0c425242013-02-08 09:55:49 -0600242};
243
Alex Elderbf0d5f502012-11-22 00:00:08 -0600244struct rbd_img_request {
Alex Elderbf0d5f502012-11-22 00:00:08 -0600245 struct rbd_device *rbd_dev;
246 u64 offset; /* starting image byte offset */
247 u64 length; /* byte count from offset */
Alex Elder0c425242013-02-08 09:55:49 -0600248 unsigned long flags;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600249 union {
Alex Elder9849e982013-01-24 16:13:36 -0600250 u64 snap_id; /* for reads */
Alex Elderbf0d5f502012-11-22 00:00:08 -0600251 struct ceph_snap_context *snapc; /* for writes */
Alex Elder9849e982013-01-24 16:13:36 -0600252 };
253 union {
254 struct request *rq; /* block request */
255 struct rbd_obj_request *obj_request; /* obj req initiator */
Alex Elderbf0d5f502012-11-22 00:00:08 -0600256 };
Alex Elder3d7efd12013-04-19 15:34:50 -0500257 struct page **copyup_pages;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600258 spinlock_t completion_lock;/* protects next_completion */
259 u32 next_completion;
260 rbd_img_callback_t callback;
Alex Elder55f27e02013-04-10 12:34:25 -0500261 u64 xferred;/* aggregate bytes transferred */
Alex Eldera5a337d2013-01-24 16:13:36 -0600262 int result; /* first nonzero obj_request result */
Alex Elderbf0d5f502012-11-22 00:00:08 -0600263
264 u32 obj_request_count;
265 struct list_head obj_requests; /* rbd_obj_request structs */
266
267 struct kref kref;
268};
269
270#define for_each_obj_request(ireq, oreq) \
Alex Elderef06f4d32013-02-08 09:55:48 -0600271 list_for_each_entry(oreq, &(ireq)->obj_requests, links)
Alex Elderbf0d5f502012-11-22 00:00:08 -0600272#define for_each_obj_request_from(ireq, oreq) \
Alex Elderef06f4d32013-02-08 09:55:48 -0600273 list_for_each_entry_from(oreq, &(ireq)->obj_requests, links)
Alex Elderbf0d5f502012-11-22 00:00:08 -0600274#define for_each_obj_request_safe(ireq, oreq, n) \
Alex Elderef06f4d32013-02-08 09:55:48 -0600275 list_for_each_entry_safe_reverse(oreq, n, &(ireq)->obj_requests, links)
Alex Elderbf0d5f502012-11-22 00:00:08 -0600276
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800277struct rbd_snap {
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800278 const char *name;
Josh Durgin3591538f2011-12-05 18:25:13 -0800279 u64 size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800280 struct list_head node;
281 u64 id;
Alex Elder34b13182012-07-13 20:35:12 -0500282 u64 features;
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800283};
284
Alex Elderf84344f2012-08-31 17:29:51 -0500285struct rbd_mapping {
Alex Elder99c1f08f2012-08-30 14:42:15 -0500286 u64 size;
Alex Elder34b13182012-07-13 20:35:12 -0500287 u64 features;
Alex Elderf84344f2012-08-31 17:29:51 -0500288 bool read_only;
289};
290
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700291/*
292 * a single device
293 */
294struct rbd_device {
Alex Elderde71a292012-07-03 16:01:19 -0500295 int dev_id; /* blkdev unique id */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700296
297 int major; /* blkdev assigned major */
298 struct gendisk *disk; /* blkdev's gendisk and rq */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700299
Alex Eldera30b71b2012-07-10 20:30:11 -0500300 u32 image_format; /* Either 1 or 2 */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700301 struct rbd_client *rbd_client;
302
303 char name[DEV_NAME_LEN]; /* blkdev name, e.g. rbd3 */
304
Alex Elderb82d1672013-01-14 12:43:31 -0600305 spinlock_t lock; /* queue, flags, open_count */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700306
307 struct rbd_image_header header;
Alex Elderb82d1672013-01-14 12:43:31 -0600308 unsigned long flags; /* possibly lock protected */
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500309 struct rbd_spec *spec;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700310
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500311 char *header_name;
Alex Elder971f8392012-10-25 23:34:41 -0500312
Alex Elder0903e872012-11-14 12:25:19 -0600313 struct ceph_file_layout layout;
314
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700315 struct ceph_osd_event *watch_event;
Alex Elder975241a2013-01-25 17:08:55 -0600316 struct rbd_obj_request *watch_request;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700317
Alex Elder86b00e02012-10-25 23:34:42 -0500318 struct rbd_spec *parent_spec;
319 u64 parent_overlap;
Alex Elder2f82ee52012-10-30 19:40:33 -0500320 struct rbd_device *parent;
Alex Elder86b00e02012-10-25 23:34:42 -0500321
Josh Durginc6666012011-11-21 17:11:12 -0800322 /* protects updating the header */
323 struct rw_semaphore header_rwsem;
Alex Elderf84344f2012-08-31 17:29:51 -0500324
325 struct rbd_mapping mapping;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700326
327 struct list_head node;
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800328
329 /* list of snapshots */
330 struct list_head snaps;
331
332 /* sysfs related */
333 struct device dev;
Alex Elderb82d1672013-01-14 12:43:31 -0600334 unsigned long open_count; /* protected by lock */
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800335};
336
Alex Elderb82d1672013-01-14 12:43:31 -0600337/*
338 * Flag bits for rbd_dev->flags. If atomicity is required,
339 * rbd_dev->lock is used to protect access.
340 *
341 * Currently, only the "removing" flag (which is coupled with the
342 * "open_count" field) requires atomic access.
343 */
Alex Elder6d292902013-01-14 12:43:31 -0600344enum rbd_dev_flags {
345 RBD_DEV_FLAG_EXISTS, /* mapped snapshot has not been deleted */
Alex Elderb82d1672013-01-14 12:43:31 -0600346 RBD_DEV_FLAG_REMOVING, /* this mapping is being removed */
Alex Elder6d292902013-01-14 12:43:31 -0600347};
348
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700349static DEFINE_MUTEX(ctl_mutex); /* Serialize open/close/setup/teardown */
Alex Eldere124a82f2012-01-29 13:57:44 -0600350
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700351static LIST_HEAD(rbd_dev_list); /* devices */
Alex Eldere124a82f2012-01-29 13:57:44 -0600352static DEFINE_SPINLOCK(rbd_dev_list_lock);
353
Alex Elder432b8582012-01-29 13:57:44 -0600354static LIST_HEAD(rbd_client_list); /* clients */
355static DEFINE_SPINLOCK(rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700356
Alex Elder3d7efd12013-04-19 15:34:50 -0500357static int rbd_img_request_submit(struct rbd_img_request *img_request);
358
Alex Elder304f6802012-08-31 17:29:52 -0500359static int rbd_dev_snaps_update(struct rbd_device *rbd_dev);
Alex Elder304f6802012-08-31 17:29:52 -0500360
Alex Elder200a6a82013-04-28 23:32:34 -0500361static void rbd_dev_device_release(struct device *dev);
Alex Elder6087b512013-04-25 15:09:41 -0500362static void rbd_snap_destroy(struct rbd_snap *snap);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800363
Alex Elderf0f8cef2012-01-29 13:57:44 -0600364static ssize_t rbd_add(struct bus_type *bus, const char *buf,
365 size_t count);
366static ssize_t rbd_remove(struct bus_type *bus, const char *buf,
367 size_t count);
Alex Elder71f293e2013-04-26 09:43:48 -0500368static int rbd_dev_image_probe(struct rbd_device *rbd_dev);
Alex Elderf0f8cef2012-01-29 13:57:44 -0600369
370static struct bus_attribute rbd_bus_attrs[] = {
371 __ATTR(add, S_IWUSR, NULL, rbd_add),
372 __ATTR(remove, S_IWUSR, NULL, rbd_remove),
373 __ATTR_NULL
374};
375
376static struct bus_type rbd_bus_type = {
377 .name = "rbd",
378 .bus_attrs = rbd_bus_attrs,
379};
380
381static void rbd_root_dev_release(struct device *dev)
382{
383}
384
385static struct device rbd_root_dev = {
386 .init_name = "rbd",
387 .release = rbd_root_dev_release,
388};
389
Alex Elder06ecc6c2012-11-01 10:17:15 -0500390static __printf(2, 3)
391void rbd_warn(struct rbd_device *rbd_dev, const char *fmt, ...)
392{
393 struct va_format vaf;
394 va_list args;
395
396 va_start(args, fmt);
397 vaf.fmt = fmt;
398 vaf.va = &args;
399
400 if (!rbd_dev)
401 printk(KERN_WARNING "%s: %pV\n", RBD_DRV_NAME, &vaf);
402 else if (rbd_dev->disk)
403 printk(KERN_WARNING "%s: %s: %pV\n",
404 RBD_DRV_NAME, rbd_dev->disk->disk_name, &vaf);
405 else if (rbd_dev->spec && rbd_dev->spec->image_name)
406 printk(KERN_WARNING "%s: image %s: %pV\n",
407 RBD_DRV_NAME, rbd_dev->spec->image_name, &vaf);
408 else if (rbd_dev->spec && rbd_dev->spec->image_id)
409 printk(KERN_WARNING "%s: id %s: %pV\n",
410 RBD_DRV_NAME, rbd_dev->spec->image_id, &vaf);
411 else /* punt */
412 printk(KERN_WARNING "%s: rbd_dev %p: %pV\n",
413 RBD_DRV_NAME, rbd_dev, &vaf);
414 va_end(args);
415}
416
Alex Elderaafb2302012-09-06 16:00:54 -0500417#ifdef RBD_DEBUG
418#define rbd_assert(expr) \
419 if (unlikely(!(expr))) { \
420 printk(KERN_ERR "\nAssertion failure in %s() " \
421 "at line %d:\n\n" \
422 "\trbd_assert(%s);\n\n", \
423 __func__, __LINE__, #expr); \
424 BUG(); \
425 }
426#else /* !RBD_DEBUG */
427# define rbd_assert(expr) ((void) 0)
428#endif /* !RBD_DEBUG */
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800429
Alex Elderb454e362013-04-19 15:34:50 -0500430static int rbd_img_obj_request_submit(struct rbd_obj_request *obj_request);
Alex Elder05a46af2013-04-26 15:44:36 -0500431static void rbd_img_parent_read(struct rbd_obj_request *obj_request);
432static void rbd_dev_remove_parent(struct rbd_device *rbd_dev);
Alex Elder8b3e1a52013-01-24 16:13:36 -0600433
Alex Elder117973f2012-08-31 17:29:55 -0500434static int rbd_dev_refresh(struct rbd_device *rbd_dev, u64 *hver);
435static int rbd_dev_v2_refresh(struct rbd_device *rbd_dev, u64 *hver);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700436
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700437static int rbd_open(struct block_device *bdev, fmode_t mode)
438{
Alex Elderf0f8cef2012-01-29 13:57:44 -0600439 struct rbd_device *rbd_dev = bdev->bd_disk->private_data;
Alex Elderb82d1672013-01-14 12:43:31 -0600440 bool removing = false;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700441
Alex Elderf84344f2012-08-31 17:29:51 -0500442 if ((mode & FMODE_WRITE) && rbd_dev->mapping.read_only)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700443 return -EROFS;
444
Alex Eldera14ea262013-02-05 13:23:12 -0600445 spin_lock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600446 if (test_bit(RBD_DEV_FLAG_REMOVING, &rbd_dev->flags))
447 removing = true;
448 else
449 rbd_dev->open_count++;
Alex Eldera14ea262013-02-05 13:23:12 -0600450 spin_unlock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600451 if (removing)
452 return -ENOENT;
453
Alex Elder42382b72012-11-16 09:29:16 -0600454 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Alex Elderc3e946c2012-11-16 09:29:16 -0600455 (void) get_device(&rbd_dev->dev);
Alex Elderf84344f2012-08-31 17:29:51 -0500456 set_device_ro(bdev, rbd_dev->mapping.read_only);
Alex Elder42382b72012-11-16 09:29:16 -0600457 mutex_unlock(&ctl_mutex);
Alex Elder340c7a22012-08-10 13:12:07 -0700458
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700459 return 0;
460}
461
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800462static int rbd_release(struct gendisk *disk, fmode_t mode)
463{
464 struct rbd_device *rbd_dev = disk->private_data;
Alex Elderb82d1672013-01-14 12:43:31 -0600465 unsigned long open_count_before;
466
Alex Eldera14ea262013-02-05 13:23:12 -0600467 spin_lock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600468 open_count_before = rbd_dev->open_count--;
Alex Eldera14ea262013-02-05 13:23:12 -0600469 spin_unlock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600470 rbd_assert(open_count_before > 0);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800471
Alex Elder42382b72012-11-16 09:29:16 -0600472 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Alex Elderc3e946c2012-11-16 09:29:16 -0600473 put_device(&rbd_dev->dev);
Alex Elder42382b72012-11-16 09:29:16 -0600474 mutex_unlock(&ctl_mutex);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800475
476 return 0;
477}
478
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700479static const struct block_device_operations rbd_bd_ops = {
480 .owner = THIS_MODULE,
481 .open = rbd_open,
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800482 .release = rbd_release,
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700483};
484
485/*
486 * Initialize an rbd client instance.
Alex Elder43ae4702012-07-03 16:01:18 -0500487 * We own *ceph_opts.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700488 */
Alex Elderf8c38922012-08-10 13:12:07 -0700489static struct rbd_client *rbd_client_create(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700490{
491 struct rbd_client *rbdc;
492 int ret = -ENOMEM;
493
Alex Elder37206ee2013-02-20 17:32:08 -0600494 dout("%s:\n", __func__);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700495 rbdc = kmalloc(sizeof(struct rbd_client), GFP_KERNEL);
496 if (!rbdc)
497 goto out_opt;
498
499 kref_init(&rbdc->kref);
500 INIT_LIST_HEAD(&rbdc->node);
501
Alex Elderbc534d82012-01-29 13:57:44 -0600502 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
503
Alex Elder43ae4702012-07-03 16:01:18 -0500504 rbdc->client = ceph_create_client(ceph_opts, rbdc, 0, 0);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700505 if (IS_ERR(rbdc->client))
Alex Elderbc534d82012-01-29 13:57:44 -0600506 goto out_mutex;
Alex Elder43ae4702012-07-03 16:01:18 -0500507 ceph_opts = NULL; /* Now rbdc->client is responsible for ceph_opts */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700508
509 ret = ceph_open_session(rbdc->client);
510 if (ret < 0)
511 goto out_err;
512
Alex Elder432b8582012-01-29 13:57:44 -0600513 spin_lock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700514 list_add_tail(&rbdc->node, &rbd_client_list);
Alex Elder432b8582012-01-29 13:57:44 -0600515 spin_unlock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700516
Alex Elderbc534d82012-01-29 13:57:44 -0600517 mutex_unlock(&ctl_mutex);
Alex Elder37206ee2013-02-20 17:32:08 -0600518 dout("%s: rbdc %p\n", __func__, rbdc);
Alex Elderbc534d82012-01-29 13:57:44 -0600519
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700520 return rbdc;
521
522out_err:
523 ceph_destroy_client(rbdc->client);
Alex Elderbc534d82012-01-29 13:57:44 -0600524out_mutex:
525 mutex_unlock(&ctl_mutex);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700526 kfree(rbdc);
527out_opt:
Alex Elder43ae4702012-07-03 16:01:18 -0500528 if (ceph_opts)
529 ceph_destroy_options(ceph_opts);
Alex Elder37206ee2013-02-20 17:32:08 -0600530 dout("%s: error %d\n", __func__, ret);
531
Vasiliy Kulikov28f259b2010-09-26 12:59:37 +0400532 return ERR_PTR(ret);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700533}
534
Alex Elder2f82ee52012-10-30 19:40:33 -0500535static struct rbd_client *__rbd_get_client(struct rbd_client *rbdc)
536{
537 kref_get(&rbdc->kref);
538
539 return rbdc;
540}
541
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700542/*
Alex Elder1f7ba332012-08-10 13:12:07 -0700543 * Find a ceph client with specific addr and configuration. If
544 * found, bump its reference count.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700545 */
Alex Elder1f7ba332012-08-10 13:12:07 -0700546static struct rbd_client *rbd_client_find(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700547{
548 struct rbd_client *client_node;
Alex Elder1f7ba332012-08-10 13:12:07 -0700549 bool found = false;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700550
Alex Elder43ae4702012-07-03 16:01:18 -0500551 if (ceph_opts->flags & CEPH_OPT_NOSHARE)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700552 return NULL;
553
Alex Elder1f7ba332012-08-10 13:12:07 -0700554 spin_lock(&rbd_client_list_lock);
555 list_for_each_entry(client_node, &rbd_client_list, node) {
556 if (!ceph_compare_options(ceph_opts, client_node->client)) {
Alex Elder2f82ee52012-10-30 19:40:33 -0500557 __rbd_get_client(client_node);
558
Alex Elder1f7ba332012-08-10 13:12:07 -0700559 found = true;
560 break;
561 }
562 }
563 spin_unlock(&rbd_client_list_lock);
564
565 return found ? client_node : NULL;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700566}
567
568/*
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700569 * mount options
570 */
571enum {
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700572 Opt_last_int,
573 /* int args above */
574 Opt_last_string,
575 /* string args above */
Alex Eldercc0538b2012-08-10 13:12:07 -0700576 Opt_read_only,
577 Opt_read_write,
578 /* Boolean args above */
579 Opt_last_bool,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700580};
581
Alex Elder43ae4702012-07-03 16:01:18 -0500582static match_table_t rbd_opts_tokens = {
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700583 /* int args above */
584 /* string args above */
Alex Elderbe466c12012-10-22 11:31:26 -0500585 {Opt_read_only, "read_only"},
Alex Eldercc0538b2012-08-10 13:12:07 -0700586 {Opt_read_only, "ro"}, /* Alternate spelling */
587 {Opt_read_write, "read_write"},
588 {Opt_read_write, "rw"}, /* Alternate spelling */
589 /* Boolean args above */
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700590 {-1, NULL}
591};
592
Alex Elder98571b52013-01-20 14:44:42 -0600593struct rbd_options {
594 bool read_only;
595};
596
597#define RBD_READ_ONLY_DEFAULT false
598
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700599static int parse_rbd_opts_token(char *c, void *private)
600{
Alex Elder43ae4702012-07-03 16:01:18 -0500601 struct rbd_options *rbd_opts = private;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700602 substring_t argstr[MAX_OPT_ARGS];
603 int token, intval, ret;
604
Alex Elder43ae4702012-07-03 16:01:18 -0500605 token = match_token(c, rbd_opts_tokens, argstr);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700606 if (token < 0)
607 return -EINVAL;
608
609 if (token < Opt_last_int) {
610 ret = match_int(&argstr[0], &intval);
611 if (ret < 0) {
612 pr_err("bad mount option arg (not int) "
613 "at '%s'\n", c);
614 return ret;
615 }
616 dout("got int token %d val %d\n", token, intval);
617 } else if (token > Opt_last_int && token < Opt_last_string) {
618 dout("got string token %d val %s\n", token,
619 argstr[0].from);
Alex Eldercc0538b2012-08-10 13:12:07 -0700620 } else if (token > Opt_last_string && token < Opt_last_bool) {
621 dout("got Boolean token %d\n", token);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700622 } else {
623 dout("got token %d\n", token);
624 }
625
626 switch (token) {
Alex Eldercc0538b2012-08-10 13:12:07 -0700627 case Opt_read_only:
628 rbd_opts->read_only = true;
629 break;
630 case Opt_read_write:
631 rbd_opts->read_only = false;
632 break;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700633 default:
Alex Elderaafb2302012-09-06 16:00:54 -0500634 rbd_assert(false);
635 break;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700636 }
637 return 0;
638}
639
640/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700641 * Get a ceph client with specific addr and configuration, if one does
642 * not exist create it.
643 */
Alex Elder9d3997f2012-10-25 23:34:42 -0500644static struct rbd_client *rbd_get_client(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700645{
Alex Elderf8c38922012-08-10 13:12:07 -0700646 struct rbd_client *rbdc;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700647
Alex Elder1f7ba332012-08-10 13:12:07 -0700648 rbdc = rbd_client_find(ceph_opts);
Alex Elder9d3997f2012-10-25 23:34:42 -0500649 if (rbdc) /* using an existing client */
Alex Elder43ae4702012-07-03 16:01:18 -0500650 ceph_destroy_options(ceph_opts);
Alex Elder9d3997f2012-10-25 23:34:42 -0500651 else
Alex Elderf8c38922012-08-10 13:12:07 -0700652 rbdc = rbd_client_create(ceph_opts);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700653
Alex Elder9d3997f2012-10-25 23:34:42 -0500654 return rbdc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700655}
656
657/*
658 * Destroy ceph client
Alex Elderd23a4b32012-01-29 13:57:43 -0600659 *
Alex Elder432b8582012-01-29 13:57:44 -0600660 * Caller must hold rbd_client_list_lock.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700661 */
662static void rbd_client_release(struct kref *kref)
663{
664 struct rbd_client *rbdc = container_of(kref, struct rbd_client, kref);
665
Alex Elder37206ee2013-02-20 17:32:08 -0600666 dout("%s: rbdc %p\n", __func__, rbdc);
Alex Eldercd9d9f52012-04-04 13:35:44 -0500667 spin_lock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700668 list_del(&rbdc->node);
Alex Eldercd9d9f52012-04-04 13:35:44 -0500669 spin_unlock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700670
671 ceph_destroy_client(rbdc->client);
672 kfree(rbdc);
673}
674
Alex Elder468521c2013-04-26 09:43:47 -0500675/* Caller has to fill in snapc->seq and snapc->snaps[0..snap_count-1] */
676
677static struct ceph_snap_context *rbd_snap_context_create(u32 snap_count)
678{
679 struct ceph_snap_context *snapc;
680 size_t size;
681
682 size = sizeof (struct ceph_snap_context);
683 size += snap_count * sizeof (snapc->snaps[0]);
684 snapc = kzalloc(size, GFP_KERNEL);
685 if (!snapc)
686 return NULL;
687
688 atomic_set(&snapc->nref, 1);
689 snapc->num_snaps = snap_count;
690
691 return snapc;
692}
693
694static inline void rbd_snap_context_get(struct ceph_snap_context *snapc)
695{
696 (void)ceph_get_snap_context(snapc);
697}
698
699static inline void rbd_snap_context_put(struct ceph_snap_context *snapc)
700{
701 ceph_put_snap_context(snapc);
702}
703
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700704/*
705 * Drop reference to ceph client node. If it's not referenced anymore, release
706 * it.
707 */
Alex Elder9d3997f2012-10-25 23:34:42 -0500708static void rbd_put_client(struct rbd_client *rbdc)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700709{
Alex Elderc53d5892012-10-25 23:34:42 -0500710 if (rbdc)
711 kref_put(&rbdc->kref, rbd_client_release);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700712}
713
Alex Eldera30b71b2012-07-10 20:30:11 -0500714static bool rbd_image_format_valid(u32 image_format)
715{
716 return image_format == 1 || image_format == 2;
717}
718
Alex Elder8e94af82012-07-25 09:32:40 -0500719static bool rbd_dev_ondisk_valid(struct rbd_image_header_ondisk *ondisk)
720{
Alex Elder103a1502012-08-02 11:29:45 -0500721 size_t size;
722 u32 snap_count;
723
724 /* The header has to start with the magic rbd header text */
725 if (memcmp(&ondisk->text, RBD_HEADER_TEXT, sizeof (RBD_HEADER_TEXT)))
726 return false;
727
Alex Elderdb2388b2012-10-20 22:17:27 -0500728 /* The bio layer requires at least sector-sized I/O */
729
730 if (ondisk->options.order < SECTOR_SHIFT)
731 return false;
732
733 /* If we use u64 in a few spots we may be able to loosen this */
734
735 if (ondisk->options.order > 8 * sizeof (int) - 1)
736 return false;
737
Alex Elder103a1502012-08-02 11:29:45 -0500738 /*
739 * The size of a snapshot header has to fit in a size_t, and
740 * that limits the number of snapshots.
741 */
742 snap_count = le32_to_cpu(ondisk->snap_count);
743 size = SIZE_MAX - sizeof (struct ceph_snap_context);
744 if (snap_count > size / sizeof (__le64))
745 return false;
746
747 /*
748 * Not only that, but the size of the entire the snapshot
749 * header must also be representable in a size_t.
750 */
751 size -= snap_count * sizeof (__le64);
752 if ((u64) size < le64_to_cpu(ondisk->snap_names_len))
753 return false;
754
755 return true;
Alex Elder8e94af82012-07-25 09:32:40 -0500756}
757
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700758/*
759 * Create a new header structure, translate header format from the on-disk
760 * header.
761 */
762static int rbd_header_from_disk(struct rbd_image_header *header,
Alex Elder4156d9982012-08-02 11:29:46 -0500763 struct rbd_image_header_ondisk *ondisk)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700764{
Alex Elderccece232012-07-10 20:30:10 -0500765 u32 snap_count;
Alex Elder58c17b02012-08-23 23:22:06 -0500766 size_t len;
Alex Elderd2bb24e2012-07-26 23:37:14 -0500767 size_t size;
Alex Elder621901d2012-08-23 23:22:06 -0500768 u32 i;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700769
Alex Elder6a523252012-07-19 17:12:59 -0500770 memset(header, 0, sizeof (*header));
771
Alex Elder103a1502012-08-02 11:29:45 -0500772 snap_count = le32_to_cpu(ondisk->snap_count);
773
Alex Elder58c17b02012-08-23 23:22:06 -0500774 len = strnlen(ondisk->object_prefix, sizeof (ondisk->object_prefix));
775 header->object_prefix = kmalloc(len + 1, GFP_KERNEL);
Alex Elder6a523252012-07-19 17:12:59 -0500776 if (!header->object_prefix)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700777 return -ENOMEM;
Alex Elder58c17b02012-08-23 23:22:06 -0500778 memcpy(header->object_prefix, ondisk->object_prefix, len);
779 header->object_prefix[len] = '\0';
Alex Elder00f1f362012-02-07 12:03:36 -0600780
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700781 if (snap_count) {
Alex Elderf785cc12012-08-23 23:22:06 -0500782 u64 snap_names_len = le64_to_cpu(ondisk->snap_names_len);
783
Alex Elder621901d2012-08-23 23:22:06 -0500784 /* Save a copy of the snapshot names */
785
Alex Elderf785cc12012-08-23 23:22:06 -0500786 if (snap_names_len > (u64) SIZE_MAX)
787 return -EIO;
788 header->snap_names = kmalloc(snap_names_len, GFP_KERNEL);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700789 if (!header->snap_names)
Alex Elder6a523252012-07-19 17:12:59 -0500790 goto out_err;
Alex Elderf785cc12012-08-23 23:22:06 -0500791 /*
792 * Note that rbd_dev_v1_header_read() guarantees
793 * the ondisk buffer we're working with has
794 * snap_names_len bytes beyond the end of the
795 * snapshot id array, this memcpy() is safe.
796 */
797 memcpy(header->snap_names, &ondisk->snaps[snap_count],
798 snap_names_len);
Alex Elder6a523252012-07-19 17:12:59 -0500799
Alex Elder621901d2012-08-23 23:22:06 -0500800 /* Record each snapshot's size */
801
Alex Elderd2bb24e2012-07-26 23:37:14 -0500802 size = snap_count * sizeof (*header->snap_sizes);
803 header->snap_sizes = kmalloc(size, GFP_KERNEL);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700804 if (!header->snap_sizes)
Alex Elder6a523252012-07-19 17:12:59 -0500805 goto out_err;
Alex Elder621901d2012-08-23 23:22:06 -0500806 for (i = 0; i < snap_count; i++)
807 header->snap_sizes[i] =
808 le64_to_cpu(ondisk->snaps[i].image_size);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700809 } else {
810 header->snap_names = NULL;
811 header->snap_sizes = NULL;
812 }
Alex Elder849b4262012-07-09 21:04:24 -0500813
Alex Elder34b13182012-07-13 20:35:12 -0500814 header->features = 0; /* No features support in v1 images */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700815 header->obj_order = ondisk->options.order;
816 header->crypt_type = ondisk->options.crypt_type;
817 header->comp_type = ondisk->options.comp_type;
Alex Elder6a523252012-07-19 17:12:59 -0500818
Alex Elder621901d2012-08-23 23:22:06 -0500819 /* Allocate and fill in the snapshot context */
820
Alex Elderf84344f2012-08-31 17:29:51 -0500821 header->image_size = le64_to_cpu(ondisk->image_size);
Alex Elder468521c2013-04-26 09:43:47 -0500822
823 header->snapc = rbd_snap_context_create(snap_count);
Alex Elder6a523252012-07-19 17:12:59 -0500824 if (!header->snapc)
825 goto out_err;
Alex Elder505cbb92012-07-19 08:49:18 -0500826 header->snapc->seq = le64_to_cpu(ondisk->snap_seq);
Alex Elder621901d2012-08-23 23:22:06 -0500827 for (i = 0; i < snap_count; i++)
Alex Elder468521c2013-04-26 09:43:47 -0500828 header->snapc->snaps[i] = le64_to_cpu(ondisk->snaps[i].id);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700829
830 return 0;
831
Alex Elder6a523252012-07-19 17:12:59 -0500832out_err:
Alex Elder849b4262012-07-09 21:04:24 -0500833 kfree(header->snap_sizes);
Alex Elderccece232012-07-10 20:30:10 -0500834 header->snap_sizes = NULL;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700835 kfree(header->snap_names);
Alex Elderccece232012-07-10 20:30:10 -0500836 header->snap_names = NULL;
Alex Elder6a523252012-07-19 17:12:59 -0500837 kfree(header->object_prefix);
838 header->object_prefix = NULL;
Alex Elderccece232012-07-10 20:30:10 -0500839
Alex Elder00f1f362012-02-07 12:03:36 -0600840 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700841}
842
Alex Elder9e15b772012-10-30 19:40:33 -0500843static const char *rbd_snap_name(struct rbd_device *rbd_dev, u64 snap_id)
844{
845 struct rbd_snap *snap;
846
847 if (snap_id == CEPH_NOSNAP)
848 return RBD_SNAP_HEAD_NAME;
849
850 list_for_each_entry(snap, &rbd_dev->snaps, node)
851 if (snap_id == snap->id)
852 return snap->name;
853
854 return NULL;
855}
856
Alex Elder8b0241f2013-04-25 23:15:08 -0500857static struct rbd_snap *snap_by_name(struct rbd_device *rbd_dev,
858 const char *snap_name)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700859{
Alex Eldere86924a2012-07-10 20:30:11 -0500860 struct rbd_snap *snap;
Alex Elder00f1f362012-02-07 12:03:36 -0600861
Alex Elder8b0241f2013-04-25 23:15:08 -0500862 list_for_each_entry(snap, &rbd_dev->snaps, node)
863 if (!strcmp(snap_name, snap->name))
864 return snap;
Alex Elder00f1f362012-02-07 12:03:36 -0600865
Alex Elder8b0241f2013-04-25 23:15:08 -0500866 return NULL;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700867}
868
Alex Elderd1cf5782013-04-27 09:59:30 -0500869static int rbd_dev_mapping_set(struct rbd_device *rbd_dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700870{
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500871 if (!memcmp(rbd_dev->spec->snap_name, RBD_SNAP_HEAD_NAME,
Josh Durgincc9d7342011-11-21 18:19:13 -0800872 sizeof (RBD_SNAP_HEAD_NAME))) {
Alex Elder99c1f08f2012-08-30 14:42:15 -0500873 rbd_dev->mapping.size = rbd_dev->header.image_size;
Alex Elder34b13182012-07-13 20:35:12 -0500874 rbd_dev->mapping.features = rbd_dev->header.features;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700875 } else {
Alex Elder8b0241f2013-04-25 23:15:08 -0500876 struct rbd_snap *snap;
877
878 snap = snap_by_name(rbd_dev, rbd_dev->spec->snap_name);
879 if (!snap)
880 return -ENOENT;
Alex Elder8b0241f2013-04-25 23:15:08 -0500881 rbd_dev->mapping.size = snap->size;
882 rbd_dev->mapping.features = snap->features;
Alex Elderf84344f2012-08-31 17:29:51 -0500883 rbd_dev->mapping.read_only = true;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700884 }
Alex Elder6d292902013-01-14 12:43:31 -0600885
Alex Elder8b0241f2013-04-25 23:15:08 -0500886 return 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700887}
888
Alex Elderd1cf5782013-04-27 09:59:30 -0500889static void rbd_dev_mapping_clear(struct rbd_device *rbd_dev)
890{
891 rbd_dev->mapping.size = 0;
892 rbd_dev->mapping.features = 0;
893 rbd_dev->mapping.read_only = true;
894}
895
Alex Elder200a6a82013-04-28 23:32:34 -0500896static void rbd_dev_clear_mapping(struct rbd_device *rbd_dev)
897{
898 rbd_dev->mapping.size = 0;
899 rbd_dev->mapping.features = 0;
900 rbd_dev->mapping.read_only = true;
901}
902
Alex Elder98571b52013-01-20 14:44:42 -0600903static const char *rbd_segment_name(struct rbd_device *rbd_dev, u64 offset)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700904{
Alex Elder65ccfe22012-08-09 10:33:26 -0700905 char *name;
906 u64 segment;
907 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700908
Alex Elder2fd82b92012-11-09 15:05:54 -0600909 name = kmalloc(MAX_OBJ_NAME_SIZE + 1, GFP_NOIO);
Alex Elder65ccfe22012-08-09 10:33:26 -0700910 if (!name)
911 return NULL;
912 segment = offset >> rbd_dev->header.obj_order;
Alex Elder2fd82b92012-11-09 15:05:54 -0600913 ret = snprintf(name, MAX_OBJ_NAME_SIZE + 1, "%s.%012llx",
Alex Elder65ccfe22012-08-09 10:33:26 -0700914 rbd_dev->header.object_prefix, segment);
Alex Elder2fd82b92012-11-09 15:05:54 -0600915 if (ret < 0 || ret > MAX_OBJ_NAME_SIZE) {
Alex Elder65ccfe22012-08-09 10:33:26 -0700916 pr_err("error formatting segment name for #%llu (%d)\n",
917 segment, ret);
918 kfree(name);
919 name = NULL;
920 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700921
Alex Elder65ccfe22012-08-09 10:33:26 -0700922 return name;
923}
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700924
Alex Elder65ccfe22012-08-09 10:33:26 -0700925static u64 rbd_segment_offset(struct rbd_device *rbd_dev, u64 offset)
926{
927 u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700928
Alex Elder65ccfe22012-08-09 10:33:26 -0700929 return offset & (segment_size - 1);
930}
931
932static u64 rbd_segment_length(struct rbd_device *rbd_dev,
933 u64 offset, u64 length)
934{
935 u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
936
937 offset &= segment_size - 1;
938
Alex Elderaafb2302012-09-06 16:00:54 -0500939 rbd_assert(length <= U64_MAX - offset);
Alex Elder65ccfe22012-08-09 10:33:26 -0700940 if (offset + length > segment_size)
941 length = segment_size - offset;
942
943 return length;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700944}
945
946/*
Josh Durgin029bcbd2011-07-22 11:35:23 -0700947 * returns the size of an object in the image
948 */
949static u64 rbd_obj_bytes(struct rbd_image_header *header)
950{
951 return 1 << header->obj_order;
952}
953
954/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700955 * bio helpers
956 */
957
958static void bio_chain_put(struct bio *chain)
959{
960 struct bio *tmp;
961
962 while (chain) {
963 tmp = chain;
964 chain = chain->bi_next;
965 bio_put(tmp);
966 }
967}
968
969/*
970 * zeros a bio chain, starting at specific offset
971 */
972static void zero_bio_chain(struct bio *chain, int start_ofs)
973{
974 struct bio_vec *bv;
975 unsigned long flags;
976 void *buf;
977 int i;
978 int pos = 0;
979
980 while (chain) {
981 bio_for_each_segment(bv, chain, i) {
982 if (pos + bv->bv_len > start_ofs) {
983 int remainder = max(start_ofs - pos, 0);
984 buf = bvec_kmap_irq(bv, &flags);
985 memset(buf + remainder, 0,
986 bv->bv_len - remainder);
Dan Carpenter85b5aaa2010-10-11 21:15:11 +0200987 bvec_kunmap_irq(buf, &flags);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700988 }
989 pos += bv->bv_len;
990 }
991
992 chain = chain->bi_next;
993 }
994}
995
996/*
Alex Elderb9434c52013-04-19 15:34:50 -0500997 * similar to zero_bio_chain(), zeros data defined by a page array,
998 * starting at the given byte offset from the start of the array and
999 * continuing up to the given end offset. The pages array is
1000 * assumed to be big enough to hold all bytes up to the end.
1001 */
1002static void zero_pages(struct page **pages, u64 offset, u64 end)
1003{
1004 struct page **page = &pages[offset >> PAGE_SHIFT];
1005
1006 rbd_assert(end > offset);
1007 rbd_assert(end - offset <= (u64)SIZE_MAX);
1008 while (offset < end) {
1009 size_t page_offset;
1010 size_t length;
1011 unsigned long flags;
1012 void *kaddr;
1013
1014 page_offset = (size_t)(offset & ~PAGE_MASK);
1015 length = min(PAGE_SIZE - page_offset, (size_t)(end - offset));
1016 local_irq_save(flags);
1017 kaddr = kmap_atomic(*page);
1018 memset(kaddr + page_offset, 0, length);
1019 kunmap_atomic(kaddr);
1020 local_irq_restore(flags);
1021
1022 offset += length;
1023 page++;
1024 }
1025}
1026
1027/*
Alex Elderf7760da2012-10-20 22:17:27 -05001028 * Clone a portion of a bio, starting at the given byte offset
1029 * and continuing for the number of bytes indicated.
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001030 */
Alex Elderf7760da2012-10-20 22:17:27 -05001031static struct bio *bio_clone_range(struct bio *bio_src,
1032 unsigned int offset,
1033 unsigned int len,
1034 gfp_t gfpmask)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001035{
Alex Elderf7760da2012-10-20 22:17:27 -05001036 struct bio_vec *bv;
1037 unsigned int resid;
1038 unsigned short idx;
1039 unsigned int voff;
1040 unsigned short end_idx;
1041 unsigned short vcnt;
1042 struct bio *bio;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001043
Alex Elderf7760da2012-10-20 22:17:27 -05001044 /* Handle the easy case for the caller */
1045
1046 if (!offset && len == bio_src->bi_size)
1047 return bio_clone(bio_src, gfpmask);
1048
1049 if (WARN_ON_ONCE(!len))
1050 return NULL;
1051 if (WARN_ON_ONCE(len > bio_src->bi_size))
1052 return NULL;
1053 if (WARN_ON_ONCE(offset > bio_src->bi_size - len))
1054 return NULL;
1055
1056 /* Find first affected segment... */
1057
1058 resid = offset;
1059 __bio_for_each_segment(bv, bio_src, idx, 0) {
1060 if (resid < bv->bv_len)
1061 break;
1062 resid -= bv->bv_len;
1063 }
1064 voff = resid;
1065
1066 /* ...and the last affected segment */
1067
1068 resid += len;
1069 __bio_for_each_segment(bv, bio_src, end_idx, idx) {
1070 if (resid <= bv->bv_len)
1071 break;
1072 resid -= bv->bv_len;
1073 }
1074 vcnt = end_idx - idx + 1;
1075
1076 /* Build the clone */
1077
1078 bio = bio_alloc(gfpmask, (unsigned int) vcnt);
1079 if (!bio)
1080 return NULL; /* ENOMEM */
1081
1082 bio->bi_bdev = bio_src->bi_bdev;
1083 bio->bi_sector = bio_src->bi_sector + (offset >> SECTOR_SHIFT);
1084 bio->bi_rw = bio_src->bi_rw;
1085 bio->bi_flags |= 1 << BIO_CLONED;
1086
1087 /*
1088 * Copy over our part of the bio_vec, then update the first
1089 * and last (or only) entries.
1090 */
1091 memcpy(&bio->bi_io_vec[0], &bio_src->bi_io_vec[idx],
1092 vcnt * sizeof (struct bio_vec));
1093 bio->bi_io_vec[0].bv_offset += voff;
1094 if (vcnt > 1) {
1095 bio->bi_io_vec[0].bv_len -= voff;
1096 bio->bi_io_vec[vcnt - 1].bv_len = resid;
1097 } else {
1098 bio->bi_io_vec[0].bv_len = len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001099 }
1100
Alex Elderf7760da2012-10-20 22:17:27 -05001101 bio->bi_vcnt = vcnt;
1102 bio->bi_size = len;
1103 bio->bi_idx = 0;
Alex Elder542582f2012-08-09 10:33:25 -07001104
Alex Elderf7760da2012-10-20 22:17:27 -05001105 return bio;
1106}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001107
Alex Elderf7760da2012-10-20 22:17:27 -05001108/*
1109 * Clone a portion of a bio chain, starting at the given byte offset
1110 * into the first bio in the source chain and continuing for the
1111 * number of bytes indicated. The result is another bio chain of
1112 * exactly the given length, or a null pointer on error.
1113 *
1114 * The bio_src and offset parameters are both in-out. On entry they
1115 * refer to the first source bio and the offset into that bio where
1116 * the start of data to be cloned is located.
1117 *
1118 * On return, bio_src is updated to refer to the bio in the source
1119 * chain that contains first un-cloned byte, and *offset will
1120 * contain the offset of that byte within that bio.
1121 */
1122static struct bio *bio_chain_clone_range(struct bio **bio_src,
1123 unsigned int *offset,
1124 unsigned int len,
1125 gfp_t gfpmask)
1126{
1127 struct bio *bi = *bio_src;
1128 unsigned int off = *offset;
1129 struct bio *chain = NULL;
1130 struct bio **end;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001131
Alex Elderf7760da2012-10-20 22:17:27 -05001132 /* Build up a chain of clone bios up to the limit */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001133
Alex Elderf7760da2012-10-20 22:17:27 -05001134 if (!bi || off >= bi->bi_size || !len)
1135 return NULL; /* Nothing to clone */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001136
Alex Elderf7760da2012-10-20 22:17:27 -05001137 end = &chain;
1138 while (len) {
1139 unsigned int bi_size;
1140 struct bio *bio;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001141
Alex Elderf5400b72012-11-01 10:17:15 -05001142 if (!bi) {
1143 rbd_warn(NULL, "bio_chain exhausted with %u left", len);
Alex Elderf7760da2012-10-20 22:17:27 -05001144 goto out_err; /* EINVAL; ran out of bio's */
Alex Elderf5400b72012-11-01 10:17:15 -05001145 }
Alex Elderf7760da2012-10-20 22:17:27 -05001146 bi_size = min_t(unsigned int, bi->bi_size - off, len);
1147 bio = bio_clone_range(bi, off, bi_size, gfpmask);
1148 if (!bio)
1149 goto out_err; /* ENOMEM */
1150
1151 *end = bio;
1152 end = &bio->bi_next;
1153
1154 off += bi_size;
1155 if (off == bi->bi_size) {
1156 bi = bi->bi_next;
1157 off = 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001158 }
Alex Elderf7760da2012-10-20 22:17:27 -05001159 len -= bi_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001160 }
Alex Elderf7760da2012-10-20 22:17:27 -05001161 *bio_src = bi;
1162 *offset = off;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001163
Alex Elderf7760da2012-10-20 22:17:27 -05001164 return chain;
1165out_err:
1166 bio_chain_put(chain);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001167
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001168 return NULL;
1169}
1170
Alex Elder926f9b32013-02-11 12:33:24 -06001171/*
1172 * The default/initial value for all object request flags is 0. For
1173 * each flag, once its value is set to 1 it is never reset to 0
1174 * again.
1175 */
Alex Elder6365d332013-02-11 12:33:24 -06001176static void obj_request_img_data_set(struct rbd_obj_request *obj_request)
1177{
1178 if (test_and_set_bit(OBJ_REQ_IMG_DATA, &obj_request->flags)) {
Alex Elder6365d332013-02-11 12:33:24 -06001179 struct rbd_device *rbd_dev;
1180
Alex Elder57acbaa2013-02-11 12:33:24 -06001181 rbd_dev = obj_request->img_request->rbd_dev;
Alex Elder6365d332013-02-11 12:33:24 -06001182 rbd_warn(rbd_dev, "obj_request %p already marked img_data\n",
1183 obj_request);
1184 }
1185}
1186
1187static bool obj_request_img_data_test(struct rbd_obj_request *obj_request)
1188{
1189 smp_mb();
1190 return test_bit(OBJ_REQ_IMG_DATA, &obj_request->flags) != 0;
1191}
1192
Alex Elder57acbaa2013-02-11 12:33:24 -06001193static void obj_request_done_set(struct rbd_obj_request *obj_request)
1194{
1195 if (test_and_set_bit(OBJ_REQ_DONE, &obj_request->flags)) {
1196 struct rbd_device *rbd_dev = NULL;
1197
1198 if (obj_request_img_data_test(obj_request))
1199 rbd_dev = obj_request->img_request->rbd_dev;
1200 rbd_warn(rbd_dev, "obj_request %p already marked done\n",
1201 obj_request);
1202 }
1203}
1204
1205static bool obj_request_done_test(struct rbd_obj_request *obj_request)
1206{
1207 smp_mb();
1208 return test_bit(OBJ_REQ_DONE, &obj_request->flags) != 0;
1209}
1210
Alex Elder5679c592013-02-11 12:33:24 -06001211/*
1212 * This sets the KNOWN flag after (possibly) setting the EXISTS
1213 * flag. The latter is set based on the "exists" value provided.
1214 *
1215 * Note that for our purposes once an object exists it never goes
1216 * away again. It's possible that the response from two existence
1217 * checks are separated by the creation of the target object, and
1218 * the first ("doesn't exist") response arrives *after* the second
1219 * ("does exist"). In that case we ignore the second one.
1220 */
1221static void obj_request_existence_set(struct rbd_obj_request *obj_request,
1222 bool exists)
1223{
1224 if (exists)
1225 set_bit(OBJ_REQ_EXISTS, &obj_request->flags);
1226 set_bit(OBJ_REQ_KNOWN, &obj_request->flags);
1227 smp_mb();
1228}
1229
1230static bool obj_request_known_test(struct rbd_obj_request *obj_request)
1231{
1232 smp_mb();
1233 return test_bit(OBJ_REQ_KNOWN, &obj_request->flags) != 0;
1234}
1235
1236static bool obj_request_exists_test(struct rbd_obj_request *obj_request)
1237{
1238 smp_mb();
1239 return test_bit(OBJ_REQ_EXISTS, &obj_request->flags) != 0;
1240}
1241
Alex Elderbf0d5f502012-11-22 00:00:08 -06001242static void rbd_obj_request_get(struct rbd_obj_request *obj_request)
1243{
Alex Elder37206ee2013-02-20 17:32:08 -06001244 dout("%s: obj %p (was %d)\n", __func__, obj_request,
1245 atomic_read(&obj_request->kref.refcount));
Alex Elderbf0d5f502012-11-22 00:00:08 -06001246 kref_get(&obj_request->kref);
1247}
1248
1249static void rbd_obj_request_destroy(struct kref *kref);
1250static void rbd_obj_request_put(struct rbd_obj_request *obj_request)
1251{
1252 rbd_assert(obj_request != NULL);
Alex Elder37206ee2013-02-20 17:32:08 -06001253 dout("%s: obj %p (was %d)\n", __func__, obj_request,
1254 atomic_read(&obj_request->kref.refcount));
Alex Elderbf0d5f502012-11-22 00:00:08 -06001255 kref_put(&obj_request->kref, rbd_obj_request_destroy);
1256}
1257
1258static void rbd_img_request_get(struct rbd_img_request *img_request)
1259{
Alex Elder37206ee2013-02-20 17:32:08 -06001260 dout("%s: img %p (was %d)\n", __func__, img_request,
1261 atomic_read(&img_request->kref.refcount));
Alex Elderbf0d5f502012-11-22 00:00:08 -06001262 kref_get(&img_request->kref);
1263}
1264
1265static void rbd_img_request_destroy(struct kref *kref);
1266static void rbd_img_request_put(struct rbd_img_request *img_request)
1267{
1268 rbd_assert(img_request != NULL);
Alex Elder37206ee2013-02-20 17:32:08 -06001269 dout("%s: img %p (was %d)\n", __func__, img_request,
1270 atomic_read(&img_request->kref.refcount));
Alex Elderbf0d5f502012-11-22 00:00:08 -06001271 kref_put(&img_request->kref, rbd_img_request_destroy);
1272}
1273
1274static inline void rbd_img_obj_request_add(struct rbd_img_request *img_request,
1275 struct rbd_obj_request *obj_request)
1276{
Alex Elder25dcf952013-01-25 17:08:55 -06001277 rbd_assert(obj_request->img_request == NULL);
1278
Alex Elderb155e862013-04-15 14:50:37 -05001279 /* Image request now owns object's original reference */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001280 obj_request->img_request = img_request;
Alex Elder25dcf952013-01-25 17:08:55 -06001281 obj_request->which = img_request->obj_request_count;
Alex Elder6365d332013-02-11 12:33:24 -06001282 rbd_assert(!obj_request_img_data_test(obj_request));
1283 obj_request_img_data_set(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001284 rbd_assert(obj_request->which != BAD_WHICH);
Alex Elder25dcf952013-01-25 17:08:55 -06001285 img_request->obj_request_count++;
1286 list_add_tail(&obj_request->links, &img_request->obj_requests);
Alex Elder37206ee2013-02-20 17:32:08 -06001287 dout("%s: img %p obj %p w=%u\n", __func__, img_request, obj_request,
1288 obj_request->which);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001289}
1290
1291static inline void rbd_img_obj_request_del(struct rbd_img_request *img_request,
1292 struct rbd_obj_request *obj_request)
1293{
1294 rbd_assert(obj_request->which != BAD_WHICH);
Alex Elder25dcf952013-01-25 17:08:55 -06001295
Alex Elder37206ee2013-02-20 17:32:08 -06001296 dout("%s: img %p obj %p w=%u\n", __func__, img_request, obj_request,
1297 obj_request->which);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001298 list_del(&obj_request->links);
Alex Elder25dcf952013-01-25 17:08:55 -06001299 rbd_assert(img_request->obj_request_count > 0);
1300 img_request->obj_request_count--;
1301 rbd_assert(obj_request->which == img_request->obj_request_count);
1302 obj_request->which = BAD_WHICH;
Alex Elder6365d332013-02-11 12:33:24 -06001303 rbd_assert(obj_request_img_data_test(obj_request));
Alex Elderbf0d5f502012-11-22 00:00:08 -06001304 rbd_assert(obj_request->img_request == img_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001305 obj_request->img_request = NULL;
Alex Elder25dcf952013-01-25 17:08:55 -06001306 obj_request->callback = NULL;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001307 rbd_obj_request_put(obj_request);
1308}
1309
1310static bool obj_request_type_valid(enum obj_request_type type)
1311{
1312 switch (type) {
Alex Elder9969ebc2013-01-18 12:31:10 -06001313 case OBJ_REQUEST_NODATA:
Alex Elderbf0d5f502012-11-22 00:00:08 -06001314 case OBJ_REQUEST_BIO:
Alex Elder788e2df2013-01-17 12:25:27 -06001315 case OBJ_REQUEST_PAGES:
Alex Elderbf0d5f502012-11-22 00:00:08 -06001316 return true;
1317 default:
1318 return false;
1319 }
1320}
1321
Alex Elderbf0d5f502012-11-22 00:00:08 -06001322static int rbd_obj_request_submit(struct ceph_osd_client *osdc,
1323 struct rbd_obj_request *obj_request)
1324{
Alex Elder37206ee2013-02-20 17:32:08 -06001325 dout("%s: osdc %p obj %p\n", __func__, osdc, obj_request);
1326
Alex Elderbf0d5f502012-11-22 00:00:08 -06001327 return ceph_osdc_start_request(osdc, obj_request->osd_req, false);
1328}
1329
1330static void rbd_img_request_complete(struct rbd_img_request *img_request)
1331{
Alex Elder55f27e02013-04-10 12:34:25 -05001332
Alex Elder37206ee2013-02-20 17:32:08 -06001333 dout("%s: img %p\n", __func__, img_request);
Alex Elder55f27e02013-04-10 12:34:25 -05001334
1335 /*
1336 * If no error occurred, compute the aggregate transfer
1337 * count for the image request. We could instead use
1338 * atomic64_cmpxchg() to update it as each object request
1339 * completes; not clear which way is better off hand.
1340 */
1341 if (!img_request->result) {
1342 struct rbd_obj_request *obj_request;
1343 u64 xferred = 0;
1344
1345 for_each_obj_request(img_request, obj_request)
1346 xferred += obj_request->xferred;
1347 img_request->xferred = xferred;
1348 }
1349
Alex Elderbf0d5f502012-11-22 00:00:08 -06001350 if (img_request->callback)
1351 img_request->callback(img_request);
1352 else
1353 rbd_img_request_put(img_request);
1354}
1355
Alex Elder788e2df2013-01-17 12:25:27 -06001356/* Caller is responsible for rbd_obj_request_destroy(obj_request) */
1357
1358static int rbd_obj_request_wait(struct rbd_obj_request *obj_request)
1359{
Alex Elder37206ee2013-02-20 17:32:08 -06001360 dout("%s: obj %p\n", __func__, obj_request);
1361
Alex Elder788e2df2013-01-17 12:25:27 -06001362 return wait_for_completion_interruptible(&obj_request->completion);
1363}
1364
Alex Elder0c425242013-02-08 09:55:49 -06001365/*
1366 * The default/initial value for all image request flags is 0. Each
1367 * is conditionally set to 1 at image request initialization time
1368 * and currently never change thereafter.
1369 */
1370static void img_request_write_set(struct rbd_img_request *img_request)
1371{
1372 set_bit(IMG_REQ_WRITE, &img_request->flags);
1373 smp_mb();
1374}
1375
1376static bool img_request_write_test(struct rbd_img_request *img_request)
1377{
1378 smp_mb();
1379 return test_bit(IMG_REQ_WRITE, &img_request->flags) != 0;
1380}
1381
Alex Elder9849e982013-01-24 16:13:36 -06001382static void img_request_child_set(struct rbd_img_request *img_request)
1383{
1384 set_bit(IMG_REQ_CHILD, &img_request->flags);
1385 smp_mb();
1386}
1387
1388static bool img_request_child_test(struct rbd_img_request *img_request)
1389{
1390 smp_mb();
1391 return test_bit(IMG_REQ_CHILD, &img_request->flags) != 0;
1392}
1393
Alex Elderd0b2e942013-01-24 16:13:36 -06001394static void img_request_layered_set(struct rbd_img_request *img_request)
1395{
1396 set_bit(IMG_REQ_LAYERED, &img_request->flags);
1397 smp_mb();
1398}
1399
1400static bool img_request_layered_test(struct rbd_img_request *img_request)
1401{
1402 smp_mb();
1403 return test_bit(IMG_REQ_LAYERED, &img_request->flags) != 0;
1404}
1405
Alex Elder6e2a4502013-03-27 09:16:30 -05001406static void
1407rbd_img_obj_request_read_callback(struct rbd_obj_request *obj_request)
1408{
Alex Elderb9434c52013-04-19 15:34:50 -05001409 u64 xferred = obj_request->xferred;
1410 u64 length = obj_request->length;
1411
Alex Elder6e2a4502013-03-27 09:16:30 -05001412 dout("%s: obj %p img %p result %d %llu/%llu\n", __func__,
1413 obj_request, obj_request->img_request, obj_request->result,
Alex Elderb9434c52013-04-19 15:34:50 -05001414 xferred, length);
Alex Elder6e2a4502013-03-27 09:16:30 -05001415 /*
1416 * ENOENT means a hole in the image. We zero-fill the
1417 * entire length of the request. A short read also implies
1418 * zero-fill to the end of the request. Either way we
1419 * update the xferred count to indicate the whole request
1420 * was satisfied.
1421 */
Alex Elderb9434c52013-04-19 15:34:50 -05001422 rbd_assert(obj_request->type != OBJ_REQUEST_NODATA);
Alex Elder6e2a4502013-03-27 09:16:30 -05001423 if (obj_request->result == -ENOENT) {
Alex Elderb9434c52013-04-19 15:34:50 -05001424 if (obj_request->type == OBJ_REQUEST_BIO)
1425 zero_bio_chain(obj_request->bio_list, 0);
1426 else
1427 zero_pages(obj_request->pages, 0, length);
Alex Elder6e2a4502013-03-27 09:16:30 -05001428 obj_request->result = 0;
Alex Elderb9434c52013-04-19 15:34:50 -05001429 obj_request->xferred = length;
1430 } else if (xferred < length && !obj_request->result) {
1431 if (obj_request->type == OBJ_REQUEST_BIO)
1432 zero_bio_chain(obj_request->bio_list, xferred);
1433 else
1434 zero_pages(obj_request->pages, xferred, length);
1435 obj_request->xferred = length;
Alex Elder6e2a4502013-03-27 09:16:30 -05001436 }
1437 obj_request_done_set(obj_request);
1438}
1439
Alex Elderbf0d5f502012-11-22 00:00:08 -06001440static void rbd_obj_request_complete(struct rbd_obj_request *obj_request)
1441{
Alex Elder37206ee2013-02-20 17:32:08 -06001442 dout("%s: obj %p cb %p\n", __func__, obj_request,
1443 obj_request->callback);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001444 if (obj_request->callback)
1445 obj_request->callback(obj_request);
Alex Elder788e2df2013-01-17 12:25:27 -06001446 else
1447 complete_all(&obj_request->completion);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001448}
1449
Alex Elderc47f9372013-02-26 14:23:07 -06001450static void rbd_osd_trivial_callback(struct rbd_obj_request *obj_request)
Alex Elder39bf2c52013-02-26 14:23:07 -06001451{
1452 dout("%s: obj %p\n", __func__, obj_request);
1453 obj_request_done_set(obj_request);
1454}
1455
Alex Elderc47f9372013-02-26 14:23:07 -06001456static void rbd_osd_read_callback(struct rbd_obj_request *obj_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001457{
Alex Elder57acbaa2013-02-11 12:33:24 -06001458 struct rbd_img_request *img_request = NULL;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05001459 struct rbd_device *rbd_dev = NULL;
Alex Elder57acbaa2013-02-11 12:33:24 -06001460 bool layered = false;
1461
1462 if (obj_request_img_data_test(obj_request)) {
1463 img_request = obj_request->img_request;
1464 layered = img_request && img_request_layered_test(img_request);
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05001465 rbd_dev = img_request->rbd_dev;
Alex Elder57acbaa2013-02-11 12:33:24 -06001466 }
Alex Elder8b3e1a52013-01-24 16:13:36 -06001467
1468 dout("%s: obj %p img %p result %d %llu/%llu\n", __func__,
1469 obj_request, img_request, obj_request->result,
1470 obj_request->xferred, obj_request->length);
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05001471 if (layered && obj_request->result == -ENOENT &&
1472 obj_request->img_offset < rbd_dev->parent_overlap)
Alex Elder8b3e1a52013-01-24 16:13:36 -06001473 rbd_img_parent_read(obj_request);
1474 else if (img_request)
Alex Elder6e2a4502013-03-27 09:16:30 -05001475 rbd_img_obj_request_read_callback(obj_request);
1476 else
1477 obj_request_done_set(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001478}
1479
Alex Elderc47f9372013-02-26 14:23:07 -06001480static void rbd_osd_write_callback(struct rbd_obj_request *obj_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001481{
Sage Weil1b83bef2013-02-25 16:11:12 -08001482 dout("%s: obj %p result %d %llu\n", __func__, obj_request,
1483 obj_request->result, obj_request->length);
1484 /*
Alex Elder8b3e1a52013-01-24 16:13:36 -06001485 * There is no such thing as a successful short write. Set
1486 * it to our originally-requested length.
Sage Weil1b83bef2013-02-25 16:11:12 -08001487 */
1488 obj_request->xferred = obj_request->length;
Alex Elder07741302013-02-05 23:41:50 -06001489 obj_request_done_set(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001490}
1491
Alex Elderfbfab532013-02-08 09:55:48 -06001492/*
1493 * For a simple stat call there's nothing to do. We'll do more if
1494 * this is part of a write sequence for a layered image.
1495 */
Alex Elderc47f9372013-02-26 14:23:07 -06001496static void rbd_osd_stat_callback(struct rbd_obj_request *obj_request)
Alex Elderfbfab532013-02-08 09:55:48 -06001497{
Alex Elder37206ee2013-02-20 17:32:08 -06001498 dout("%s: obj %p\n", __func__, obj_request);
Alex Elderfbfab532013-02-08 09:55:48 -06001499 obj_request_done_set(obj_request);
1500}
1501
Alex Elderbf0d5f502012-11-22 00:00:08 -06001502static void rbd_osd_req_callback(struct ceph_osd_request *osd_req,
1503 struct ceph_msg *msg)
1504{
1505 struct rbd_obj_request *obj_request = osd_req->r_priv;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001506 u16 opcode;
1507
Alex Elder37206ee2013-02-20 17:32:08 -06001508 dout("%s: osd_req %p msg %p\n", __func__, osd_req, msg);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001509 rbd_assert(osd_req == obj_request->osd_req);
Alex Elder57acbaa2013-02-11 12:33:24 -06001510 if (obj_request_img_data_test(obj_request)) {
1511 rbd_assert(obj_request->img_request);
1512 rbd_assert(obj_request->which != BAD_WHICH);
1513 } else {
1514 rbd_assert(obj_request->which == BAD_WHICH);
1515 }
Alex Elderbf0d5f502012-11-22 00:00:08 -06001516
Sage Weil1b83bef2013-02-25 16:11:12 -08001517 if (osd_req->r_result < 0)
1518 obj_request->result = osd_req->r_result;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001519 obj_request->version = le64_to_cpu(osd_req->r_reassert_version.version);
1520
Alex Elder0eefd472013-04-19 15:34:50 -05001521 BUG_ON(osd_req->r_num_ops > 2);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001522
Alex Elderc47f9372013-02-26 14:23:07 -06001523 /*
1524 * We support a 64-bit length, but ultimately it has to be
1525 * passed to blk_end_request(), which takes an unsigned int.
1526 */
Sage Weil1b83bef2013-02-25 16:11:12 -08001527 obj_request->xferred = osd_req->r_reply_op_len[0];
Alex Elder8b3e1a52013-01-24 16:13:36 -06001528 rbd_assert(obj_request->xferred < (u64)UINT_MAX);
Alex Elder79528732013-04-03 21:32:51 -05001529 opcode = osd_req->r_ops[0].op;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001530 switch (opcode) {
1531 case CEPH_OSD_OP_READ:
Alex Elderc47f9372013-02-26 14:23:07 -06001532 rbd_osd_read_callback(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001533 break;
1534 case CEPH_OSD_OP_WRITE:
Alex Elderc47f9372013-02-26 14:23:07 -06001535 rbd_osd_write_callback(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001536 break;
Alex Elderfbfab532013-02-08 09:55:48 -06001537 case CEPH_OSD_OP_STAT:
Alex Elderc47f9372013-02-26 14:23:07 -06001538 rbd_osd_stat_callback(obj_request);
Alex Elderfbfab532013-02-08 09:55:48 -06001539 break;
Alex Elder36be9a72013-01-19 00:30:28 -06001540 case CEPH_OSD_OP_CALL:
Alex Elderb8d70032012-11-30 17:53:04 -06001541 case CEPH_OSD_OP_NOTIFY_ACK:
Alex Elder9969ebc2013-01-18 12:31:10 -06001542 case CEPH_OSD_OP_WATCH:
Alex Elderc47f9372013-02-26 14:23:07 -06001543 rbd_osd_trivial_callback(obj_request);
Alex Elder9969ebc2013-01-18 12:31:10 -06001544 break;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001545 default:
1546 rbd_warn(NULL, "%s: unsupported op %hu\n",
1547 obj_request->object_name, (unsigned short) opcode);
1548 break;
1549 }
1550
Alex Elder07741302013-02-05 23:41:50 -06001551 if (obj_request_done_test(obj_request))
Alex Elderbf0d5f502012-11-22 00:00:08 -06001552 rbd_obj_request_complete(obj_request);
1553}
1554
Alex Elder9d4df012013-04-19 15:34:50 -05001555static void rbd_osd_req_format_read(struct rbd_obj_request *obj_request)
Alex Elder430c28c2013-04-03 21:32:51 -05001556{
1557 struct rbd_img_request *img_request = obj_request->img_request;
Alex Elder8c042b02013-04-03 01:28:58 -05001558 struct ceph_osd_request *osd_req = obj_request->osd_req;
Alex Elder9d4df012013-04-19 15:34:50 -05001559 u64 snap_id;
Alex Elder430c28c2013-04-03 21:32:51 -05001560
Alex Elder8c042b02013-04-03 01:28:58 -05001561 rbd_assert(osd_req != NULL);
Alex Elder430c28c2013-04-03 21:32:51 -05001562
Alex Elder9d4df012013-04-19 15:34:50 -05001563 snap_id = img_request ? img_request->snap_id : CEPH_NOSNAP;
Alex Elder8c042b02013-04-03 01:28:58 -05001564 ceph_osdc_build_request(osd_req, obj_request->offset,
Alex Elder9d4df012013-04-19 15:34:50 -05001565 NULL, snap_id, NULL);
1566}
1567
1568static void rbd_osd_req_format_write(struct rbd_obj_request *obj_request)
1569{
1570 struct rbd_img_request *img_request = obj_request->img_request;
1571 struct ceph_osd_request *osd_req = obj_request->osd_req;
1572 struct ceph_snap_context *snapc;
1573 struct timespec mtime = CURRENT_TIME;
1574
1575 rbd_assert(osd_req != NULL);
1576
1577 snapc = img_request ? img_request->snapc : NULL;
1578 ceph_osdc_build_request(osd_req, obj_request->offset,
1579 snapc, CEPH_NOSNAP, &mtime);
Alex Elder430c28c2013-04-03 21:32:51 -05001580}
1581
Alex Elderbf0d5f502012-11-22 00:00:08 -06001582static struct ceph_osd_request *rbd_osd_req_create(
1583 struct rbd_device *rbd_dev,
1584 bool write_request,
Alex Elder430c28c2013-04-03 21:32:51 -05001585 struct rbd_obj_request *obj_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001586{
Alex Elderbf0d5f502012-11-22 00:00:08 -06001587 struct ceph_snap_context *snapc = NULL;
1588 struct ceph_osd_client *osdc;
1589 struct ceph_osd_request *osd_req;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001590
Alex Elder6365d332013-02-11 12:33:24 -06001591 if (obj_request_img_data_test(obj_request)) {
1592 struct rbd_img_request *img_request = obj_request->img_request;
1593
Alex Elder0c425242013-02-08 09:55:49 -06001594 rbd_assert(write_request ==
1595 img_request_write_test(img_request));
1596 if (write_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001597 snapc = img_request->snapc;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001598 }
1599
1600 /* Allocate and initialize the request, for the single op */
1601
1602 osdc = &rbd_dev->rbd_client->client->osdc;
1603 osd_req = ceph_osdc_alloc_request(osdc, snapc, 1, false, GFP_ATOMIC);
1604 if (!osd_req)
1605 return NULL; /* ENOMEM */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001606
Alex Elder430c28c2013-04-03 21:32:51 -05001607 if (write_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001608 osd_req->r_flags = CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK;
Alex Elder430c28c2013-04-03 21:32:51 -05001609 else
Alex Elderbf0d5f502012-11-22 00:00:08 -06001610 osd_req->r_flags = CEPH_OSD_FLAG_READ;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001611
1612 osd_req->r_callback = rbd_osd_req_callback;
1613 osd_req->r_priv = obj_request;
1614
1615 osd_req->r_oid_len = strlen(obj_request->object_name);
1616 rbd_assert(osd_req->r_oid_len < sizeof (osd_req->r_oid));
1617 memcpy(osd_req->r_oid, obj_request->object_name, osd_req->r_oid_len);
1618
1619 osd_req->r_file_layout = rbd_dev->layout; /* struct */
1620
Alex Elderbf0d5f502012-11-22 00:00:08 -06001621 return osd_req;
1622}
1623
Alex Elder0eefd472013-04-19 15:34:50 -05001624/*
1625 * Create a copyup osd request based on the information in the
1626 * object request supplied. A copyup request has two osd ops,
1627 * a copyup method call, and a "normal" write request.
1628 */
1629static struct ceph_osd_request *
1630rbd_osd_req_create_copyup(struct rbd_obj_request *obj_request)
1631{
1632 struct rbd_img_request *img_request;
1633 struct ceph_snap_context *snapc;
1634 struct rbd_device *rbd_dev;
1635 struct ceph_osd_client *osdc;
1636 struct ceph_osd_request *osd_req;
1637
1638 rbd_assert(obj_request_img_data_test(obj_request));
1639 img_request = obj_request->img_request;
1640 rbd_assert(img_request);
1641 rbd_assert(img_request_write_test(img_request));
1642
1643 /* Allocate and initialize the request, for the two ops */
1644
1645 snapc = img_request->snapc;
1646 rbd_dev = img_request->rbd_dev;
1647 osdc = &rbd_dev->rbd_client->client->osdc;
1648 osd_req = ceph_osdc_alloc_request(osdc, snapc, 2, false, GFP_ATOMIC);
1649 if (!osd_req)
1650 return NULL; /* ENOMEM */
1651
1652 osd_req->r_flags = CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK;
1653 osd_req->r_callback = rbd_osd_req_callback;
1654 osd_req->r_priv = obj_request;
1655
1656 osd_req->r_oid_len = strlen(obj_request->object_name);
1657 rbd_assert(osd_req->r_oid_len < sizeof (osd_req->r_oid));
1658 memcpy(osd_req->r_oid, obj_request->object_name, osd_req->r_oid_len);
1659
1660 osd_req->r_file_layout = rbd_dev->layout; /* struct */
1661
1662 return osd_req;
1663}
1664
1665
Alex Elderbf0d5f502012-11-22 00:00:08 -06001666static void rbd_osd_req_destroy(struct ceph_osd_request *osd_req)
1667{
1668 ceph_osdc_put_request(osd_req);
1669}
1670
1671/* object_name is assumed to be a non-null pointer and NUL-terminated */
1672
1673static struct rbd_obj_request *rbd_obj_request_create(const char *object_name,
1674 u64 offset, u64 length,
1675 enum obj_request_type type)
1676{
1677 struct rbd_obj_request *obj_request;
1678 size_t size;
1679 char *name;
1680
1681 rbd_assert(obj_request_type_valid(type));
1682
1683 size = strlen(object_name) + 1;
1684 obj_request = kzalloc(sizeof (*obj_request) + size, GFP_KERNEL);
1685 if (!obj_request)
1686 return NULL;
1687
1688 name = (char *)(obj_request + 1);
1689 obj_request->object_name = memcpy(name, object_name, size);
1690 obj_request->offset = offset;
1691 obj_request->length = length;
Alex Elder926f9b32013-02-11 12:33:24 -06001692 obj_request->flags = 0;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001693 obj_request->which = BAD_WHICH;
1694 obj_request->type = type;
1695 INIT_LIST_HEAD(&obj_request->links);
Alex Elder788e2df2013-01-17 12:25:27 -06001696 init_completion(&obj_request->completion);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001697 kref_init(&obj_request->kref);
1698
Alex Elder37206ee2013-02-20 17:32:08 -06001699 dout("%s: \"%s\" %llu/%llu %d -> obj %p\n", __func__, object_name,
1700 offset, length, (int)type, obj_request);
1701
Alex Elderbf0d5f502012-11-22 00:00:08 -06001702 return obj_request;
1703}
1704
1705static void rbd_obj_request_destroy(struct kref *kref)
1706{
1707 struct rbd_obj_request *obj_request;
1708
1709 obj_request = container_of(kref, struct rbd_obj_request, kref);
1710
Alex Elder37206ee2013-02-20 17:32:08 -06001711 dout("%s: obj %p\n", __func__, obj_request);
1712
Alex Elderbf0d5f502012-11-22 00:00:08 -06001713 rbd_assert(obj_request->img_request == NULL);
1714 rbd_assert(obj_request->which == BAD_WHICH);
1715
1716 if (obj_request->osd_req)
1717 rbd_osd_req_destroy(obj_request->osd_req);
1718
1719 rbd_assert(obj_request_type_valid(obj_request->type));
1720 switch (obj_request->type) {
Alex Elder9969ebc2013-01-18 12:31:10 -06001721 case OBJ_REQUEST_NODATA:
1722 break; /* Nothing to do */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001723 case OBJ_REQUEST_BIO:
1724 if (obj_request->bio_list)
1725 bio_chain_put(obj_request->bio_list);
1726 break;
Alex Elder788e2df2013-01-17 12:25:27 -06001727 case OBJ_REQUEST_PAGES:
1728 if (obj_request->pages)
1729 ceph_release_page_vector(obj_request->pages,
1730 obj_request->page_count);
1731 break;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001732 }
1733
1734 kfree(obj_request);
1735}
1736
1737/*
1738 * Caller is responsible for filling in the list of object requests
1739 * that comprises the image request, and the Linux request pointer
1740 * (if there is one).
1741 */
Alex Eldercc344fa2013-02-19 12:25:56 -06001742static struct rbd_img_request *rbd_img_request_create(
1743 struct rbd_device *rbd_dev,
Alex Elderbf0d5f502012-11-22 00:00:08 -06001744 u64 offset, u64 length,
Alex Elder9849e982013-01-24 16:13:36 -06001745 bool write_request,
1746 bool child_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001747{
1748 struct rbd_img_request *img_request;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001749
1750 img_request = kmalloc(sizeof (*img_request), GFP_ATOMIC);
1751 if (!img_request)
1752 return NULL;
1753
1754 if (write_request) {
1755 down_read(&rbd_dev->header_rwsem);
Alex Elder468521c2013-04-26 09:43:47 -05001756 rbd_snap_context_get(rbd_dev->header.snapc);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001757 up_read(&rbd_dev->header_rwsem);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001758 }
1759
1760 img_request->rq = NULL;
1761 img_request->rbd_dev = rbd_dev;
1762 img_request->offset = offset;
1763 img_request->length = length;
Alex Elder0c425242013-02-08 09:55:49 -06001764 img_request->flags = 0;
1765 if (write_request) {
1766 img_request_write_set(img_request);
Alex Elder468521c2013-04-26 09:43:47 -05001767 img_request->snapc = rbd_dev->header.snapc;
Alex Elder0c425242013-02-08 09:55:49 -06001768 } else {
Alex Elderbf0d5f502012-11-22 00:00:08 -06001769 img_request->snap_id = rbd_dev->spec->snap_id;
Alex Elder0c425242013-02-08 09:55:49 -06001770 }
Alex Elder9849e982013-01-24 16:13:36 -06001771 if (child_request)
1772 img_request_child_set(img_request);
Alex Elderd0b2e942013-01-24 16:13:36 -06001773 if (rbd_dev->parent_spec)
1774 img_request_layered_set(img_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001775 spin_lock_init(&img_request->completion_lock);
1776 img_request->next_completion = 0;
1777 img_request->callback = NULL;
Alex Eldera5a337d2013-01-24 16:13:36 -06001778 img_request->result = 0;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001779 img_request->obj_request_count = 0;
1780 INIT_LIST_HEAD(&img_request->obj_requests);
1781 kref_init(&img_request->kref);
1782
1783 rbd_img_request_get(img_request); /* Avoid a warning */
1784 rbd_img_request_put(img_request); /* TEMPORARY */
1785
Alex Elder37206ee2013-02-20 17:32:08 -06001786 dout("%s: rbd_dev %p %s %llu/%llu -> img %p\n", __func__, rbd_dev,
1787 write_request ? "write" : "read", offset, length,
1788 img_request);
1789
Alex Elderbf0d5f502012-11-22 00:00:08 -06001790 return img_request;
1791}
1792
1793static void rbd_img_request_destroy(struct kref *kref)
1794{
1795 struct rbd_img_request *img_request;
1796 struct rbd_obj_request *obj_request;
1797 struct rbd_obj_request *next_obj_request;
1798
1799 img_request = container_of(kref, struct rbd_img_request, kref);
1800
Alex Elder37206ee2013-02-20 17:32:08 -06001801 dout("%s: img %p\n", __func__, img_request);
1802
Alex Elderbf0d5f502012-11-22 00:00:08 -06001803 for_each_obj_request_safe(img_request, obj_request, next_obj_request)
1804 rbd_img_obj_request_del(img_request, obj_request);
Alex Elder25dcf952013-01-25 17:08:55 -06001805 rbd_assert(img_request->obj_request_count == 0);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001806
Alex Elder0c425242013-02-08 09:55:49 -06001807 if (img_request_write_test(img_request))
Alex Elder468521c2013-04-26 09:43:47 -05001808 rbd_snap_context_put(img_request->snapc);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001809
Alex Elder8b3e1a52013-01-24 16:13:36 -06001810 if (img_request_child_test(img_request))
1811 rbd_obj_request_put(img_request->obj_request);
1812
Alex Elderbf0d5f502012-11-22 00:00:08 -06001813 kfree(img_request);
1814}
1815
Alex Elder12178572013-02-08 09:55:49 -06001816static bool rbd_img_obj_end_request(struct rbd_obj_request *obj_request)
1817{
Alex Elder6365d332013-02-11 12:33:24 -06001818 struct rbd_img_request *img_request;
Alex Elder12178572013-02-08 09:55:49 -06001819 unsigned int xferred;
1820 int result;
Alex Elder8b3e1a52013-01-24 16:13:36 -06001821 bool more;
Alex Elder12178572013-02-08 09:55:49 -06001822
Alex Elder6365d332013-02-11 12:33:24 -06001823 rbd_assert(obj_request_img_data_test(obj_request));
1824 img_request = obj_request->img_request;
1825
Alex Elder12178572013-02-08 09:55:49 -06001826 rbd_assert(obj_request->xferred <= (u64)UINT_MAX);
1827 xferred = (unsigned int)obj_request->xferred;
1828 result = obj_request->result;
1829 if (result) {
1830 struct rbd_device *rbd_dev = img_request->rbd_dev;
1831
1832 rbd_warn(rbd_dev, "%s %llx at %llx (%llx)\n",
1833 img_request_write_test(img_request) ? "write" : "read",
1834 obj_request->length, obj_request->img_offset,
1835 obj_request->offset);
1836 rbd_warn(rbd_dev, " result %d xferred %x\n",
1837 result, xferred);
1838 if (!img_request->result)
1839 img_request->result = result;
1840 }
1841
Alex Elderf1a47392013-04-19 15:34:50 -05001842 /* Image object requests don't own their page array */
1843
1844 if (obj_request->type == OBJ_REQUEST_PAGES) {
1845 obj_request->pages = NULL;
1846 obj_request->page_count = 0;
1847 }
1848
Alex Elder8b3e1a52013-01-24 16:13:36 -06001849 if (img_request_child_test(img_request)) {
1850 rbd_assert(img_request->obj_request != NULL);
1851 more = obj_request->which < img_request->obj_request_count - 1;
1852 } else {
1853 rbd_assert(img_request->rq != NULL);
1854 more = blk_end_request(img_request->rq, result, xferred);
1855 }
1856
1857 return more;
Alex Elder12178572013-02-08 09:55:49 -06001858}
1859
Alex Elder21692382013-04-05 01:27:12 -05001860static void rbd_img_obj_callback(struct rbd_obj_request *obj_request)
1861{
1862 struct rbd_img_request *img_request;
1863 u32 which = obj_request->which;
1864 bool more = true;
1865
Alex Elder6365d332013-02-11 12:33:24 -06001866 rbd_assert(obj_request_img_data_test(obj_request));
Alex Elder21692382013-04-05 01:27:12 -05001867 img_request = obj_request->img_request;
1868
1869 dout("%s: img %p obj %p\n", __func__, img_request, obj_request);
1870 rbd_assert(img_request != NULL);
Alex Elder21692382013-04-05 01:27:12 -05001871 rbd_assert(img_request->obj_request_count > 0);
1872 rbd_assert(which != BAD_WHICH);
1873 rbd_assert(which < img_request->obj_request_count);
1874 rbd_assert(which >= img_request->next_completion);
1875
1876 spin_lock_irq(&img_request->completion_lock);
1877 if (which != img_request->next_completion)
1878 goto out;
1879
1880 for_each_obj_request_from(img_request, obj_request) {
Alex Elder21692382013-04-05 01:27:12 -05001881 rbd_assert(more);
1882 rbd_assert(which < img_request->obj_request_count);
1883
1884 if (!obj_request_done_test(obj_request))
1885 break;
Alex Elder12178572013-02-08 09:55:49 -06001886 more = rbd_img_obj_end_request(obj_request);
Alex Elder21692382013-04-05 01:27:12 -05001887 which++;
1888 }
1889
1890 rbd_assert(more ^ (which == img_request->obj_request_count));
1891 img_request->next_completion = which;
1892out:
1893 spin_unlock_irq(&img_request->completion_lock);
1894
1895 if (!more)
1896 rbd_img_request_complete(img_request);
1897}
1898
Alex Elderf1a47392013-04-19 15:34:50 -05001899/*
1900 * Split up an image request into one or more object requests, each
1901 * to a different object. The "type" parameter indicates whether
1902 * "data_desc" is the pointer to the head of a list of bio
1903 * structures, or the base of a page array. In either case this
1904 * function assumes data_desc describes memory sufficient to hold
1905 * all data described by the image request.
1906 */
1907static int rbd_img_request_fill(struct rbd_img_request *img_request,
1908 enum obj_request_type type,
1909 void *data_desc)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001910{
1911 struct rbd_device *rbd_dev = img_request->rbd_dev;
1912 struct rbd_obj_request *obj_request = NULL;
1913 struct rbd_obj_request *next_obj_request;
Alex Elder0c425242013-02-08 09:55:49 -06001914 bool write_request = img_request_write_test(img_request);
Alex Elderf1a47392013-04-19 15:34:50 -05001915 struct bio *bio_list;
1916 unsigned int bio_offset = 0;
1917 struct page **pages;
Alex Elder7da22d22013-01-24 16:13:36 -06001918 u64 img_offset;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001919 u64 resid;
1920 u16 opcode;
1921
Alex Elderf1a47392013-04-19 15:34:50 -05001922 dout("%s: img %p type %d data_desc %p\n", __func__, img_request,
1923 (int)type, data_desc);
Alex Elder37206ee2013-02-20 17:32:08 -06001924
Alex Elder430c28c2013-04-03 21:32:51 -05001925 opcode = write_request ? CEPH_OSD_OP_WRITE : CEPH_OSD_OP_READ;
Alex Elder7da22d22013-01-24 16:13:36 -06001926 img_offset = img_request->offset;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001927 resid = img_request->length;
Alex Elder4dda41d2013-02-20 21:59:33 -06001928 rbd_assert(resid > 0);
Alex Elderf1a47392013-04-19 15:34:50 -05001929
1930 if (type == OBJ_REQUEST_BIO) {
1931 bio_list = data_desc;
1932 rbd_assert(img_offset == bio_list->bi_sector << SECTOR_SHIFT);
1933 } else {
1934 rbd_assert(type == OBJ_REQUEST_PAGES);
1935 pages = data_desc;
1936 }
1937
Alex Elderbf0d5f502012-11-22 00:00:08 -06001938 while (resid) {
Alex Elder2fa12322013-04-05 01:27:12 -05001939 struct ceph_osd_request *osd_req;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001940 const char *object_name;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001941 u64 offset;
1942 u64 length;
1943
Alex Elder7da22d22013-01-24 16:13:36 -06001944 object_name = rbd_segment_name(rbd_dev, img_offset);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001945 if (!object_name)
1946 goto out_unwind;
Alex Elder7da22d22013-01-24 16:13:36 -06001947 offset = rbd_segment_offset(rbd_dev, img_offset);
1948 length = rbd_segment_length(rbd_dev, img_offset, resid);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001949 obj_request = rbd_obj_request_create(object_name,
Alex Elderf1a47392013-04-19 15:34:50 -05001950 offset, length, type);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001951 kfree(object_name); /* object request has its own copy */
1952 if (!obj_request)
1953 goto out_unwind;
1954
Alex Elderf1a47392013-04-19 15:34:50 -05001955 if (type == OBJ_REQUEST_BIO) {
1956 unsigned int clone_size;
1957
1958 rbd_assert(length <= (u64)UINT_MAX);
1959 clone_size = (unsigned int)length;
1960 obj_request->bio_list =
1961 bio_chain_clone_range(&bio_list,
1962 &bio_offset,
1963 clone_size,
1964 GFP_ATOMIC);
1965 if (!obj_request->bio_list)
1966 goto out_partial;
1967 } else {
1968 unsigned int page_count;
1969
1970 obj_request->pages = pages;
1971 page_count = (u32)calc_pages_for(offset, length);
1972 obj_request->page_count = page_count;
1973 if ((offset + length) & ~PAGE_MASK)
1974 page_count--; /* more on last page */
1975 pages += page_count;
1976 }
Alex Elderbf0d5f502012-11-22 00:00:08 -06001977
Alex Elder2fa12322013-04-05 01:27:12 -05001978 osd_req = rbd_osd_req_create(rbd_dev, write_request,
1979 obj_request);
1980 if (!osd_req)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001981 goto out_partial;
Alex Elder2fa12322013-04-05 01:27:12 -05001982 obj_request->osd_req = osd_req;
Alex Elder21692382013-04-05 01:27:12 -05001983 obj_request->callback = rbd_img_obj_callback;
Alex Elder430c28c2013-04-03 21:32:51 -05001984
Alex Elder2fa12322013-04-05 01:27:12 -05001985 osd_req_op_extent_init(osd_req, 0, opcode, offset, length,
1986 0, 0);
Alex Elderf1a47392013-04-19 15:34:50 -05001987 if (type == OBJ_REQUEST_BIO)
1988 osd_req_op_extent_osd_data_bio(osd_req, 0,
1989 obj_request->bio_list, length);
1990 else
1991 osd_req_op_extent_osd_data_pages(osd_req, 0,
1992 obj_request->pages, length,
1993 offset & ~PAGE_MASK, false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05001994
1995 if (write_request)
1996 rbd_osd_req_format_write(obj_request);
1997 else
1998 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05001999
Alex Elder7da22d22013-01-24 16:13:36 -06002000 obj_request->img_offset = img_offset;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002001 rbd_img_obj_request_add(img_request, obj_request);
2002
Alex Elder7da22d22013-01-24 16:13:36 -06002003 img_offset += length;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002004 resid -= length;
2005 }
2006
2007 return 0;
2008
2009out_partial:
2010 rbd_obj_request_put(obj_request);
2011out_unwind:
2012 for_each_obj_request_safe(img_request, obj_request, next_obj_request)
2013 rbd_obj_request_put(obj_request);
2014
2015 return -ENOMEM;
2016}
2017
Alex Elder3d7efd12013-04-19 15:34:50 -05002018static void
Alex Elder0eefd472013-04-19 15:34:50 -05002019rbd_img_obj_copyup_callback(struct rbd_obj_request *obj_request)
2020{
2021 struct rbd_img_request *img_request;
2022 struct rbd_device *rbd_dev;
2023 u64 length;
2024 u32 page_count;
2025
2026 rbd_assert(obj_request->type == OBJ_REQUEST_BIO);
2027 rbd_assert(obj_request_img_data_test(obj_request));
2028 img_request = obj_request->img_request;
2029 rbd_assert(img_request);
2030
2031 rbd_dev = img_request->rbd_dev;
2032 rbd_assert(rbd_dev);
2033 length = (u64)1 << rbd_dev->header.obj_order;
2034 page_count = (u32)calc_pages_for(0, length);
2035
2036 rbd_assert(obj_request->copyup_pages);
2037 ceph_release_page_vector(obj_request->copyup_pages, page_count);
2038 obj_request->copyup_pages = NULL;
2039
2040 /*
2041 * We want the transfer count to reflect the size of the
2042 * original write request. There is no such thing as a
2043 * successful short write, so if the request was successful
2044 * we can just set it to the originally-requested length.
2045 */
2046 if (!obj_request->result)
2047 obj_request->xferred = obj_request->length;
2048
2049 /* Finish up with the normal image object callback */
2050
2051 rbd_img_obj_callback(obj_request);
2052}
2053
2054static void
Alex Elder3d7efd12013-04-19 15:34:50 -05002055rbd_img_obj_parent_read_full_callback(struct rbd_img_request *img_request)
2056{
2057 struct rbd_obj_request *orig_request;
Alex Elder0eefd472013-04-19 15:34:50 -05002058 struct ceph_osd_request *osd_req;
2059 struct ceph_osd_client *osdc;
2060 struct rbd_device *rbd_dev;
Alex Elder3d7efd12013-04-19 15:34:50 -05002061 struct page **pages;
Alex Elder3d7efd12013-04-19 15:34:50 -05002062 int result;
2063 u64 obj_size;
2064 u64 xferred;
2065
2066 rbd_assert(img_request_child_test(img_request));
2067
2068 /* First get what we need from the image request */
2069
2070 pages = img_request->copyup_pages;
2071 rbd_assert(pages != NULL);
2072 img_request->copyup_pages = NULL;
2073
2074 orig_request = img_request->obj_request;
2075 rbd_assert(orig_request != NULL);
Alex Elder0eefd472013-04-19 15:34:50 -05002076 rbd_assert(orig_request->type == OBJ_REQUEST_BIO);
Alex Elder3d7efd12013-04-19 15:34:50 -05002077 result = img_request->result;
2078 obj_size = img_request->length;
2079 xferred = img_request->xferred;
2080
Alex Elder0eefd472013-04-19 15:34:50 -05002081 rbd_dev = img_request->rbd_dev;
2082 rbd_assert(rbd_dev);
2083 rbd_assert(obj_size == (u64)1 << rbd_dev->header.obj_order);
2084
Alex Elder3d7efd12013-04-19 15:34:50 -05002085 rbd_img_request_put(img_request);
2086
Alex Elder0eefd472013-04-19 15:34:50 -05002087 if (result)
2088 goto out_err;
Alex Elder3d7efd12013-04-19 15:34:50 -05002089
Alex Elder0eefd472013-04-19 15:34:50 -05002090 /* Allocate the new copyup osd request for the original request */
Alex Elder3d7efd12013-04-19 15:34:50 -05002091
Alex Elder0eefd472013-04-19 15:34:50 -05002092 result = -ENOMEM;
2093 rbd_assert(!orig_request->osd_req);
2094 osd_req = rbd_osd_req_create_copyup(orig_request);
2095 if (!osd_req)
2096 goto out_err;
2097 orig_request->osd_req = osd_req;
2098 orig_request->copyup_pages = pages;
Alex Elder3d7efd12013-04-19 15:34:50 -05002099
Alex Elder0eefd472013-04-19 15:34:50 -05002100 /* Initialize the copyup op */
2101
2102 osd_req_op_cls_init(osd_req, 0, CEPH_OSD_OP_CALL, "rbd", "copyup");
2103 osd_req_op_cls_request_data_pages(osd_req, 0, pages, obj_size, 0,
2104 false, false);
2105
2106 /* Then the original write request op */
2107
2108 osd_req_op_extent_init(osd_req, 1, CEPH_OSD_OP_WRITE,
2109 orig_request->offset,
2110 orig_request->length, 0, 0);
2111 osd_req_op_extent_osd_data_bio(osd_req, 1, orig_request->bio_list,
2112 orig_request->length);
2113
2114 rbd_osd_req_format_write(orig_request);
2115
2116 /* All set, send it off. */
2117
2118 orig_request->callback = rbd_img_obj_copyup_callback;
2119 osdc = &rbd_dev->rbd_client->client->osdc;
2120 result = rbd_obj_request_submit(osdc, orig_request);
2121 if (!result)
2122 return;
2123out_err:
2124 /* Record the error code and complete the request */
2125
2126 orig_request->result = result;
2127 orig_request->xferred = 0;
2128 obj_request_done_set(orig_request);
2129 rbd_obj_request_complete(orig_request);
Alex Elder3d7efd12013-04-19 15:34:50 -05002130}
2131
2132/*
2133 * Read from the parent image the range of data that covers the
2134 * entire target of the given object request. This is used for
2135 * satisfying a layered image write request when the target of an
2136 * object request from the image request does not exist.
2137 *
2138 * A page array big enough to hold the returned data is allocated
2139 * and supplied to rbd_img_request_fill() as the "data descriptor."
2140 * When the read completes, this page array will be transferred to
2141 * the original object request for the copyup operation.
2142 *
2143 * If an error occurs, record it as the result of the original
2144 * object request and mark it done so it gets completed.
2145 */
2146static int rbd_img_obj_parent_read_full(struct rbd_obj_request *obj_request)
2147{
2148 struct rbd_img_request *img_request = NULL;
2149 struct rbd_img_request *parent_request = NULL;
2150 struct rbd_device *rbd_dev;
2151 u64 img_offset;
2152 u64 length;
2153 struct page **pages = NULL;
2154 u32 page_count;
2155 int result;
2156
2157 rbd_assert(obj_request_img_data_test(obj_request));
2158 rbd_assert(obj_request->type == OBJ_REQUEST_BIO);
2159
2160 img_request = obj_request->img_request;
2161 rbd_assert(img_request != NULL);
2162 rbd_dev = img_request->rbd_dev;
2163 rbd_assert(rbd_dev->parent != NULL);
2164
2165 /*
Alex Elder0eefd472013-04-19 15:34:50 -05002166 * First things first. The original osd request is of no
2167 * use to use any more, we'll need a new one that can hold
2168 * the two ops in a copyup request. We'll get that later,
2169 * but for now we can release the old one.
2170 */
2171 rbd_osd_req_destroy(obj_request->osd_req);
2172 obj_request->osd_req = NULL;
2173
2174 /*
Alex Elder3d7efd12013-04-19 15:34:50 -05002175 * Determine the byte range covered by the object in the
2176 * child image to which the original request was to be sent.
2177 */
2178 img_offset = obj_request->img_offset - obj_request->offset;
2179 length = (u64)1 << rbd_dev->header.obj_order;
2180
2181 /*
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002182 * There is no defined parent data beyond the parent
2183 * overlap, so limit what we read at that boundary if
2184 * necessary.
2185 */
2186 if (img_offset + length > rbd_dev->parent_overlap) {
2187 rbd_assert(img_offset < rbd_dev->parent_overlap);
2188 length = rbd_dev->parent_overlap - img_offset;
2189 }
2190
2191 /*
Alex Elder3d7efd12013-04-19 15:34:50 -05002192 * Allocate a page array big enough to receive the data read
2193 * from the parent.
2194 */
2195 page_count = (u32)calc_pages_for(0, length);
2196 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
2197 if (IS_ERR(pages)) {
2198 result = PTR_ERR(pages);
2199 pages = NULL;
2200 goto out_err;
2201 }
2202
2203 result = -ENOMEM;
2204 parent_request = rbd_img_request_create(rbd_dev->parent,
2205 img_offset, length,
2206 false, true);
2207 if (!parent_request)
2208 goto out_err;
2209 rbd_obj_request_get(obj_request);
2210 parent_request->obj_request = obj_request;
2211
2212 result = rbd_img_request_fill(parent_request, OBJ_REQUEST_PAGES, pages);
2213 if (result)
2214 goto out_err;
2215 parent_request->copyup_pages = pages;
2216
2217 parent_request->callback = rbd_img_obj_parent_read_full_callback;
2218 result = rbd_img_request_submit(parent_request);
2219 if (!result)
2220 return 0;
2221
2222 parent_request->copyup_pages = NULL;
2223 parent_request->obj_request = NULL;
2224 rbd_obj_request_put(obj_request);
2225out_err:
2226 if (pages)
2227 ceph_release_page_vector(pages, page_count);
2228 if (parent_request)
2229 rbd_img_request_put(parent_request);
2230 obj_request->result = result;
2231 obj_request->xferred = 0;
2232 obj_request_done_set(obj_request);
2233
2234 return result;
2235}
2236
Alex Elderc5b5ef62013-02-11 12:33:24 -06002237static void rbd_img_obj_exists_callback(struct rbd_obj_request *obj_request)
2238{
Alex Elderc5b5ef62013-02-11 12:33:24 -06002239 struct rbd_obj_request *orig_request;
2240 int result;
2241
2242 rbd_assert(!obj_request_img_data_test(obj_request));
2243
2244 /*
2245 * All we need from the object request is the original
2246 * request and the result of the STAT op. Grab those, then
2247 * we're done with the request.
2248 */
2249 orig_request = obj_request->obj_request;
2250 obj_request->obj_request = NULL;
2251 rbd_assert(orig_request);
2252 rbd_assert(orig_request->img_request);
2253
2254 result = obj_request->result;
2255 obj_request->result = 0;
2256
2257 dout("%s: obj %p for obj %p result %d %llu/%llu\n", __func__,
2258 obj_request, orig_request, result,
2259 obj_request->xferred, obj_request->length);
2260 rbd_obj_request_put(obj_request);
2261
2262 rbd_assert(orig_request);
2263 rbd_assert(orig_request->img_request);
Alex Elderc5b5ef62013-02-11 12:33:24 -06002264
2265 /*
2266 * Our only purpose here is to determine whether the object
2267 * exists, and we don't want to treat the non-existence as
2268 * an error. If something else comes back, transfer the
2269 * error to the original request and complete it now.
2270 */
2271 if (!result) {
2272 obj_request_existence_set(orig_request, true);
2273 } else if (result == -ENOENT) {
2274 obj_request_existence_set(orig_request, false);
2275 } else if (result) {
2276 orig_request->result = result;
Alex Elder3d7efd12013-04-19 15:34:50 -05002277 goto out;
Alex Elderc5b5ef62013-02-11 12:33:24 -06002278 }
2279
2280 /*
2281 * Resubmit the original request now that we have recorded
2282 * whether the target object exists.
2283 */
Alex Elderb454e362013-04-19 15:34:50 -05002284 orig_request->result = rbd_img_obj_request_submit(orig_request);
Alex Elder3d7efd12013-04-19 15:34:50 -05002285out:
Alex Elderc5b5ef62013-02-11 12:33:24 -06002286 if (orig_request->result)
2287 rbd_obj_request_complete(orig_request);
2288 rbd_obj_request_put(orig_request);
2289}
2290
2291static int rbd_img_obj_exists_submit(struct rbd_obj_request *obj_request)
2292{
2293 struct rbd_obj_request *stat_request;
2294 struct rbd_device *rbd_dev;
2295 struct ceph_osd_client *osdc;
2296 struct page **pages = NULL;
2297 u32 page_count;
2298 size_t size;
2299 int ret;
2300
2301 /*
2302 * The response data for a STAT call consists of:
2303 * le64 length;
2304 * struct {
2305 * le32 tv_sec;
2306 * le32 tv_nsec;
2307 * } mtime;
2308 */
2309 size = sizeof (__le64) + sizeof (__le32) + sizeof (__le32);
2310 page_count = (u32)calc_pages_for(0, size);
2311 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
2312 if (IS_ERR(pages))
2313 return PTR_ERR(pages);
2314
2315 ret = -ENOMEM;
2316 stat_request = rbd_obj_request_create(obj_request->object_name, 0, 0,
2317 OBJ_REQUEST_PAGES);
2318 if (!stat_request)
2319 goto out;
2320
2321 rbd_obj_request_get(obj_request);
2322 stat_request->obj_request = obj_request;
2323 stat_request->pages = pages;
2324 stat_request->page_count = page_count;
2325
2326 rbd_assert(obj_request->img_request);
2327 rbd_dev = obj_request->img_request->rbd_dev;
2328 stat_request->osd_req = rbd_osd_req_create(rbd_dev, false,
2329 stat_request);
2330 if (!stat_request->osd_req)
2331 goto out;
2332 stat_request->callback = rbd_img_obj_exists_callback;
2333
2334 osd_req_op_init(stat_request->osd_req, 0, CEPH_OSD_OP_STAT);
2335 osd_req_op_raw_data_in_pages(stat_request->osd_req, 0, pages, size, 0,
2336 false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05002337 rbd_osd_req_format_read(stat_request);
Alex Elderc5b5ef62013-02-11 12:33:24 -06002338
2339 osdc = &rbd_dev->rbd_client->client->osdc;
2340 ret = rbd_obj_request_submit(osdc, stat_request);
2341out:
2342 if (ret)
2343 rbd_obj_request_put(obj_request);
2344
2345 return ret;
2346}
2347
Alex Elderb454e362013-04-19 15:34:50 -05002348static int rbd_img_obj_request_submit(struct rbd_obj_request *obj_request)
2349{
2350 struct rbd_img_request *img_request;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002351 struct rbd_device *rbd_dev;
Alex Elder3d7efd12013-04-19 15:34:50 -05002352 bool known;
Alex Elderb454e362013-04-19 15:34:50 -05002353
2354 rbd_assert(obj_request_img_data_test(obj_request));
2355
2356 img_request = obj_request->img_request;
2357 rbd_assert(img_request);
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002358 rbd_dev = img_request->rbd_dev;
Alex Elderb454e362013-04-19 15:34:50 -05002359
Alex Elderb454e362013-04-19 15:34:50 -05002360 /*
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002361 * Only writes to layered images need special handling.
2362 * Reads and non-layered writes are simple object requests.
2363 * Layered writes that start beyond the end of the overlap
2364 * with the parent have no parent data, so they too are
2365 * simple object requests. Finally, if the target object is
2366 * known to already exist, its parent data has already been
2367 * copied, so a write to the object can also be handled as a
2368 * simple object request.
Alex Elderb454e362013-04-19 15:34:50 -05002369 */
2370 if (!img_request_write_test(img_request) ||
2371 !img_request_layered_test(img_request) ||
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002372 rbd_dev->parent_overlap <= obj_request->img_offset ||
Alex Elder3d7efd12013-04-19 15:34:50 -05002373 ((known = obj_request_known_test(obj_request)) &&
2374 obj_request_exists_test(obj_request))) {
Alex Elderb454e362013-04-19 15:34:50 -05002375
2376 struct rbd_device *rbd_dev;
2377 struct ceph_osd_client *osdc;
2378
2379 rbd_dev = obj_request->img_request->rbd_dev;
2380 osdc = &rbd_dev->rbd_client->client->osdc;
2381
2382 return rbd_obj_request_submit(osdc, obj_request);
2383 }
2384
2385 /*
Alex Elder3d7efd12013-04-19 15:34:50 -05002386 * It's a layered write. The target object might exist but
2387 * we may not know that yet. If we know it doesn't exist,
2388 * start by reading the data for the full target object from
2389 * the parent so we can use it for a copyup to the target.
Alex Elderb454e362013-04-19 15:34:50 -05002390 */
Alex Elder3d7efd12013-04-19 15:34:50 -05002391 if (known)
2392 return rbd_img_obj_parent_read_full(obj_request);
2393
2394 /* We don't know whether the target exists. Go find out. */
Alex Elderb454e362013-04-19 15:34:50 -05002395
2396 return rbd_img_obj_exists_submit(obj_request);
2397}
2398
Alex Elderbf0d5f502012-11-22 00:00:08 -06002399static int rbd_img_request_submit(struct rbd_img_request *img_request)
2400{
Alex Elderbf0d5f502012-11-22 00:00:08 -06002401 struct rbd_obj_request *obj_request;
Alex Elder46faeed2013-04-10 17:47:46 -05002402 struct rbd_obj_request *next_obj_request;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002403
Alex Elder37206ee2013-02-20 17:32:08 -06002404 dout("%s: img %p\n", __func__, img_request);
Alex Elder46faeed2013-04-10 17:47:46 -05002405 for_each_obj_request_safe(img_request, obj_request, next_obj_request) {
Alex Elderbf0d5f502012-11-22 00:00:08 -06002406 int ret;
2407
Alex Elderb454e362013-04-19 15:34:50 -05002408 ret = rbd_img_obj_request_submit(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002409 if (ret)
2410 return ret;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002411 }
2412
2413 return 0;
2414}
2415
Alex Elder8b3e1a52013-01-24 16:13:36 -06002416static void rbd_img_parent_read_callback(struct rbd_img_request *img_request)
2417{
2418 struct rbd_obj_request *obj_request;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002419 struct rbd_device *rbd_dev;
2420 u64 obj_end;
Alex Elder8b3e1a52013-01-24 16:13:36 -06002421
2422 rbd_assert(img_request_child_test(img_request));
2423
2424 obj_request = img_request->obj_request;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002425 rbd_assert(obj_request);
2426 rbd_assert(obj_request->img_request);
Alex Elder8b3e1a52013-01-24 16:13:36 -06002427
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002428 obj_request->result = img_request->result;
2429 if (obj_request->result)
2430 goto out;
2431
2432 /*
2433 * We need to zero anything beyond the parent overlap
2434 * boundary. Since rbd_img_obj_request_read_callback()
2435 * will zero anything beyond the end of a short read, an
2436 * easy way to do this is to pretend the data from the
2437 * parent came up short--ending at the overlap boundary.
2438 */
2439 rbd_assert(obj_request->img_offset < U64_MAX - obj_request->length);
2440 obj_end = obj_request->img_offset + obj_request->length;
2441 rbd_dev = obj_request->img_request->rbd_dev;
2442 if (obj_end > rbd_dev->parent_overlap) {
2443 u64 xferred = 0;
2444
2445 if (obj_request->img_offset < rbd_dev->parent_overlap)
2446 xferred = rbd_dev->parent_overlap -
2447 obj_request->img_offset;
2448
2449 obj_request->xferred = min(img_request->xferred, xferred);
2450 } else {
2451 obj_request->xferred = img_request->xferred;
2452 }
2453out:
Alex Elder8b3e1a52013-01-24 16:13:36 -06002454 rbd_img_obj_request_read_callback(obj_request);
2455 rbd_obj_request_complete(obj_request);
2456}
2457
2458static void rbd_img_parent_read(struct rbd_obj_request *obj_request)
2459{
2460 struct rbd_device *rbd_dev;
2461 struct rbd_img_request *img_request;
2462 int result;
2463
2464 rbd_assert(obj_request_img_data_test(obj_request));
2465 rbd_assert(obj_request->img_request != NULL);
2466 rbd_assert(obj_request->result == (s32) -ENOENT);
2467 rbd_assert(obj_request->type == OBJ_REQUEST_BIO);
2468
2469 rbd_dev = obj_request->img_request->rbd_dev;
2470 rbd_assert(rbd_dev->parent != NULL);
2471 /* rbd_read_finish(obj_request, obj_request->length); */
2472 img_request = rbd_img_request_create(rbd_dev->parent,
2473 obj_request->img_offset,
2474 obj_request->length,
2475 false, true);
2476 result = -ENOMEM;
2477 if (!img_request)
2478 goto out_err;
2479
2480 rbd_obj_request_get(obj_request);
2481 img_request->obj_request = obj_request;
2482
Alex Elderf1a47392013-04-19 15:34:50 -05002483 result = rbd_img_request_fill(img_request, OBJ_REQUEST_BIO,
2484 obj_request->bio_list);
Alex Elder8b3e1a52013-01-24 16:13:36 -06002485 if (result)
2486 goto out_err;
2487
2488 img_request->callback = rbd_img_parent_read_callback;
2489 result = rbd_img_request_submit(img_request);
2490 if (result)
2491 goto out_err;
2492
2493 return;
2494out_err:
2495 if (img_request)
2496 rbd_img_request_put(img_request);
2497 obj_request->result = result;
2498 obj_request->xferred = 0;
2499 obj_request_done_set(obj_request);
2500}
2501
Alex Eldercf81b602013-01-17 12:18:46 -06002502static int rbd_obj_notify_ack(struct rbd_device *rbd_dev,
Alex Elderb8d70032012-11-30 17:53:04 -06002503 u64 ver, u64 notify_id)
2504{
2505 struct rbd_obj_request *obj_request;
Alex Elder21692382013-04-05 01:27:12 -05002506 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elderb8d70032012-11-30 17:53:04 -06002507 int ret;
2508
2509 obj_request = rbd_obj_request_create(rbd_dev->header_name, 0, 0,
2510 OBJ_REQUEST_NODATA);
2511 if (!obj_request)
2512 return -ENOMEM;
2513
2514 ret = -ENOMEM;
Alex Elder430c28c2013-04-03 21:32:51 -05002515 obj_request->osd_req = rbd_osd_req_create(rbd_dev, false, obj_request);
Alex Elderb8d70032012-11-30 17:53:04 -06002516 if (!obj_request->osd_req)
2517 goto out;
Alex Elder21692382013-04-05 01:27:12 -05002518 obj_request->callback = rbd_obj_request_put;
Alex Elderb8d70032012-11-30 17:53:04 -06002519
Alex Elderc99d2d42013-04-05 01:27:11 -05002520 osd_req_op_watch_init(obj_request->osd_req, 0, CEPH_OSD_OP_NOTIFY_ACK,
2521 notify_id, ver, 0);
Alex Elder9d4df012013-04-19 15:34:50 -05002522 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05002523
Alex Elderb8d70032012-11-30 17:53:04 -06002524 ret = rbd_obj_request_submit(osdc, obj_request);
Alex Elderb8d70032012-11-30 17:53:04 -06002525out:
Alex Eldercf81b602013-01-17 12:18:46 -06002526 if (ret)
2527 rbd_obj_request_put(obj_request);
Alex Elderb8d70032012-11-30 17:53:04 -06002528
2529 return ret;
2530}
2531
2532static void rbd_watch_cb(u64 ver, u64 notify_id, u8 opcode, void *data)
2533{
2534 struct rbd_device *rbd_dev = (struct rbd_device *)data;
2535 u64 hver;
Alex Elderb8d70032012-11-30 17:53:04 -06002536
2537 if (!rbd_dev)
2538 return;
2539
Alex Elder37206ee2013-02-20 17:32:08 -06002540 dout("%s: \"%s\" notify_id %llu opcode %u\n", __func__,
Alex Elderb8d70032012-11-30 17:53:04 -06002541 rbd_dev->header_name, (unsigned long long) notify_id,
2542 (unsigned int) opcode);
Alex Elder522a0cc2013-04-25 15:09:41 -05002543 (void)rbd_dev_refresh(rbd_dev, &hver);
Alex Elderb8d70032012-11-30 17:53:04 -06002544
Alex Eldercf81b602013-01-17 12:18:46 -06002545 rbd_obj_notify_ack(rbd_dev, hver, notify_id);
Alex Elderb8d70032012-11-30 17:53:04 -06002546}
2547
Alex Elder9969ebc2013-01-18 12:31:10 -06002548/*
2549 * Request sync osd watch/unwatch. The value of "start" determines
2550 * whether a watch request is being initiated or torn down.
2551 */
2552static int rbd_dev_header_watch_sync(struct rbd_device *rbd_dev, int start)
2553{
2554 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
2555 struct rbd_obj_request *obj_request;
Alex Elder9969ebc2013-01-18 12:31:10 -06002556 int ret;
2557
2558 rbd_assert(start ^ !!rbd_dev->watch_event);
2559 rbd_assert(start ^ !!rbd_dev->watch_request);
2560
2561 if (start) {
Alex Elder3c663bb2013-02-15 11:42:30 -06002562 ret = ceph_osdc_create_event(osdc, rbd_watch_cb, rbd_dev,
Alex Elder9969ebc2013-01-18 12:31:10 -06002563 &rbd_dev->watch_event);
2564 if (ret < 0)
2565 return ret;
Alex Elder8eb87562013-01-25 17:08:55 -06002566 rbd_assert(rbd_dev->watch_event != NULL);
Alex Elder9969ebc2013-01-18 12:31:10 -06002567 }
2568
2569 ret = -ENOMEM;
2570 obj_request = rbd_obj_request_create(rbd_dev->header_name, 0, 0,
2571 OBJ_REQUEST_NODATA);
2572 if (!obj_request)
2573 goto out_cancel;
2574
Alex Elder430c28c2013-04-03 21:32:51 -05002575 obj_request->osd_req = rbd_osd_req_create(rbd_dev, true, obj_request);
2576 if (!obj_request->osd_req)
2577 goto out_cancel;
2578
Alex Elder8eb87562013-01-25 17:08:55 -06002579 if (start)
Alex Elder975241a2013-01-25 17:08:55 -06002580 ceph_osdc_set_request_linger(osdc, obj_request->osd_req);
Alex Elder8eb87562013-01-25 17:08:55 -06002581 else
Alex Elder6977c3f2013-01-25 17:08:55 -06002582 ceph_osdc_unregister_linger_request(osdc,
Alex Elder975241a2013-01-25 17:08:55 -06002583 rbd_dev->watch_request->osd_req);
Alex Elder21692382013-04-05 01:27:12 -05002584
2585 osd_req_op_watch_init(obj_request->osd_req, 0, CEPH_OSD_OP_WATCH,
2586 rbd_dev->watch_event->cookie,
2587 rbd_dev->header.obj_version, start);
Alex Elder9d4df012013-04-19 15:34:50 -05002588 rbd_osd_req_format_write(obj_request);
Alex Elder21692382013-04-05 01:27:12 -05002589
Alex Elder9969ebc2013-01-18 12:31:10 -06002590 ret = rbd_obj_request_submit(osdc, obj_request);
2591 if (ret)
2592 goto out_cancel;
2593 ret = rbd_obj_request_wait(obj_request);
2594 if (ret)
2595 goto out_cancel;
Alex Elder9969ebc2013-01-18 12:31:10 -06002596 ret = obj_request->result;
2597 if (ret)
2598 goto out_cancel;
2599
Alex Elder8eb87562013-01-25 17:08:55 -06002600 /*
2601 * A watch request is set to linger, so the underlying osd
2602 * request won't go away until we unregister it. We retain
2603 * a pointer to the object request during that time (in
2604 * rbd_dev->watch_request), so we'll keep a reference to
2605 * it. We'll drop that reference (below) after we've
2606 * unregistered it.
2607 */
2608 if (start) {
2609 rbd_dev->watch_request = obj_request;
2610
2611 return 0;
2612 }
2613
2614 /* We have successfully torn down the watch request */
2615
2616 rbd_obj_request_put(rbd_dev->watch_request);
2617 rbd_dev->watch_request = NULL;
Alex Elder9969ebc2013-01-18 12:31:10 -06002618out_cancel:
2619 /* Cancel the event if we're tearing down, or on error */
2620 ceph_osdc_cancel_event(rbd_dev->watch_event);
2621 rbd_dev->watch_event = NULL;
Alex Elder9969ebc2013-01-18 12:31:10 -06002622 if (obj_request)
2623 rbd_obj_request_put(obj_request);
2624
2625 return ret;
2626}
2627
Alex Elder36be9a72013-01-19 00:30:28 -06002628/*
Alex Elderf40eb342013-04-25 15:09:42 -05002629 * Synchronous osd object method call. Returns the number of bytes
2630 * returned in the outbound buffer, or a negative error code.
Alex Elder36be9a72013-01-19 00:30:28 -06002631 */
2632static int rbd_obj_method_sync(struct rbd_device *rbd_dev,
2633 const char *object_name,
2634 const char *class_name,
2635 const char *method_name,
Alex Elder41579762013-04-21 12:14:45 -05002636 const void *outbound,
Alex Elder36be9a72013-01-19 00:30:28 -06002637 size_t outbound_size,
Alex Elder41579762013-04-21 12:14:45 -05002638 void *inbound,
Alex Elder36be9a72013-01-19 00:30:28 -06002639 size_t inbound_size,
2640 u64 *version)
2641{
Alex Elder21692382013-04-05 01:27:12 -05002642 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elder36be9a72013-01-19 00:30:28 -06002643 struct rbd_obj_request *obj_request;
Alex Elder36be9a72013-01-19 00:30:28 -06002644 struct page **pages;
2645 u32 page_count;
2646 int ret;
2647
2648 /*
Alex Elder6010a452013-04-05 01:27:11 -05002649 * Method calls are ultimately read operations. The result
2650 * should placed into the inbound buffer provided. They
2651 * also supply outbound data--parameters for the object
2652 * method. Currently if this is present it will be a
2653 * snapshot id.
Alex Elder36be9a72013-01-19 00:30:28 -06002654 */
Alex Elder57385b52013-04-21 12:14:45 -05002655 page_count = (u32)calc_pages_for(0, inbound_size);
Alex Elder36be9a72013-01-19 00:30:28 -06002656 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
2657 if (IS_ERR(pages))
2658 return PTR_ERR(pages);
2659
2660 ret = -ENOMEM;
Alex Elder6010a452013-04-05 01:27:11 -05002661 obj_request = rbd_obj_request_create(object_name, 0, inbound_size,
Alex Elder36be9a72013-01-19 00:30:28 -06002662 OBJ_REQUEST_PAGES);
2663 if (!obj_request)
2664 goto out;
2665
2666 obj_request->pages = pages;
2667 obj_request->page_count = page_count;
2668
Alex Elder430c28c2013-04-03 21:32:51 -05002669 obj_request->osd_req = rbd_osd_req_create(rbd_dev, false, obj_request);
Alex Elder36be9a72013-01-19 00:30:28 -06002670 if (!obj_request->osd_req)
2671 goto out;
2672
Alex Elderc99d2d42013-04-05 01:27:11 -05002673 osd_req_op_cls_init(obj_request->osd_req, 0, CEPH_OSD_OP_CALL,
Alex Elder04017e22013-04-05 14:46:02 -05002674 class_name, method_name);
2675 if (outbound_size) {
2676 struct ceph_pagelist *pagelist;
2677
2678 pagelist = kmalloc(sizeof (*pagelist), GFP_NOFS);
2679 if (!pagelist)
2680 goto out;
2681
2682 ceph_pagelist_init(pagelist);
2683 ceph_pagelist_append(pagelist, outbound, outbound_size);
2684 osd_req_op_cls_request_data_pagelist(obj_request->osd_req, 0,
2685 pagelist);
2686 }
Alex Eldera4ce40a2013-04-05 01:27:12 -05002687 osd_req_op_cls_response_data_pages(obj_request->osd_req, 0,
2688 obj_request->pages, inbound_size,
Alex Elder44cd1882013-04-05 01:27:12 -05002689 0, false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05002690 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05002691
Alex Elder36be9a72013-01-19 00:30:28 -06002692 ret = rbd_obj_request_submit(osdc, obj_request);
2693 if (ret)
2694 goto out;
2695 ret = rbd_obj_request_wait(obj_request);
2696 if (ret)
2697 goto out;
2698
2699 ret = obj_request->result;
2700 if (ret < 0)
2701 goto out;
Alex Elder57385b52013-04-21 12:14:45 -05002702
2703 rbd_assert(obj_request->xferred < (u64)INT_MAX);
2704 ret = (int)obj_request->xferred;
Alex Elder903bb322013-02-06 13:11:38 -06002705 ceph_copy_from_page_vector(pages, inbound, 0, obj_request->xferred);
Alex Elder36be9a72013-01-19 00:30:28 -06002706 if (version)
2707 *version = obj_request->version;
2708out:
2709 if (obj_request)
2710 rbd_obj_request_put(obj_request);
2711 else
2712 ceph_release_page_vector(pages, page_count);
2713
2714 return ret;
2715}
2716
Alex Elderbf0d5f502012-11-22 00:00:08 -06002717static void rbd_request_fn(struct request_queue *q)
Alex Eldercc344fa2013-02-19 12:25:56 -06002718 __releases(q->queue_lock) __acquires(q->queue_lock)
Alex Elderbf0d5f502012-11-22 00:00:08 -06002719{
2720 struct rbd_device *rbd_dev = q->queuedata;
2721 bool read_only = rbd_dev->mapping.read_only;
2722 struct request *rq;
2723 int result;
2724
2725 while ((rq = blk_fetch_request(q))) {
2726 bool write_request = rq_data_dir(rq) == WRITE;
2727 struct rbd_img_request *img_request;
2728 u64 offset;
2729 u64 length;
2730
2731 /* Ignore any non-FS requests that filter through. */
2732
2733 if (rq->cmd_type != REQ_TYPE_FS) {
Alex Elder4dda41d2013-02-20 21:59:33 -06002734 dout("%s: non-fs request type %d\n", __func__,
2735 (int) rq->cmd_type);
2736 __blk_end_request_all(rq, 0);
2737 continue;
2738 }
2739
2740 /* Ignore/skip any zero-length requests */
2741
2742 offset = (u64) blk_rq_pos(rq) << SECTOR_SHIFT;
2743 length = (u64) blk_rq_bytes(rq);
2744
2745 if (!length) {
2746 dout("%s: zero-length request\n", __func__);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002747 __blk_end_request_all(rq, 0);
2748 continue;
2749 }
2750
2751 spin_unlock_irq(q->queue_lock);
2752
2753 /* Disallow writes to a read-only device */
2754
2755 if (write_request) {
2756 result = -EROFS;
2757 if (read_only)
2758 goto end_request;
2759 rbd_assert(rbd_dev->spec->snap_id == CEPH_NOSNAP);
2760 }
2761
Alex Elder6d292902013-01-14 12:43:31 -06002762 /*
2763 * Quit early if the mapped snapshot no longer
2764 * exists. It's still possible the snapshot will
2765 * have disappeared by the time our request arrives
2766 * at the osd, but there's no sense in sending it if
2767 * we already know.
2768 */
2769 if (!test_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags)) {
Alex Elderbf0d5f502012-11-22 00:00:08 -06002770 dout("request for non-existent snapshot");
2771 rbd_assert(rbd_dev->spec->snap_id != CEPH_NOSNAP);
2772 result = -ENXIO;
2773 goto end_request;
2774 }
2775
Alex Elderbf0d5f502012-11-22 00:00:08 -06002776 result = -EINVAL;
Alex Elderc0cd10db2013-04-26 09:43:47 -05002777 if (offset && length > U64_MAX - offset + 1) {
2778 rbd_warn(rbd_dev, "bad request range (%llu~%llu)\n",
2779 offset, length);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002780 goto end_request; /* Shouldn't happen */
Alex Elderc0cd10db2013-04-26 09:43:47 -05002781 }
Alex Elderbf0d5f502012-11-22 00:00:08 -06002782
2783 result = -ENOMEM;
2784 img_request = rbd_img_request_create(rbd_dev, offset, length,
Alex Elder9849e982013-01-24 16:13:36 -06002785 write_request, false);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002786 if (!img_request)
2787 goto end_request;
2788
2789 img_request->rq = rq;
2790
Alex Elderf1a47392013-04-19 15:34:50 -05002791 result = rbd_img_request_fill(img_request, OBJ_REQUEST_BIO,
2792 rq->bio);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002793 if (!result)
2794 result = rbd_img_request_submit(img_request);
2795 if (result)
2796 rbd_img_request_put(img_request);
2797end_request:
2798 spin_lock_irq(q->queue_lock);
2799 if (result < 0) {
Alex Elder7da22d22013-01-24 16:13:36 -06002800 rbd_warn(rbd_dev, "%s %llx at %llx result %d\n",
2801 write_request ? "write" : "read",
2802 length, offset, result);
2803
Alex Elderbf0d5f502012-11-22 00:00:08 -06002804 __blk_end_request_all(rq, result);
2805 }
2806 }
2807}
2808
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002809/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002810 * a queue callback. Makes sure that we don't create a bio that spans across
2811 * multiple osd objects. One exception would be with a single page bios,
Alex Elderf7760da2012-10-20 22:17:27 -05002812 * which we handle later at bio_chain_clone_range()
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002813 */
2814static int rbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bmd,
2815 struct bio_vec *bvec)
2816{
2817 struct rbd_device *rbd_dev = q->queuedata;
Alex Eldere5cfeed22012-10-20 22:17:27 -05002818 sector_t sector_offset;
2819 sector_t sectors_per_obj;
2820 sector_t obj_sector_offset;
2821 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002822
Alex Eldere5cfeed22012-10-20 22:17:27 -05002823 /*
2824 * Find how far into its rbd object the partition-relative
2825 * bio start sector is to offset relative to the enclosing
2826 * device.
2827 */
2828 sector_offset = get_start_sect(bmd->bi_bdev) + bmd->bi_sector;
2829 sectors_per_obj = 1 << (rbd_dev->header.obj_order - SECTOR_SHIFT);
2830 obj_sector_offset = sector_offset & (sectors_per_obj - 1);
Alex Elder593a9e72012-02-07 12:03:37 -06002831
Alex Eldere5cfeed22012-10-20 22:17:27 -05002832 /*
2833 * Compute the number of bytes from that offset to the end
2834 * of the object. Account for what's already used by the bio.
2835 */
2836 ret = (int) (sectors_per_obj - obj_sector_offset) << SECTOR_SHIFT;
2837 if (ret > bmd->bi_size)
2838 ret -= bmd->bi_size;
2839 else
2840 ret = 0;
2841
2842 /*
2843 * Don't send back more than was asked for. And if the bio
2844 * was empty, let the whole thing through because: "Note
2845 * that a block device *must* allow a single page to be
2846 * added to an empty bio."
2847 */
2848 rbd_assert(bvec->bv_len <= PAGE_SIZE);
2849 if (ret > (int) bvec->bv_len || !bmd->bi_size)
2850 ret = (int) bvec->bv_len;
2851
2852 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002853}
2854
2855static void rbd_free_disk(struct rbd_device *rbd_dev)
2856{
2857 struct gendisk *disk = rbd_dev->disk;
2858
2859 if (!disk)
2860 return;
2861
Alex Eldera0cab922013-04-25 23:15:08 -05002862 rbd_dev->disk = NULL;
2863 if (disk->flags & GENHD_FL_UP) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002864 del_gendisk(disk);
Alex Eldera0cab922013-04-25 23:15:08 -05002865 if (disk->queue)
2866 blk_cleanup_queue(disk->queue);
2867 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002868 put_disk(disk);
2869}
2870
Alex Elder788e2df2013-01-17 12:25:27 -06002871static int rbd_obj_read_sync(struct rbd_device *rbd_dev,
2872 const char *object_name,
2873 u64 offset, u64 length,
Alex Elder80ef15b2013-04-21 12:14:45 -05002874 void *buf, u64 *version)
Alex Elder788e2df2013-01-17 12:25:27 -06002875
2876{
Alex Elder21692382013-04-05 01:27:12 -05002877 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elder788e2df2013-01-17 12:25:27 -06002878 struct rbd_obj_request *obj_request;
Alex Elder788e2df2013-01-17 12:25:27 -06002879 struct page **pages = NULL;
2880 u32 page_count;
Alex Elder1ceae7e2013-02-06 13:11:38 -06002881 size_t size;
Alex Elder788e2df2013-01-17 12:25:27 -06002882 int ret;
2883
2884 page_count = (u32) calc_pages_for(offset, length);
2885 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
2886 if (IS_ERR(pages))
2887 ret = PTR_ERR(pages);
2888
2889 ret = -ENOMEM;
2890 obj_request = rbd_obj_request_create(object_name, offset, length,
Alex Elder36be9a72013-01-19 00:30:28 -06002891 OBJ_REQUEST_PAGES);
Alex Elder788e2df2013-01-17 12:25:27 -06002892 if (!obj_request)
2893 goto out;
2894
2895 obj_request->pages = pages;
2896 obj_request->page_count = page_count;
2897
Alex Elder430c28c2013-04-03 21:32:51 -05002898 obj_request->osd_req = rbd_osd_req_create(rbd_dev, false, obj_request);
Alex Elder788e2df2013-01-17 12:25:27 -06002899 if (!obj_request->osd_req)
2900 goto out;
2901
Alex Elderc99d2d42013-04-05 01:27:11 -05002902 osd_req_op_extent_init(obj_request->osd_req, 0, CEPH_OSD_OP_READ,
2903 offset, length, 0, 0);
Alex Elder406e2c92013-04-15 14:50:36 -05002904 osd_req_op_extent_osd_data_pages(obj_request->osd_req, 0,
Alex Eldera4ce40a2013-04-05 01:27:12 -05002905 obj_request->pages,
Alex Elder44cd1882013-04-05 01:27:12 -05002906 obj_request->length,
2907 obj_request->offset & ~PAGE_MASK,
2908 false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05002909 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05002910
Alex Elder788e2df2013-01-17 12:25:27 -06002911 ret = rbd_obj_request_submit(osdc, obj_request);
2912 if (ret)
2913 goto out;
2914 ret = rbd_obj_request_wait(obj_request);
2915 if (ret)
2916 goto out;
2917
2918 ret = obj_request->result;
2919 if (ret < 0)
2920 goto out;
Alex Elder1ceae7e2013-02-06 13:11:38 -06002921
2922 rbd_assert(obj_request->xferred <= (u64) SIZE_MAX);
2923 size = (size_t) obj_request->xferred;
Alex Elder903bb322013-02-06 13:11:38 -06002924 ceph_copy_from_page_vector(pages, buf, 0, size);
Alex Elder23ed6e12013-02-06 13:11:38 -06002925 rbd_assert(size <= (size_t) INT_MAX);
2926 ret = (int) size;
Alex Elder788e2df2013-01-17 12:25:27 -06002927 if (version)
2928 *version = obj_request->version;
2929out:
2930 if (obj_request)
2931 rbd_obj_request_put(obj_request);
2932 else
2933 ceph_release_page_vector(pages, page_count);
2934
2935 return ret;
2936}
2937
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002938/*
Alex Elder4156d9982012-08-02 11:29:46 -05002939 * Read the complete header for the given rbd device.
2940 *
2941 * Returns a pointer to a dynamically-allocated buffer containing
2942 * the complete and validated header. Caller can pass the address
2943 * of a variable that will be filled in with the version of the
2944 * header object at the time it was read.
2945 *
2946 * Returns a pointer-coded errno if a failure occurs.
2947 */
2948static struct rbd_image_header_ondisk *
2949rbd_dev_v1_header_read(struct rbd_device *rbd_dev, u64 *version)
2950{
2951 struct rbd_image_header_ondisk *ondisk = NULL;
2952 u32 snap_count = 0;
2953 u64 names_size = 0;
2954 u32 want_count;
2955 int ret;
2956
2957 /*
2958 * The complete header will include an array of its 64-bit
2959 * snapshot ids, followed by the names of those snapshots as
2960 * a contiguous block of NUL-terminated strings. Note that
2961 * the number of snapshots could change by the time we read
2962 * it in, in which case we re-read it.
2963 */
2964 do {
2965 size_t size;
2966
2967 kfree(ondisk);
2968
2969 size = sizeof (*ondisk);
2970 size += snap_count * sizeof (struct rbd_image_snap_ondisk);
2971 size += names_size;
2972 ondisk = kmalloc(size, GFP_KERNEL);
2973 if (!ondisk)
2974 return ERR_PTR(-ENOMEM);
2975
Alex Elder788e2df2013-01-17 12:25:27 -06002976 ret = rbd_obj_read_sync(rbd_dev, rbd_dev->header_name,
Alex Elder80ef15b2013-04-21 12:14:45 -05002977 0, size, ondisk, version);
Alex Elder4156d9982012-08-02 11:29:46 -05002978 if (ret < 0)
2979 goto out_err;
Alex Elderc0cd10db2013-04-26 09:43:47 -05002980 if ((size_t)ret < size) {
Alex Elder4156d9982012-08-02 11:29:46 -05002981 ret = -ENXIO;
Alex Elder06ecc6c2012-11-01 10:17:15 -05002982 rbd_warn(rbd_dev, "short header read (want %zd got %d)",
2983 size, ret);
Alex Elder4156d9982012-08-02 11:29:46 -05002984 goto out_err;
2985 }
2986 if (!rbd_dev_ondisk_valid(ondisk)) {
2987 ret = -ENXIO;
Alex Elder06ecc6c2012-11-01 10:17:15 -05002988 rbd_warn(rbd_dev, "invalid header");
Alex Elder4156d9982012-08-02 11:29:46 -05002989 goto out_err;
2990 }
2991
2992 names_size = le64_to_cpu(ondisk->snap_names_len);
2993 want_count = snap_count;
2994 snap_count = le32_to_cpu(ondisk->snap_count);
2995 } while (snap_count != want_count);
2996
2997 return ondisk;
2998
2999out_err:
3000 kfree(ondisk);
3001
3002 return ERR_PTR(ret);
3003}
3004
3005/*
3006 * reload the ondisk the header
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003007 */
3008static int rbd_read_header(struct rbd_device *rbd_dev,
3009 struct rbd_image_header *header)
3010{
Alex Elder4156d9982012-08-02 11:29:46 -05003011 struct rbd_image_header_ondisk *ondisk;
3012 u64 ver = 0;
3013 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003014
Alex Elder4156d9982012-08-02 11:29:46 -05003015 ondisk = rbd_dev_v1_header_read(rbd_dev, &ver);
3016 if (IS_ERR(ondisk))
3017 return PTR_ERR(ondisk);
3018 ret = rbd_header_from_disk(header, ondisk);
3019 if (ret >= 0)
3020 header->obj_version = ver;
3021 kfree(ondisk);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003022
Alex Elder4156d9982012-08-02 11:29:46 -05003023 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003024}
3025
Alex Elder41f38c22012-10-25 23:34:40 -05003026static void rbd_remove_all_snaps(struct rbd_device *rbd_dev)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003027{
3028 struct rbd_snap *snap;
Alex Eldera0593292012-07-19 09:09:27 -05003029 struct rbd_snap *next;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003030
Alex Elder6087b512013-04-25 15:09:41 -05003031 list_for_each_entry_safe(snap, next, &rbd_dev->snaps, node) {
3032 list_del(&snap->node);
3033 rbd_snap_destroy(snap);
3034 }
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003035}
3036
Alex Elder94785542012-10-09 13:50:17 -07003037static void rbd_update_mapping_size(struct rbd_device *rbd_dev)
3038{
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003039 if (rbd_dev->spec->snap_id != CEPH_NOSNAP)
Alex Elder94785542012-10-09 13:50:17 -07003040 return;
3041
Alex Eldere28626a2013-04-26 15:44:35 -05003042 if (rbd_dev->mapping.size != rbd_dev->header.image_size) {
3043 sector_t size;
3044
3045 rbd_dev->mapping.size = rbd_dev->header.image_size;
3046 size = (sector_t)rbd_dev->mapping.size / SECTOR_SIZE;
3047 dout("setting size to %llu sectors", (unsigned long long)size);
3048 set_capacity(rbd_dev->disk, size);
3049 }
Alex Elder94785542012-10-09 13:50:17 -07003050}
3051
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003052/*
3053 * only read the first part of the ondisk header, without the snaps info
3054 */
Alex Elder117973f2012-08-31 17:29:55 -05003055static int rbd_dev_v1_refresh(struct rbd_device *rbd_dev, u64 *hver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003056{
3057 int ret;
3058 struct rbd_image_header h;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003059
3060 ret = rbd_read_header(rbd_dev, &h);
3061 if (ret < 0)
3062 return ret;
3063
Josh Durgina51aa0c2011-12-05 10:35:04 -08003064 down_write(&rbd_dev->header_rwsem);
3065
Alex Elder94785542012-10-09 13:50:17 -07003066 /* Update image size, and check for resize of mapped image */
3067 rbd_dev->header.image_size = h.image_size;
3068 rbd_update_mapping_size(rbd_dev);
Sage Weil9db4b3e2011-04-19 22:49:06 -07003069
Alex Elder849b4262012-07-09 21:04:24 -05003070 /* rbd_dev->header.object_prefix shouldn't change */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003071 kfree(rbd_dev->header.snap_sizes);
Alex Elder849b4262012-07-09 21:04:24 -05003072 kfree(rbd_dev->header.snap_names);
Josh Durgind1d25642011-12-05 14:03:05 -08003073 /* osd requests may still refer to snapc */
Alex Elder468521c2013-04-26 09:43:47 -05003074 rbd_snap_context_put(rbd_dev->header.snapc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003075
Alex Elderb8136232012-07-25 09:32:41 -05003076 if (hver)
3077 *hver = h.obj_version;
Josh Durgina71b8912011-12-05 18:10:44 -08003078 rbd_dev->header.obj_version = h.obj_version;
Josh Durgin93a24e02011-12-05 10:41:28 -08003079 rbd_dev->header.image_size = h.image_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003080 rbd_dev->header.snapc = h.snapc;
3081 rbd_dev->header.snap_names = h.snap_names;
3082 rbd_dev->header.snap_sizes = h.snap_sizes;
Alex Elder849b4262012-07-09 21:04:24 -05003083 /* Free the extra copy of the object prefix */
Alex Elderc0cd10db2013-04-26 09:43:47 -05003084 if (strcmp(rbd_dev->header.object_prefix, h.object_prefix))
3085 rbd_warn(rbd_dev, "object prefix changed (ignoring)");
Alex Elder849b4262012-07-09 21:04:24 -05003086 kfree(h.object_prefix);
3087
Alex Elder304f6802012-08-31 17:29:52 -05003088 ret = rbd_dev_snaps_update(rbd_dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003089
Josh Durginc6666012011-11-21 17:11:12 -08003090 up_write(&rbd_dev->header_rwsem);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003091
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003092 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003093}
3094
Alex Elder117973f2012-08-31 17:29:55 -05003095static int rbd_dev_refresh(struct rbd_device *rbd_dev, u64 *hver)
Alex Elder1fe5e992012-07-25 09:32:41 -05003096{
3097 int ret;
3098
Alex Elder117973f2012-08-31 17:29:55 -05003099 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
Alex Elder1fe5e992012-07-25 09:32:41 -05003100 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Alex Elder117973f2012-08-31 17:29:55 -05003101 if (rbd_dev->image_format == 1)
3102 ret = rbd_dev_v1_refresh(rbd_dev, hver);
3103 else
3104 ret = rbd_dev_v2_refresh(rbd_dev, hver);
Alex Elder1fe5e992012-07-25 09:32:41 -05003105 mutex_unlock(&ctl_mutex);
Laurent Barbed98df632013-04-10 17:47:46 -05003106 revalidate_disk(rbd_dev->disk);
Alex Elder522a0cc2013-04-25 15:09:41 -05003107 if (ret)
3108 rbd_warn(rbd_dev, "got notification but failed to "
3109 " update snaps: %d\n", ret);
Alex Elder1fe5e992012-07-25 09:32:41 -05003110
3111 return ret;
3112}
3113
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003114static int rbd_init_disk(struct rbd_device *rbd_dev)
3115{
3116 struct gendisk *disk;
3117 struct request_queue *q;
Alex Elder593a9e72012-02-07 12:03:37 -06003118 u64 segment_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003119
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003120 /* create gendisk info */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003121 disk = alloc_disk(RBD_MINORS_PER_MAJOR);
3122 if (!disk)
Alex Elder1fcdb8a2012-08-29 17:11:06 -05003123 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003124
Alex Elderf0f8cef2012-01-29 13:57:44 -06003125 snprintf(disk->disk_name, sizeof(disk->disk_name), RBD_DRV_NAME "%d",
Alex Elderde71a292012-07-03 16:01:19 -05003126 rbd_dev->dev_id);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003127 disk->major = rbd_dev->major;
3128 disk->first_minor = 0;
3129 disk->fops = &rbd_bd_ops;
3130 disk->private_data = rbd_dev;
3131
Alex Elderbf0d5f502012-11-22 00:00:08 -06003132 q = blk_init_queue(rbd_request_fn, &rbd_dev->lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003133 if (!q)
3134 goto out_disk;
Josh Durgin029bcbd2011-07-22 11:35:23 -07003135
Alex Elder593a9e72012-02-07 12:03:37 -06003136 /* We use the default size, but let's be explicit about it. */
3137 blk_queue_physical_block_size(q, SECTOR_SIZE);
3138
Josh Durgin029bcbd2011-07-22 11:35:23 -07003139 /* set io sizes to object size */
Alex Elder593a9e72012-02-07 12:03:37 -06003140 segment_size = rbd_obj_bytes(&rbd_dev->header);
3141 blk_queue_max_hw_sectors(q, segment_size / SECTOR_SIZE);
3142 blk_queue_max_segment_size(q, segment_size);
3143 blk_queue_io_min(q, segment_size);
3144 blk_queue_io_opt(q, segment_size);
Josh Durgin029bcbd2011-07-22 11:35:23 -07003145
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003146 blk_queue_merge_bvec(q, rbd_merge_bvec);
3147 disk->queue = q;
3148
3149 q->queuedata = rbd_dev;
3150
3151 rbd_dev->disk = disk;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003152
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003153 return 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003154out_disk:
3155 put_disk(disk);
Alex Elder1fcdb8a2012-08-29 17:11:06 -05003156
3157 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003158}
3159
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003160/*
3161 sysfs
3162*/
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003163
Alex Elder593a9e72012-02-07 12:03:37 -06003164static struct rbd_device *dev_to_rbd_dev(struct device *dev)
3165{
3166 return container_of(dev, struct rbd_device, dev);
3167}
3168
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003169static ssize_t rbd_size_show(struct device *dev,
3170 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003171{
Alex Elder593a9e72012-02-07 12:03:37 -06003172 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003173
Alex Elderfc71d832013-04-26 15:44:36 -05003174 return sprintf(buf, "%llu\n",
3175 (unsigned long long)rbd_dev->mapping.size);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003176}
3177
Alex Elder34b13182012-07-13 20:35:12 -05003178/*
3179 * Note this shows the features for whatever's mapped, which is not
3180 * necessarily the base image.
3181 */
3182static ssize_t rbd_features_show(struct device *dev,
3183 struct device_attribute *attr, char *buf)
3184{
3185 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3186
3187 return sprintf(buf, "0x%016llx\n",
Alex Elderfc71d832013-04-26 15:44:36 -05003188 (unsigned long long)rbd_dev->mapping.features);
Alex Elder34b13182012-07-13 20:35:12 -05003189}
3190
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003191static ssize_t rbd_major_show(struct device *dev,
3192 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003193{
Alex Elder593a9e72012-02-07 12:03:37 -06003194 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003195
Alex Elderfc71d832013-04-26 15:44:36 -05003196 if (rbd_dev->major)
3197 return sprintf(buf, "%d\n", rbd_dev->major);
3198
3199 return sprintf(buf, "(none)\n");
3200
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003201}
3202
3203static ssize_t rbd_client_id_show(struct device *dev,
3204 struct device_attribute *attr, char *buf)
3205{
Alex Elder593a9e72012-02-07 12:03:37 -06003206 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003207
Alex Elder1dbb4392012-01-24 10:08:37 -06003208 return sprintf(buf, "client%lld\n",
3209 ceph_client_id(rbd_dev->rbd_client->client));
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003210}
3211
3212static ssize_t rbd_pool_show(struct device *dev,
3213 struct device_attribute *attr, char *buf)
3214{
Alex Elder593a9e72012-02-07 12:03:37 -06003215 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003216
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003217 return sprintf(buf, "%s\n", rbd_dev->spec->pool_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003218}
3219
Alex Elder9bb2f332012-07-12 10:46:35 -05003220static ssize_t rbd_pool_id_show(struct device *dev,
3221 struct device_attribute *attr, char *buf)
3222{
3223 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3224
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003225 return sprintf(buf, "%llu\n",
Alex Elderfc71d832013-04-26 15:44:36 -05003226 (unsigned long long) rbd_dev->spec->pool_id);
Alex Elder9bb2f332012-07-12 10:46:35 -05003227}
3228
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003229static ssize_t rbd_name_show(struct device *dev,
3230 struct device_attribute *attr, char *buf)
3231{
Alex Elder593a9e72012-02-07 12:03:37 -06003232 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003233
Alex Eldera92ffdf2012-10-30 19:40:33 -05003234 if (rbd_dev->spec->image_name)
3235 return sprintf(buf, "%s\n", rbd_dev->spec->image_name);
3236
3237 return sprintf(buf, "(unknown)\n");
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003238}
3239
Alex Elder589d30e2012-07-10 20:30:11 -05003240static ssize_t rbd_image_id_show(struct device *dev,
3241 struct device_attribute *attr, char *buf)
3242{
3243 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3244
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003245 return sprintf(buf, "%s\n", rbd_dev->spec->image_id);
Alex Elder589d30e2012-07-10 20:30:11 -05003246}
3247
Alex Elder34b13182012-07-13 20:35:12 -05003248/*
3249 * Shows the name of the currently-mapped snapshot (or
3250 * RBD_SNAP_HEAD_NAME for the base image).
3251 */
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003252static ssize_t rbd_snap_show(struct device *dev,
3253 struct device_attribute *attr,
3254 char *buf)
3255{
Alex Elder593a9e72012-02-07 12:03:37 -06003256 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003257
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003258 return sprintf(buf, "%s\n", rbd_dev->spec->snap_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003259}
3260
Alex Elder86b00e02012-10-25 23:34:42 -05003261/*
3262 * For an rbd v2 image, shows the pool id, image id, and snapshot id
3263 * for the parent image. If there is no parent, simply shows
3264 * "(no parent image)".
3265 */
3266static ssize_t rbd_parent_show(struct device *dev,
3267 struct device_attribute *attr,
3268 char *buf)
3269{
3270 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3271 struct rbd_spec *spec = rbd_dev->parent_spec;
3272 int count;
3273 char *bufp = buf;
3274
3275 if (!spec)
3276 return sprintf(buf, "(no parent image)\n");
3277
3278 count = sprintf(bufp, "pool_id %llu\npool_name %s\n",
3279 (unsigned long long) spec->pool_id, spec->pool_name);
3280 if (count < 0)
3281 return count;
3282 bufp += count;
3283
3284 count = sprintf(bufp, "image_id %s\nimage_name %s\n", spec->image_id,
3285 spec->image_name ? spec->image_name : "(unknown)");
3286 if (count < 0)
3287 return count;
3288 bufp += count;
3289
3290 count = sprintf(bufp, "snap_id %llu\nsnap_name %s\n",
3291 (unsigned long long) spec->snap_id, spec->snap_name);
3292 if (count < 0)
3293 return count;
3294 bufp += count;
3295
3296 count = sprintf(bufp, "overlap %llu\n", rbd_dev->parent_overlap);
3297 if (count < 0)
3298 return count;
3299 bufp += count;
3300
3301 return (ssize_t) (bufp - buf);
3302}
3303
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003304static ssize_t rbd_image_refresh(struct device *dev,
3305 struct device_attribute *attr,
3306 const char *buf,
3307 size_t size)
3308{
Alex Elder593a9e72012-02-07 12:03:37 -06003309 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Alex Elderb8136232012-07-25 09:32:41 -05003310 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003311
Alex Elder117973f2012-08-31 17:29:55 -05003312 ret = rbd_dev_refresh(rbd_dev, NULL);
Alex Elderb8136232012-07-25 09:32:41 -05003313
3314 return ret < 0 ? ret : size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003315}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003316
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003317static DEVICE_ATTR(size, S_IRUGO, rbd_size_show, NULL);
Alex Elder34b13182012-07-13 20:35:12 -05003318static DEVICE_ATTR(features, S_IRUGO, rbd_features_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003319static DEVICE_ATTR(major, S_IRUGO, rbd_major_show, NULL);
3320static DEVICE_ATTR(client_id, S_IRUGO, rbd_client_id_show, NULL);
3321static DEVICE_ATTR(pool, S_IRUGO, rbd_pool_show, NULL);
Alex Elder9bb2f332012-07-12 10:46:35 -05003322static DEVICE_ATTR(pool_id, S_IRUGO, rbd_pool_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003323static DEVICE_ATTR(name, S_IRUGO, rbd_name_show, NULL);
Alex Elder589d30e2012-07-10 20:30:11 -05003324static DEVICE_ATTR(image_id, S_IRUGO, rbd_image_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003325static DEVICE_ATTR(refresh, S_IWUSR, NULL, rbd_image_refresh);
3326static DEVICE_ATTR(current_snap, S_IRUGO, rbd_snap_show, NULL);
Alex Elder86b00e02012-10-25 23:34:42 -05003327static DEVICE_ATTR(parent, S_IRUGO, rbd_parent_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003328
3329static struct attribute *rbd_attrs[] = {
3330 &dev_attr_size.attr,
Alex Elder34b13182012-07-13 20:35:12 -05003331 &dev_attr_features.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003332 &dev_attr_major.attr,
3333 &dev_attr_client_id.attr,
3334 &dev_attr_pool.attr,
Alex Elder9bb2f332012-07-12 10:46:35 -05003335 &dev_attr_pool_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003336 &dev_attr_name.attr,
Alex Elder589d30e2012-07-10 20:30:11 -05003337 &dev_attr_image_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003338 &dev_attr_current_snap.attr,
Alex Elder86b00e02012-10-25 23:34:42 -05003339 &dev_attr_parent.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003340 &dev_attr_refresh.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003341 NULL
3342};
3343
3344static struct attribute_group rbd_attr_group = {
3345 .attrs = rbd_attrs,
3346};
3347
3348static const struct attribute_group *rbd_attr_groups[] = {
3349 &rbd_attr_group,
3350 NULL
3351};
3352
3353static void rbd_sysfs_dev_release(struct device *dev)
3354{
3355}
3356
3357static struct device_type rbd_device_type = {
3358 .name = "rbd",
3359 .groups = rbd_attr_groups,
3360 .release = rbd_sysfs_dev_release,
3361};
3362
Alex Elder8b8fb992012-10-26 17:25:24 -05003363static struct rbd_spec *rbd_spec_get(struct rbd_spec *spec)
3364{
3365 kref_get(&spec->kref);
3366
3367 return spec;
3368}
3369
3370static void rbd_spec_free(struct kref *kref);
3371static void rbd_spec_put(struct rbd_spec *spec)
3372{
3373 if (spec)
3374 kref_put(&spec->kref, rbd_spec_free);
3375}
3376
3377static struct rbd_spec *rbd_spec_alloc(void)
3378{
3379 struct rbd_spec *spec;
3380
3381 spec = kzalloc(sizeof (*spec), GFP_KERNEL);
3382 if (!spec)
3383 return NULL;
3384 kref_init(&spec->kref);
3385
Alex Elder8b8fb992012-10-26 17:25:24 -05003386 return spec;
3387}
3388
3389static void rbd_spec_free(struct kref *kref)
3390{
3391 struct rbd_spec *spec = container_of(kref, struct rbd_spec, kref);
3392
3393 kfree(spec->pool_name);
3394 kfree(spec->image_id);
3395 kfree(spec->image_name);
3396 kfree(spec->snap_name);
3397 kfree(spec);
3398}
3399
Alex Eldercc344fa2013-02-19 12:25:56 -06003400static struct rbd_device *rbd_dev_create(struct rbd_client *rbdc,
Alex Elderc53d5892012-10-25 23:34:42 -05003401 struct rbd_spec *spec)
3402{
3403 struct rbd_device *rbd_dev;
3404
3405 rbd_dev = kzalloc(sizeof (*rbd_dev), GFP_KERNEL);
3406 if (!rbd_dev)
3407 return NULL;
3408
3409 spin_lock_init(&rbd_dev->lock);
Alex Elder6d292902013-01-14 12:43:31 -06003410 rbd_dev->flags = 0;
Alex Elderc53d5892012-10-25 23:34:42 -05003411 INIT_LIST_HEAD(&rbd_dev->node);
3412 INIT_LIST_HEAD(&rbd_dev->snaps);
3413 init_rwsem(&rbd_dev->header_rwsem);
3414
3415 rbd_dev->spec = spec;
3416 rbd_dev->rbd_client = rbdc;
3417
Alex Elder0903e872012-11-14 12:25:19 -06003418 /* Initialize the layout used for all rbd requests */
3419
3420 rbd_dev->layout.fl_stripe_unit = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
3421 rbd_dev->layout.fl_stripe_count = cpu_to_le32(1);
3422 rbd_dev->layout.fl_object_size = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
3423 rbd_dev->layout.fl_pg_pool = cpu_to_le32((u32) spec->pool_id);
3424
Alex Elderc53d5892012-10-25 23:34:42 -05003425 return rbd_dev;
3426}
3427
3428static void rbd_dev_destroy(struct rbd_device *rbd_dev)
3429{
Alex Elderc53d5892012-10-25 23:34:42 -05003430 rbd_put_client(rbd_dev->rbd_client);
3431 rbd_spec_put(rbd_dev->spec);
3432 kfree(rbd_dev);
3433}
3434
Alex Elder6087b512013-04-25 15:09:41 -05003435static void rbd_snap_destroy(struct rbd_snap *snap)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003436{
Alex Elder3e83b652013-04-23 13:52:53 -05003437 kfree(snap->name);
3438 kfree(snap);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003439}
3440
Alex Elder6087b512013-04-25 15:09:41 -05003441static struct rbd_snap *rbd_snap_create(struct rbd_device *rbd_dev,
Alex Elderc8d18422012-07-10 20:30:11 -05003442 const char *snap_name,
Alex Elder34b13182012-07-13 20:35:12 -05003443 u64 snap_id, u64 snap_size,
3444 u64 snap_features)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003445{
Alex Elder4e891e02012-07-10 20:30:10 -05003446 struct rbd_snap *snap;
Alex Elder4e891e02012-07-10 20:30:10 -05003447
3448 snap = kzalloc(sizeof (*snap), GFP_KERNEL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003449 if (!snap)
Alex Elder4e891e02012-07-10 20:30:10 -05003450 return ERR_PTR(-ENOMEM);
3451
Alex Elder6e584f52013-04-25 15:09:42 -05003452 snap->name = snap_name;
Alex Elderc8d18422012-07-10 20:30:11 -05003453 snap->id = snap_id;
3454 snap->size = snap_size;
Alex Elder34b13182012-07-13 20:35:12 -05003455 snap->features = snap_features;
Alex Elder4e891e02012-07-10 20:30:10 -05003456
3457 return snap;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003458}
3459
Alex Elder6e584f52013-04-25 15:09:42 -05003460/*
3461 * Returns a dynamically-allocated snapshot name if successful, or a
3462 * pointer-coded error otherwise.
3463 */
Alex Eldercd892122012-07-03 16:01:19 -05003464static char *rbd_dev_v1_snap_info(struct rbd_device *rbd_dev, u32 which,
3465 u64 *snap_size, u64 *snap_features)
3466{
3467 char *snap_name;
Alex Elder6e584f52013-04-25 15:09:42 -05003468 int i;
Alex Eldercd892122012-07-03 16:01:19 -05003469
3470 rbd_assert(which < rbd_dev->header.snapc->num_snaps);
3471
Alex Eldercd892122012-07-03 16:01:19 -05003472 /* Skip over names until we find the one we are looking for */
3473
3474 snap_name = rbd_dev->header.snap_names;
Alex Elder6e584f52013-04-25 15:09:42 -05003475 for (i = 0; i < which; i++)
Alex Eldercd892122012-07-03 16:01:19 -05003476 snap_name += strlen(snap_name) + 1;
3477
Alex Elder6e584f52013-04-25 15:09:42 -05003478 snap_name = kstrdup(snap_name, GFP_KERNEL);
3479 if (!snap_name)
3480 return ERR_PTR(-ENOMEM);
3481
3482 *snap_size = rbd_dev->header.snap_sizes[which];
3483 *snap_features = 0; /* No features for v1 */
3484
Alex Eldercd892122012-07-03 16:01:19 -05003485 return snap_name;
3486}
3487
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003488/*
Alex Elder9d475de52012-07-03 16:01:19 -05003489 * Get the size and object order for an image snapshot, or if
3490 * snap_id is CEPH_NOSNAP, gets this information for the base
3491 * image.
3492 */
3493static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
3494 u8 *order, u64 *snap_size)
3495{
3496 __le64 snapid = cpu_to_le64(snap_id);
3497 int ret;
3498 struct {
3499 u8 order;
3500 __le64 size;
3501 } __attribute__ ((packed)) size_buf = { 0 };
3502
Alex Elder36be9a72013-01-19 00:30:28 -06003503 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder9d475de52012-07-03 16:01:19 -05003504 "rbd", "get_size",
Alex Elder41579762013-04-21 12:14:45 -05003505 &snapid, sizeof (snapid),
3506 &size_buf, sizeof (size_buf), NULL);
Alex Elder36be9a72013-01-19 00:30:28 -06003507 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder9d475de52012-07-03 16:01:19 -05003508 if (ret < 0)
3509 return ret;
Alex Elder57385b52013-04-21 12:14:45 -05003510 if (ret < sizeof (size_buf))
3511 return -ERANGE;
Alex Elder9d475de52012-07-03 16:01:19 -05003512
Alex Elderc86f86e2013-04-25 15:09:41 -05003513 if (order)
3514 *order = size_buf.order;
Alex Elder9d475de52012-07-03 16:01:19 -05003515 *snap_size = le64_to_cpu(size_buf.size);
3516
3517 dout(" snap_id 0x%016llx order = %u, snap_size = %llu\n",
Alex Elder57385b52013-04-21 12:14:45 -05003518 (unsigned long long)snap_id, (unsigned int)*order,
3519 (unsigned long long)*snap_size);
Alex Elder9d475de52012-07-03 16:01:19 -05003520
3521 return 0;
3522}
3523
3524static int rbd_dev_v2_image_size(struct rbd_device *rbd_dev)
3525{
3526 return _rbd_dev_v2_snap_size(rbd_dev, CEPH_NOSNAP,
3527 &rbd_dev->header.obj_order,
3528 &rbd_dev->header.image_size);
3529}
3530
Alex Elder1e130192012-07-03 16:01:19 -05003531static int rbd_dev_v2_object_prefix(struct rbd_device *rbd_dev)
3532{
3533 void *reply_buf;
3534 int ret;
3535 void *p;
3536
3537 reply_buf = kzalloc(RBD_OBJ_PREFIX_LEN_MAX, GFP_KERNEL);
3538 if (!reply_buf)
3539 return -ENOMEM;
3540
Alex Elder36be9a72013-01-19 00:30:28 -06003541 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder41579762013-04-21 12:14:45 -05003542 "rbd", "get_object_prefix", NULL, 0,
Alex Elder07b23912012-11-09 08:43:16 -06003543 reply_buf, RBD_OBJ_PREFIX_LEN_MAX, NULL);
Alex Elder36be9a72013-01-19 00:30:28 -06003544 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder1e130192012-07-03 16:01:19 -05003545 if (ret < 0)
3546 goto out;
3547
3548 p = reply_buf;
3549 rbd_dev->header.object_prefix = ceph_extract_encoded_string(&p,
Alex Elder57385b52013-04-21 12:14:45 -05003550 p + ret, NULL, GFP_NOIO);
3551 ret = 0;
Alex Elder1e130192012-07-03 16:01:19 -05003552
3553 if (IS_ERR(rbd_dev->header.object_prefix)) {
3554 ret = PTR_ERR(rbd_dev->header.object_prefix);
3555 rbd_dev->header.object_prefix = NULL;
3556 } else {
3557 dout(" object_prefix = %s\n", rbd_dev->header.object_prefix);
3558 }
Alex Elder1e130192012-07-03 16:01:19 -05003559out:
3560 kfree(reply_buf);
3561
3562 return ret;
3563}
3564
Alex Elderb1b54022012-07-03 16:01:19 -05003565static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
3566 u64 *snap_features)
3567{
3568 __le64 snapid = cpu_to_le64(snap_id);
3569 struct {
3570 __le64 features;
3571 __le64 incompat;
Alex Elder41579762013-04-21 12:14:45 -05003572 } __attribute__ ((packed)) features_buf = { 0 };
Alex Elderd8891402012-10-09 13:50:17 -07003573 u64 incompat;
Alex Elderb1b54022012-07-03 16:01:19 -05003574 int ret;
3575
Alex Elder36be9a72013-01-19 00:30:28 -06003576 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elderb1b54022012-07-03 16:01:19 -05003577 "rbd", "get_features",
Alex Elder41579762013-04-21 12:14:45 -05003578 &snapid, sizeof (snapid),
3579 &features_buf, sizeof (features_buf), NULL);
Alex Elder36be9a72013-01-19 00:30:28 -06003580 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elderb1b54022012-07-03 16:01:19 -05003581 if (ret < 0)
3582 return ret;
Alex Elder57385b52013-04-21 12:14:45 -05003583 if (ret < sizeof (features_buf))
3584 return -ERANGE;
Alex Elderd8891402012-10-09 13:50:17 -07003585
3586 incompat = le64_to_cpu(features_buf.incompat);
Alex Elder5cbf6f122013-04-11 09:29:48 -05003587 if (incompat & ~RBD_FEATURES_SUPPORTED)
Alex Elderb8f5c6e2012-11-01 08:39:26 -05003588 return -ENXIO;
Alex Elderd8891402012-10-09 13:50:17 -07003589
Alex Elderb1b54022012-07-03 16:01:19 -05003590 *snap_features = le64_to_cpu(features_buf.features);
3591
3592 dout(" snap_id 0x%016llx features = 0x%016llx incompat = 0x%016llx\n",
Alex Elder57385b52013-04-21 12:14:45 -05003593 (unsigned long long)snap_id,
3594 (unsigned long long)*snap_features,
3595 (unsigned long long)le64_to_cpu(features_buf.incompat));
Alex Elderb1b54022012-07-03 16:01:19 -05003596
3597 return 0;
3598}
3599
3600static int rbd_dev_v2_features(struct rbd_device *rbd_dev)
3601{
3602 return _rbd_dev_v2_snap_features(rbd_dev, CEPH_NOSNAP,
3603 &rbd_dev->header.features);
3604}
3605
Alex Elder86b00e02012-10-25 23:34:42 -05003606static int rbd_dev_v2_parent_info(struct rbd_device *rbd_dev)
3607{
3608 struct rbd_spec *parent_spec;
3609 size_t size;
3610 void *reply_buf = NULL;
3611 __le64 snapid;
3612 void *p;
3613 void *end;
3614 char *image_id;
3615 u64 overlap;
Alex Elder86b00e02012-10-25 23:34:42 -05003616 int ret;
3617
3618 parent_spec = rbd_spec_alloc();
3619 if (!parent_spec)
3620 return -ENOMEM;
3621
3622 size = sizeof (__le64) + /* pool_id */
3623 sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX + /* image_id */
3624 sizeof (__le64) + /* snap_id */
3625 sizeof (__le64); /* overlap */
3626 reply_buf = kmalloc(size, GFP_KERNEL);
3627 if (!reply_buf) {
3628 ret = -ENOMEM;
3629 goto out_err;
3630 }
3631
3632 snapid = cpu_to_le64(CEPH_NOSNAP);
Alex Elder36be9a72013-01-19 00:30:28 -06003633 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder86b00e02012-10-25 23:34:42 -05003634 "rbd", "get_parent",
Alex Elder41579762013-04-21 12:14:45 -05003635 &snapid, sizeof (snapid),
3636 reply_buf, size, NULL);
Alex Elder36be9a72013-01-19 00:30:28 -06003637 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder86b00e02012-10-25 23:34:42 -05003638 if (ret < 0)
3639 goto out_err;
3640
Alex Elder86b00e02012-10-25 23:34:42 -05003641 p = reply_buf;
Alex Elder57385b52013-04-21 12:14:45 -05003642 end = reply_buf + ret;
3643 ret = -ERANGE;
Alex Elder86b00e02012-10-25 23:34:42 -05003644 ceph_decode_64_safe(&p, end, parent_spec->pool_id, out_err);
3645 if (parent_spec->pool_id == CEPH_NOPOOL)
3646 goto out; /* No parent? No problem. */
3647
Alex Elder0903e872012-11-14 12:25:19 -06003648 /* The ceph file layout needs to fit pool id in 32 bits */
3649
3650 ret = -EIO;
Alex Elderc0cd10db2013-04-26 09:43:47 -05003651 if (parent_spec->pool_id > (u64)U32_MAX) {
3652 rbd_warn(NULL, "parent pool id too large (%llu > %u)\n",
3653 (unsigned long long)parent_spec->pool_id, U32_MAX);
Alex Elder57385b52013-04-21 12:14:45 -05003654 goto out_err;
Alex Elderc0cd10db2013-04-26 09:43:47 -05003655 }
Alex Elder0903e872012-11-14 12:25:19 -06003656
Alex Elder979ed482012-11-01 08:39:26 -05003657 image_id = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
Alex Elder86b00e02012-10-25 23:34:42 -05003658 if (IS_ERR(image_id)) {
3659 ret = PTR_ERR(image_id);
3660 goto out_err;
3661 }
3662 parent_spec->image_id = image_id;
3663 ceph_decode_64_safe(&p, end, parent_spec->snap_id, out_err);
3664 ceph_decode_64_safe(&p, end, overlap, out_err);
3665
3666 rbd_dev->parent_overlap = overlap;
3667 rbd_dev->parent_spec = parent_spec;
3668 parent_spec = NULL; /* rbd_dev now owns this */
3669out:
3670 ret = 0;
3671out_err:
3672 kfree(reply_buf);
3673 rbd_spec_put(parent_spec);
3674
3675 return ret;
3676}
3677
Alex Eldercc070d52013-04-21 12:14:45 -05003678static int rbd_dev_v2_striping_info(struct rbd_device *rbd_dev)
3679{
3680 struct {
3681 __le64 stripe_unit;
3682 __le64 stripe_count;
3683 } __attribute__ ((packed)) striping_info_buf = { 0 };
3684 size_t size = sizeof (striping_info_buf);
3685 void *p;
3686 u64 obj_size;
3687 u64 stripe_unit;
3688 u64 stripe_count;
3689 int ret;
3690
3691 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
3692 "rbd", "get_stripe_unit_count", NULL, 0,
3693 (char *)&striping_info_buf, size, NULL);
3694 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
3695 if (ret < 0)
3696 return ret;
3697 if (ret < size)
3698 return -ERANGE;
3699
3700 /*
3701 * We don't actually support the "fancy striping" feature
3702 * (STRIPINGV2) yet, but if the striping sizes are the
3703 * defaults the behavior is the same as before. So find
3704 * out, and only fail if the image has non-default values.
3705 */
3706 ret = -EINVAL;
3707 obj_size = (u64)1 << rbd_dev->header.obj_order;
3708 p = &striping_info_buf;
3709 stripe_unit = ceph_decode_64(&p);
3710 if (stripe_unit != obj_size) {
3711 rbd_warn(rbd_dev, "unsupported stripe unit "
3712 "(got %llu want %llu)",
3713 stripe_unit, obj_size);
3714 return -EINVAL;
3715 }
3716 stripe_count = ceph_decode_64(&p);
3717 if (stripe_count != 1) {
3718 rbd_warn(rbd_dev, "unsupported stripe count "
3719 "(got %llu want 1)", stripe_count);
3720 return -EINVAL;
3721 }
Alex Elder500d0c0f2013-04-26 09:43:47 -05003722 rbd_dev->header.stripe_unit = stripe_unit;
3723 rbd_dev->header.stripe_count = stripe_count;
Alex Eldercc070d52013-04-21 12:14:45 -05003724
3725 return 0;
3726}
3727
Alex Elder9e15b772012-10-30 19:40:33 -05003728static char *rbd_dev_image_name(struct rbd_device *rbd_dev)
3729{
3730 size_t image_id_size;
3731 char *image_id;
3732 void *p;
3733 void *end;
3734 size_t size;
3735 void *reply_buf = NULL;
3736 size_t len = 0;
3737 char *image_name = NULL;
3738 int ret;
3739
3740 rbd_assert(!rbd_dev->spec->image_name);
3741
Alex Elder69e7a022012-11-01 08:39:26 -05003742 len = strlen(rbd_dev->spec->image_id);
3743 image_id_size = sizeof (__le32) + len;
Alex Elder9e15b772012-10-30 19:40:33 -05003744 image_id = kmalloc(image_id_size, GFP_KERNEL);
3745 if (!image_id)
3746 return NULL;
3747
3748 p = image_id;
Alex Elder41579762013-04-21 12:14:45 -05003749 end = image_id + image_id_size;
Alex Elder57385b52013-04-21 12:14:45 -05003750 ceph_encode_string(&p, end, rbd_dev->spec->image_id, (u32)len);
Alex Elder9e15b772012-10-30 19:40:33 -05003751
3752 size = sizeof (__le32) + RBD_IMAGE_NAME_LEN_MAX;
3753 reply_buf = kmalloc(size, GFP_KERNEL);
3754 if (!reply_buf)
3755 goto out;
3756
Alex Elder36be9a72013-01-19 00:30:28 -06003757 ret = rbd_obj_method_sync(rbd_dev, RBD_DIRECTORY,
Alex Elder9e15b772012-10-30 19:40:33 -05003758 "rbd", "dir_get_name",
3759 image_id, image_id_size,
Alex Elder41579762013-04-21 12:14:45 -05003760 reply_buf, size, NULL);
Alex Elder9e15b772012-10-30 19:40:33 -05003761 if (ret < 0)
3762 goto out;
3763 p = reply_buf;
Alex Elderf40eb342013-04-25 15:09:42 -05003764 end = reply_buf + ret;
3765
Alex Elder9e15b772012-10-30 19:40:33 -05003766 image_name = ceph_extract_encoded_string(&p, end, &len, GFP_KERNEL);
3767 if (IS_ERR(image_name))
3768 image_name = NULL;
3769 else
3770 dout("%s: name is %s len is %zd\n", __func__, image_name, len);
3771out:
3772 kfree(reply_buf);
3773 kfree(image_id);
3774
3775 return image_name;
3776}
3777
3778/*
Alex Elder2e9f7f12013-04-26 09:43:48 -05003779 * When an rbd image has a parent image, it is identified by the
3780 * pool, image, and snapshot ids (not names). This function fills
3781 * in the names for those ids. (It's OK if we can't figure out the
3782 * name for an image id, but the pool and snapshot ids should always
3783 * exist and have names.) All names in an rbd spec are dynamically
3784 * allocated.
Alex Eldere1d42132013-04-25 23:15:08 -05003785 *
3786 * When an image being mapped (not a parent) is probed, we have the
3787 * pool name and pool id, image name and image id, and the snapshot
3788 * name. The only thing we're missing is the snapshot id.
Alex Elder2e9f7f12013-04-26 09:43:48 -05003789 *
3790 * The set of snapshots for an image is not known until they have
3791 * been read by rbd_dev_snaps_update(), so we can't completely fill
3792 * in this information until after that has been called.
Alex Elder9e15b772012-10-30 19:40:33 -05003793 */
Alex Elder2e9f7f12013-04-26 09:43:48 -05003794static int rbd_dev_spec_update(struct rbd_device *rbd_dev)
Alex Elder9e15b772012-10-30 19:40:33 -05003795{
Alex Elder2e9f7f12013-04-26 09:43:48 -05003796 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
3797 struct rbd_spec *spec = rbd_dev->spec;
3798 const char *pool_name;
3799 const char *image_name;
3800 const char *snap_name;
Alex Elder9e15b772012-10-30 19:40:33 -05003801 int ret;
3802
Alex Eldere1d42132013-04-25 23:15:08 -05003803 /*
3804 * An image being mapped will have the pool name (etc.), but
3805 * we need to look up the snapshot id.
3806 */
Alex Elder2e9f7f12013-04-26 09:43:48 -05003807 if (spec->pool_name) {
3808 if (strcmp(spec->snap_name, RBD_SNAP_HEAD_NAME)) {
Alex Eldere1d42132013-04-25 23:15:08 -05003809 struct rbd_snap *snap;
3810
Alex Elder2e9f7f12013-04-26 09:43:48 -05003811 snap = snap_by_name(rbd_dev, spec->snap_name);
Alex Eldere1d42132013-04-25 23:15:08 -05003812 if (!snap)
3813 return -ENOENT;
Alex Elder2e9f7f12013-04-26 09:43:48 -05003814 spec->snap_id = snap->id;
Alex Eldere1d42132013-04-25 23:15:08 -05003815 } else {
Alex Elder2e9f7f12013-04-26 09:43:48 -05003816 spec->snap_id = CEPH_NOSNAP;
Alex Eldere1d42132013-04-25 23:15:08 -05003817 }
3818
3819 return 0;
3820 }
Alex Elder9e15b772012-10-30 19:40:33 -05003821
Alex Elder2e9f7f12013-04-26 09:43:48 -05003822 /* Get the pool name; we have to make our own copy of this */
Alex Elder9e15b772012-10-30 19:40:33 -05003823
Alex Elder2e9f7f12013-04-26 09:43:48 -05003824 pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, spec->pool_id);
3825 if (!pool_name) {
3826 rbd_warn(rbd_dev, "no pool with id %llu", spec->pool_id);
Alex Elder935dc892012-11-01 10:17:15 -05003827 return -EIO;
3828 }
Alex Elder2e9f7f12013-04-26 09:43:48 -05003829 pool_name = kstrdup(pool_name, GFP_KERNEL);
3830 if (!pool_name)
Alex Elder9e15b772012-10-30 19:40:33 -05003831 return -ENOMEM;
3832
3833 /* Fetch the image name; tolerate failure here */
3834
Alex Elder2e9f7f12013-04-26 09:43:48 -05003835 image_name = rbd_dev_image_name(rbd_dev);
3836 if (!image_name)
Alex Elder06ecc6c2012-11-01 10:17:15 -05003837 rbd_warn(rbd_dev, "unable to get image name");
Alex Elder9e15b772012-10-30 19:40:33 -05003838
Alex Elder2e9f7f12013-04-26 09:43:48 -05003839 /* Look up the snapshot name, and make a copy */
Alex Elder9e15b772012-10-30 19:40:33 -05003840
Alex Elder2e9f7f12013-04-26 09:43:48 -05003841 snap_name = rbd_snap_name(rbd_dev, spec->snap_id);
3842 if (!snap_name) {
3843 rbd_warn(rbd_dev, "no snapshot with id %llu", spec->snap_id);
Alex Elder9e15b772012-10-30 19:40:33 -05003844 ret = -EIO;
3845 goto out_err;
3846 }
Alex Elder2e9f7f12013-04-26 09:43:48 -05003847 snap_name = kstrdup(snap_name, GFP_KERNEL);
3848 if (!snap_name) {
3849 ret = -ENOMEM;
Alex Elder9e15b772012-10-30 19:40:33 -05003850 goto out_err;
Alex Elder2e9f7f12013-04-26 09:43:48 -05003851 }
3852
3853 spec->pool_name = pool_name;
3854 spec->image_name = image_name;
3855 spec->snap_name = snap_name;
Alex Elder9e15b772012-10-30 19:40:33 -05003856
3857 return 0;
3858out_err:
Alex Elder2e9f7f12013-04-26 09:43:48 -05003859 kfree(image_name);
3860 kfree(pool_name);
Alex Elder9e15b772012-10-30 19:40:33 -05003861
3862 return ret;
3863}
3864
Alex Elder6e14b1a2012-07-03 16:01:19 -05003865static int rbd_dev_v2_snap_context(struct rbd_device *rbd_dev, u64 *ver)
Alex Elder35d489f2012-07-03 16:01:19 -05003866{
3867 size_t size;
3868 int ret;
3869 void *reply_buf;
3870 void *p;
3871 void *end;
3872 u64 seq;
3873 u32 snap_count;
3874 struct ceph_snap_context *snapc;
3875 u32 i;
3876
3877 /*
3878 * We'll need room for the seq value (maximum snapshot id),
3879 * snapshot count, and array of that many snapshot ids.
3880 * For now we have a fixed upper limit on the number we're
3881 * prepared to receive.
3882 */
3883 size = sizeof (__le64) + sizeof (__le32) +
3884 RBD_MAX_SNAP_COUNT * sizeof (__le64);
3885 reply_buf = kzalloc(size, GFP_KERNEL);
3886 if (!reply_buf)
3887 return -ENOMEM;
3888
Alex Elder36be9a72013-01-19 00:30:28 -06003889 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder41579762013-04-21 12:14:45 -05003890 "rbd", "get_snapcontext", NULL, 0,
Alex Elder07b23912012-11-09 08:43:16 -06003891 reply_buf, size, ver);
Alex Elder36be9a72013-01-19 00:30:28 -06003892 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder35d489f2012-07-03 16:01:19 -05003893 if (ret < 0)
3894 goto out;
3895
Alex Elder35d489f2012-07-03 16:01:19 -05003896 p = reply_buf;
Alex Elder57385b52013-04-21 12:14:45 -05003897 end = reply_buf + ret;
3898 ret = -ERANGE;
Alex Elder35d489f2012-07-03 16:01:19 -05003899 ceph_decode_64_safe(&p, end, seq, out);
3900 ceph_decode_32_safe(&p, end, snap_count, out);
3901
3902 /*
3903 * Make sure the reported number of snapshot ids wouldn't go
3904 * beyond the end of our buffer. But before checking that,
3905 * make sure the computed size of the snapshot context we
3906 * allocate is representable in a size_t.
3907 */
3908 if (snap_count > (SIZE_MAX - sizeof (struct ceph_snap_context))
3909 / sizeof (u64)) {
3910 ret = -EINVAL;
3911 goto out;
3912 }
3913 if (!ceph_has_room(&p, end, snap_count * sizeof (__le64)))
3914 goto out;
Alex Elder468521c2013-04-26 09:43:47 -05003915 ret = 0;
Alex Elder35d489f2012-07-03 16:01:19 -05003916
Alex Elder468521c2013-04-26 09:43:47 -05003917 snapc = rbd_snap_context_create(snap_count);
Alex Elder35d489f2012-07-03 16:01:19 -05003918 if (!snapc) {
3919 ret = -ENOMEM;
3920 goto out;
3921 }
Alex Elder35d489f2012-07-03 16:01:19 -05003922 snapc->seq = seq;
Alex Elder35d489f2012-07-03 16:01:19 -05003923 for (i = 0; i < snap_count; i++)
3924 snapc->snaps[i] = ceph_decode_64(&p);
3925
3926 rbd_dev->header.snapc = snapc;
3927
3928 dout(" snap context seq = %llu, snap_count = %u\n",
Alex Elder57385b52013-04-21 12:14:45 -05003929 (unsigned long long)seq, (unsigned int)snap_count);
Alex Elder35d489f2012-07-03 16:01:19 -05003930out:
3931 kfree(reply_buf);
3932
Alex Elder57385b52013-04-21 12:14:45 -05003933 return ret;
Alex Elder35d489f2012-07-03 16:01:19 -05003934}
3935
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003936static char *rbd_dev_v2_snap_name(struct rbd_device *rbd_dev, u32 which)
3937{
3938 size_t size;
3939 void *reply_buf;
3940 __le64 snap_id;
3941 int ret;
3942 void *p;
3943 void *end;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003944 char *snap_name;
3945
3946 size = sizeof (__le32) + RBD_MAX_SNAP_NAME_LEN;
3947 reply_buf = kmalloc(size, GFP_KERNEL);
3948 if (!reply_buf)
3949 return ERR_PTR(-ENOMEM);
3950
Alex Elderacb1b6c2013-04-25 15:09:41 -05003951 rbd_assert(which < rbd_dev->header.snapc->num_snaps);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003952 snap_id = cpu_to_le64(rbd_dev->header.snapc->snaps[which]);
Alex Elder36be9a72013-01-19 00:30:28 -06003953 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003954 "rbd", "get_snapshot_name",
Alex Elder41579762013-04-21 12:14:45 -05003955 &snap_id, sizeof (snap_id),
Alex Elder07b23912012-11-09 08:43:16 -06003956 reply_buf, size, NULL);
Alex Elder36be9a72013-01-19 00:30:28 -06003957 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elderf40eb342013-04-25 15:09:42 -05003958 if (ret < 0) {
3959 snap_name = ERR_PTR(ret);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003960 goto out;
Alex Elderf40eb342013-04-25 15:09:42 -05003961 }
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003962
3963 p = reply_buf;
Alex Elderf40eb342013-04-25 15:09:42 -05003964 end = reply_buf + ret;
Alex Eldere5c35532012-10-25 23:34:41 -05003965 snap_name = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
Alex Elderf40eb342013-04-25 15:09:42 -05003966 if (IS_ERR(snap_name))
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003967 goto out;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003968
Alex Elderf40eb342013-04-25 15:09:42 -05003969 dout(" snap_id 0x%016llx snap_name = %s\n",
3970 (unsigned long long)le64_to_cpu(snap_id), snap_name);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003971out:
3972 kfree(reply_buf);
3973
Alex Elderf40eb342013-04-25 15:09:42 -05003974 return snap_name;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003975}
3976
3977static char *rbd_dev_v2_snap_info(struct rbd_device *rbd_dev, u32 which,
3978 u64 *snap_size, u64 *snap_features)
3979{
Alex Eldere0b49862013-01-09 14:44:18 -06003980 u64 snap_id;
Alex Elderacb1b6c2013-04-25 15:09:41 -05003981 u64 size;
3982 u64 features;
3983 char *snap_name;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003984 int ret;
3985
Alex Elderacb1b6c2013-04-25 15:09:41 -05003986 rbd_assert(which < rbd_dev->header.snapc->num_snaps);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003987 snap_id = rbd_dev->header.snapc->snaps[which];
Alex Elderacb1b6c2013-04-25 15:09:41 -05003988 ret = _rbd_dev_v2_snap_size(rbd_dev, snap_id, NULL, &size);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003989 if (ret)
Alex Elderacb1b6c2013-04-25 15:09:41 -05003990 goto out_err;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05003991
Alex Elderacb1b6c2013-04-25 15:09:41 -05003992 ret = _rbd_dev_v2_snap_features(rbd_dev, snap_id, &features);
3993 if (ret)
3994 goto out_err;
3995
3996 snap_name = rbd_dev_v2_snap_name(rbd_dev, which);
3997 if (!IS_ERR(snap_name)) {
3998 *snap_size = size;
3999 *snap_features = features;
4000 }
4001
4002 return snap_name;
4003out_err:
4004 return ERR_PTR(ret);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004005}
4006
4007static char *rbd_dev_snap_info(struct rbd_device *rbd_dev, u32 which,
4008 u64 *snap_size, u64 *snap_features)
4009{
4010 if (rbd_dev->image_format == 1)
4011 return rbd_dev_v1_snap_info(rbd_dev, which,
4012 snap_size, snap_features);
4013 if (rbd_dev->image_format == 2)
4014 return rbd_dev_v2_snap_info(rbd_dev, which,
4015 snap_size, snap_features);
4016 return ERR_PTR(-EINVAL);
4017}
4018
Alex Elder117973f2012-08-31 17:29:55 -05004019static int rbd_dev_v2_refresh(struct rbd_device *rbd_dev, u64 *hver)
4020{
4021 int ret;
Alex Elder117973f2012-08-31 17:29:55 -05004022
4023 down_write(&rbd_dev->header_rwsem);
4024
Alex Elder117973f2012-08-31 17:29:55 -05004025 ret = rbd_dev_v2_image_size(rbd_dev);
4026 if (ret)
4027 goto out;
Alex Elder117973f2012-08-31 17:29:55 -05004028 rbd_update_mapping_size(rbd_dev);
4029
4030 ret = rbd_dev_v2_snap_context(rbd_dev, hver);
4031 dout("rbd_dev_v2_snap_context returned %d\n", ret);
4032 if (ret)
4033 goto out;
4034 ret = rbd_dev_snaps_update(rbd_dev);
4035 dout("rbd_dev_snaps_update returned %d\n", ret);
4036 if (ret)
4037 goto out;
Alex Elder117973f2012-08-31 17:29:55 -05004038out:
4039 up_write(&rbd_dev->header_rwsem);
4040
4041 return ret;
4042}
4043
Alex Elder9d475de52012-07-03 16:01:19 -05004044/*
Alex Elder35938152012-08-02 11:29:46 -05004045 * Scan the rbd device's current snapshot list and compare it to the
4046 * newly-received snapshot context. Remove any existing snapshots
4047 * not present in the new snapshot context. Add a new snapshot for
4048 * any snaphots in the snapshot context not in the current list.
4049 * And verify there are no changes to snapshots we already know
4050 * about.
4051 *
4052 * Assumes the snapshots in the snapshot context are sorted by
4053 * snapshot id, highest id first. (Snapshots in the rbd_dev's list
4054 * are also maintained in that order.)
Alex Elder522a0cc2013-04-25 15:09:41 -05004055 *
4056 * Note that any error occurs while updating the snapshot list
4057 * aborts the update, and the entire list is cleared. The snapshot
4058 * list becomes inconsistent at that point anyway, so it might as
4059 * well be empty.
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004060 */
Alex Elder304f6802012-08-31 17:29:52 -05004061static int rbd_dev_snaps_update(struct rbd_device *rbd_dev)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004062{
Alex Elder35938152012-08-02 11:29:46 -05004063 struct ceph_snap_context *snapc = rbd_dev->header.snapc;
4064 const u32 snap_count = snapc->num_snaps;
Alex Elder35938152012-08-02 11:29:46 -05004065 struct list_head *head = &rbd_dev->snaps;
4066 struct list_head *links = head->next;
4067 u32 index = 0;
Alex Elder522a0cc2013-04-25 15:09:41 -05004068 int ret = 0;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004069
Alex Elder522a0cc2013-04-25 15:09:41 -05004070 dout("%s: snap count is %u\n", __func__, (unsigned int)snap_count);
Alex Elder35938152012-08-02 11:29:46 -05004071 while (index < snap_count || links != head) {
4072 u64 snap_id;
4073 struct rbd_snap *snap;
Alex Eldercd892122012-07-03 16:01:19 -05004074 char *snap_name;
4075 u64 snap_size = 0;
4076 u64 snap_features = 0;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004077
Alex Elder35938152012-08-02 11:29:46 -05004078 snap_id = index < snap_count ? snapc->snaps[index]
4079 : CEPH_NOSNAP;
4080 snap = links != head ? list_entry(links, struct rbd_snap, node)
4081 : NULL;
Alex Elderaafb2302012-09-06 16:00:54 -05004082 rbd_assert(!snap || snap->id != CEPH_NOSNAP);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004083
Alex Elder35938152012-08-02 11:29:46 -05004084 if (snap_id == CEPH_NOSNAP || (snap && snap->id > snap_id)) {
4085 struct list_head *next = links->next;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004086
Alex Elder6d292902013-01-14 12:43:31 -06004087 /*
4088 * A previously-existing snapshot is not in
4089 * the new snap context.
4090 *
Alex Elder522a0cc2013-04-25 15:09:41 -05004091 * If the now-missing snapshot is the one
4092 * the image represents, clear its existence
4093 * flag so we can avoid sending any more
4094 * requests to it.
Alex Elder6d292902013-01-14 12:43:31 -06004095 */
Alex Elder0d7dbfc2012-10-25 23:34:41 -05004096 if (rbd_dev->spec->snap_id == snap->id)
Alex Elder6d292902013-01-14 12:43:31 -06004097 clear_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags);
Alex Elder3e83b652013-04-23 13:52:53 -05004098 dout("removing %ssnap id %llu\n",
Alex Elder0d7dbfc2012-10-25 23:34:41 -05004099 rbd_dev->spec->snap_id == snap->id ?
4100 "mapped " : "",
Alex Elder522a0cc2013-04-25 15:09:41 -05004101 (unsigned long long)snap->id);
Alex Elder6087b512013-04-25 15:09:41 -05004102
4103 list_del(&snap->node);
4104 rbd_snap_destroy(snap);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004105
Alex Elder35938152012-08-02 11:29:46 -05004106 /* Done with this list entry; advance */
4107
4108 links = next;
4109 continue;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004110 }
Alex Elder35938152012-08-02 11:29:46 -05004111
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004112 snap_name = rbd_dev_snap_info(rbd_dev, index,
4113 &snap_size, &snap_features);
Alex Elder522a0cc2013-04-25 15:09:41 -05004114 if (IS_ERR(snap_name)) {
4115 ret = PTR_ERR(snap_name);
4116 dout("failed to get snap info, error %d\n", ret);
4117 goto out_err;
4118 }
Alex Eldercd892122012-07-03 16:01:19 -05004119
Alex Elder522a0cc2013-04-25 15:09:41 -05004120 dout("entry %u: snap_id = %llu\n", (unsigned int)snap_count,
4121 (unsigned long long)snap_id);
Alex Elder35938152012-08-02 11:29:46 -05004122 if (!snap || (snap_id != CEPH_NOSNAP && snap->id < snap_id)) {
4123 struct rbd_snap *new_snap;
4124
4125 /* We haven't seen this snapshot before */
4126
Alex Elder6087b512013-04-25 15:09:41 -05004127 new_snap = rbd_snap_create(rbd_dev, snap_name,
Alex Eldercd892122012-07-03 16:01:19 -05004128 snap_id, snap_size, snap_features);
Alex Elder9fcbb802012-08-23 23:48:49 -05004129 if (IS_ERR(new_snap)) {
Alex Elder522a0cc2013-04-25 15:09:41 -05004130 ret = PTR_ERR(new_snap);
4131 dout(" failed to add dev, error %d\n", ret);
4132 goto out_err;
Alex Elder9fcbb802012-08-23 23:48:49 -05004133 }
Alex Elder35938152012-08-02 11:29:46 -05004134
4135 /* New goes before existing, or at end of list */
4136
Alex Elder9fcbb802012-08-23 23:48:49 -05004137 dout(" added dev%s\n", snap ? "" : " at end\n");
Alex Elder35938152012-08-02 11:29:46 -05004138 if (snap)
4139 list_add_tail(&new_snap->node, &snap->node);
4140 else
Alex Elder523f3252012-08-30 00:16:37 -05004141 list_add_tail(&new_snap->node, head);
Alex Elder35938152012-08-02 11:29:46 -05004142 } else {
4143 /* Already have this one */
4144
Alex Elder9fcbb802012-08-23 23:48:49 -05004145 dout(" already present\n");
4146
Alex Eldercd892122012-07-03 16:01:19 -05004147 rbd_assert(snap->size == snap_size);
Alex Elderaafb2302012-09-06 16:00:54 -05004148 rbd_assert(!strcmp(snap->name, snap_name));
Alex Eldercd892122012-07-03 16:01:19 -05004149 rbd_assert(snap->features == snap_features);
Alex Elder35938152012-08-02 11:29:46 -05004150
4151 /* Done with this list entry; advance */
4152
4153 links = links->next;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004154 }
Alex Elder35938152012-08-02 11:29:46 -05004155
4156 /* Advance to the next entry in the snapshot context */
4157
4158 index++;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004159 }
Alex Elder9fcbb802012-08-23 23:48:49 -05004160 dout("%s: done\n", __func__);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004161
4162 return 0;
Alex Elder522a0cc2013-04-25 15:09:41 -05004163out_err:
4164 rbd_remove_all_snaps(rbd_dev);
4165
4166 return ret;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004167}
4168
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004169static int rbd_bus_add_dev(struct rbd_device *rbd_dev)
4170{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004171 struct device *dev;
Alex Eldercd789ab2012-08-30 00:16:38 -05004172 int ret;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004173
4174 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004175
Alex Eldercd789ab2012-08-30 00:16:38 -05004176 dev = &rbd_dev->dev;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004177 dev->bus = &rbd_bus_type;
4178 dev->type = &rbd_device_type;
4179 dev->parent = &rbd_root_dev;
Alex Elder200a6a82013-04-28 23:32:34 -05004180 dev->release = rbd_dev_device_release;
Alex Elderde71a292012-07-03 16:01:19 -05004181 dev_set_name(dev, "%d", rbd_dev->dev_id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004182 ret = device_register(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004183
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004184 mutex_unlock(&ctl_mutex);
Alex Eldercd789ab2012-08-30 00:16:38 -05004185
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004186 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004187}
4188
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004189static void rbd_bus_del_dev(struct rbd_device *rbd_dev)
4190{
4191 device_unregister(&rbd_dev->dev);
4192}
4193
Alex Eldere2839302012-08-29 17:11:06 -05004194static atomic64_t rbd_dev_id_max = ATOMIC64_INIT(0);
Alex Elder1ddbe942012-01-29 13:57:44 -06004195
4196/*
Alex Elder499afd52012-02-02 08:13:29 -06004197 * Get a unique rbd identifier for the given new rbd_dev, and add
4198 * the rbd_dev to the global list. The minimum rbd id is 1.
Alex Elder1ddbe942012-01-29 13:57:44 -06004199 */
Alex Eldere2839302012-08-29 17:11:06 -05004200static void rbd_dev_id_get(struct rbd_device *rbd_dev)
Alex Elderb7f23c32012-01-29 13:57:43 -06004201{
Alex Eldere2839302012-08-29 17:11:06 -05004202 rbd_dev->dev_id = atomic64_inc_return(&rbd_dev_id_max);
Alex Elder499afd52012-02-02 08:13:29 -06004203
4204 spin_lock(&rbd_dev_list_lock);
4205 list_add_tail(&rbd_dev->node, &rbd_dev_list);
4206 spin_unlock(&rbd_dev_list_lock);
Alex Eldere2839302012-08-29 17:11:06 -05004207 dout("rbd_dev %p given dev id %llu\n", rbd_dev,
4208 (unsigned long long) rbd_dev->dev_id);
Alex Elder1ddbe942012-01-29 13:57:44 -06004209}
Alex Elderb7f23c32012-01-29 13:57:43 -06004210
Alex Elder1ddbe942012-01-29 13:57:44 -06004211/*
Alex Elder499afd52012-02-02 08:13:29 -06004212 * Remove an rbd_dev from the global list, and record that its
4213 * identifier is no longer in use.
Alex Elder1ddbe942012-01-29 13:57:44 -06004214 */
Alex Eldere2839302012-08-29 17:11:06 -05004215static void rbd_dev_id_put(struct rbd_device *rbd_dev)
Alex Elder1ddbe942012-01-29 13:57:44 -06004216{
Alex Elderd184f6b2012-01-29 13:57:44 -06004217 struct list_head *tmp;
Alex Elderde71a292012-07-03 16:01:19 -05004218 int rbd_id = rbd_dev->dev_id;
Alex Elderd184f6b2012-01-29 13:57:44 -06004219 int max_id;
4220
Alex Elderaafb2302012-09-06 16:00:54 -05004221 rbd_assert(rbd_id > 0);
Alex Elder499afd52012-02-02 08:13:29 -06004222
Alex Eldere2839302012-08-29 17:11:06 -05004223 dout("rbd_dev %p released dev id %llu\n", rbd_dev,
4224 (unsigned long long) rbd_dev->dev_id);
Alex Elder499afd52012-02-02 08:13:29 -06004225 spin_lock(&rbd_dev_list_lock);
4226 list_del_init(&rbd_dev->node);
Alex Elderd184f6b2012-01-29 13:57:44 -06004227
4228 /*
4229 * If the id being "put" is not the current maximum, there
4230 * is nothing special we need to do.
4231 */
Alex Eldere2839302012-08-29 17:11:06 -05004232 if (rbd_id != atomic64_read(&rbd_dev_id_max)) {
Alex Elderd184f6b2012-01-29 13:57:44 -06004233 spin_unlock(&rbd_dev_list_lock);
4234 return;
4235 }
4236
4237 /*
4238 * We need to update the current maximum id. Search the
4239 * list to find out what it is. We're more likely to find
4240 * the maximum at the end, so search the list backward.
4241 */
4242 max_id = 0;
4243 list_for_each_prev(tmp, &rbd_dev_list) {
4244 struct rbd_device *rbd_dev;
4245
4246 rbd_dev = list_entry(tmp, struct rbd_device, node);
Alex Elderb213e0b2012-10-10 21:19:13 -07004247 if (rbd_dev->dev_id > max_id)
4248 max_id = rbd_dev->dev_id;
Alex Elderd184f6b2012-01-29 13:57:44 -06004249 }
Alex Elder499afd52012-02-02 08:13:29 -06004250 spin_unlock(&rbd_dev_list_lock);
Alex Elderb7f23c32012-01-29 13:57:43 -06004251
Alex Elder1ddbe942012-01-29 13:57:44 -06004252 /*
Alex Eldere2839302012-08-29 17:11:06 -05004253 * The max id could have been updated by rbd_dev_id_get(), in
Alex Elderd184f6b2012-01-29 13:57:44 -06004254 * which case it now accurately reflects the new maximum.
4255 * Be careful not to overwrite the maximum value in that
4256 * case.
Alex Elder1ddbe942012-01-29 13:57:44 -06004257 */
Alex Eldere2839302012-08-29 17:11:06 -05004258 atomic64_cmpxchg(&rbd_dev_id_max, rbd_id, max_id);
4259 dout(" max dev id has been reset\n");
Alex Elderb7f23c32012-01-29 13:57:43 -06004260}
4261
Alex Eldera725f65e2012-02-02 08:13:30 -06004262/*
Alex Eldere28fff262012-02-02 08:13:30 -06004263 * Skips over white space at *buf, and updates *buf to point to the
4264 * first found non-space character (if any). Returns the length of
Alex Elder593a9e72012-02-07 12:03:37 -06004265 * the token (string of non-white space characters) found. Note
4266 * that *buf must be terminated with '\0'.
Alex Eldere28fff262012-02-02 08:13:30 -06004267 */
4268static inline size_t next_token(const char **buf)
4269{
4270 /*
4271 * These are the characters that produce nonzero for
4272 * isspace() in the "C" and "POSIX" locales.
4273 */
4274 const char *spaces = " \f\n\r\t\v";
4275
4276 *buf += strspn(*buf, spaces); /* Find start of token */
4277
4278 return strcspn(*buf, spaces); /* Return token length */
4279}
4280
4281/*
4282 * Finds the next token in *buf, and if the provided token buffer is
4283 * big enough, copies the found token into it. The result, if
Alex Elder593a9e72012-02-07 12:03:37 -06004284 * copied, is guaranteed to be terminated with '\0'. Note that *buf
4285 * must be terminated with '\0' on entry.
Alex Eldere28fff262012-02-02 08:13:30 -06004286 *
4287 * Returns the length of the token found (not including the '\0').
4288 * Return value will be 0 if no token is found, and it will be >=
4289 * token_size if the token would not fit.
4290 *
Alex Elder593a9e72012-02-07 12:03:37 -06004291 * The *buf pointer will be updated to point beyond the end of the
Alex Eldere28fff262012-02-02 08:13:30 -06004292 * found token. Note that this occurs even if the token buffer is
4293 * too small to hold it.
4294 */
4295static inline size_t copy_token(const char **buf,
4296 char *token,
4297 size_t token_size)
4298{
4299 size_t len;
4300
4301 len = next_token(buf);
4302 if (len < token_size) {
4303 memcpy(token, *buf, len);
4304 *(token + len) = '\0';
4305 }
4306 *buf += len;
4307
4308 return len;
4309}
4310
4311/*
Alex Elderea3352f2012-07-09 21:04:23 -05004312 * Finds the next token in *buf, dynamically allocates a buffer big
4313 * enough to hold a copy of it, and copies the token into the new
4314 * buffer. The copy is guaranteed to be terminated with '\0'. Note
4315 * that a duplicate buffer is created even for a zero-length token.
4316 *
4317 * Returns a pointer to the newly-allocated duplicate, or a null
4318 * pointer if memory for the duplicate was not available. If
4319 * the lenp argument is a non-null pointer, the length of the token
4320 * (not including the '\0') is returned in *lenp.
4321 *
4322 * If successful, the *buf pointer will be updated to point beyond
4323 * the end of the found token.
4324 *
4325 * Note: uses GFP_KERNEL for allocation.
4326 */
4327static inline char *dup_token(const char **buf, size_t *lenp)
4328{
4329 char *dup;
4330 size_t len;
4331
4332 len = next_token(buf);
Alex Elder4caf35f2012-11-01 08:39:27 -05004333 dup = kmemdup(*buf, len + 1, GFP_KERNEL);
Alex Elderea3352f2012-07-09 21:04:23 -05004334 if (!dup)
4335 return NULL;
Alex Elderea3352f2012-07-09 21:04:23 -05004336 *(dup + len) = '\0';
4337 *buf += len;
4338
4339 if (lenp)
4340 *lenp = len;
4341
4342 return dup;
4343}
4344
4345/*
Alex Elder859c31d2012-10-25 23:34:42 -05004346 * Parse the options provided for an "rbd add" (i.e., rbd image
4347 * mapping) request. These arrive via a write to /sys/bus/rbd/add,
4348 * and the data written is passed here via a NUL-terminated buffer.
4349 * Returns 0 if successful or an error code otherwise.
Alex Elderd22f76e2012-07-12 10:46:35 -05004350 *
Alex Elder859c31d2012-10-25 23:34:42 -05004351 * The information extracted from these options is recorded in
4352 * the other parameters which return dynamically-allocated
4353 * structures:
4354 * ceph_opts
4355 * The address of a pointer that will refer to a ceph options
4356 * structure. Caller must release the returned pointer using
4357 * ceph_destroy_options() when it is no longer needed.
4358 * rbd_opts
4359 * Address of an rbd options pointer. Fully initialized by
4360 * this function; caller must release with kfree().
4361 * spec
4362 * Address of an rbd image specification pointer. Fully
4363 * initialized by this function based on parsed options.
4364 * Caller must release with rbd_spec_put().
4365 *
4366 * The options passed take this form:
4367 * <mon_addrs> <options> <pool_name> <image_name> [<snap_id>]
4368 * where:
4369 * <mon_addrs>
4370 * A comma-separated list of one or more monitor addresses.
4371 * A monitor address is an ip address, optionally followed
4372 * by a port number (separated by a colon).
4373 * I.e.: ip1[:port1][,ip2[:port2]...]
4374 * <options>
4375 * A comma-separated list of ceph and/or rbd options.
4376 * <pool_name>
4377 * The name of the rados pool containing the rbd image.
4378 * <image_name>
4379 * The name of the image in that pool to map.
4380 * <snap_id>
4381 * An optional snapshot id. If provided, the mapping will
4382 * present data from the image at the time that snapshot was
4383 * created. The image head is used if no snapshot id is
4384 * provided. Snapshot mappings are always read-only.
Alex Eldera725f65e2012-02-02 08:13:30 -06004385 */
Alex Elder859c31d2012-10-25 23:34:42 -05004386static int rbd_add_parse_args(const char *buf,
Alex Elderdc79b112012-10-25 23:34:41 -05004387 struct ceph_options **ceph_opts,
Alex Elder859c31d2012-10-25 23:34:42 -05004388 struct rbd_options **opts,
4389 struct rbd_spec **rbd_spec)
Alex Eldera725f65e2012-02-02 08:13:30 -06004390{
Alex Elderd22f76e2012-07-12 10:46:35 -05004391 size_t len;
Alex Elder859c31d2012-10-25 23:34:42 -05004392 char *options;
Alex Elder0ddebc02012-10-25 23:34:41 -05004393 const char *mon_addrs;
Alex Elderecb4dc222013-04-26 09:43:47 -05004394 char *snap_name;
Alex Elder0ddebc02012-10-25 23:34:41 -05004395 size_t mon_addrs_size;
Alex Elder859c31d2012-10-25 23:34:42 -05004396 struct rbd_spec *spec = NULL;
Alex Elder4e9afeba2012-10-25 23:34:41 -05004397 struct rbd_options *rbd_opts = NULL;
Alex Elder859c31d2012-10-25 23:34:42 -05004398 struct ceph_options *copts;
Alex Elderdc79b112012-10-25 23:34:41 -05004399 int ret;
Alex Eldere28fff262012-02-02 08:13:30 -06004400
4401 /* The first four tokens are required */
4402
Alex Elder7ef32142012-02-02 08:13:30 -06004403 len = next_token(&buf);
Alex Elder4fb5d6712012-11-01 10:17:15 -05004404 if (!len) {
4405 rbd_warn(NULL, "no monitor address(es) provided");
4406 return -EINVAL;
4407 }
Alex Elder0ddebc02012-10-25 23:34:41 -05004408 mon_addrs = buf;
Alex Elderf28e5652012-10-25 23:34:41 -05004409 mon_addrs_size = len + 1;
Alex Elder7ef32142012-02-02 08:13:30 -06004410 buf += len;
Alex Eldera725f65e2012-02-02 08:13:30 -06004411
Alex Elderdc79b112012-10-25 23:34:41 -05004412 ret = -EINVAL;
Alex Elderf28e5652012-10-25 23:34:41 -05004413 options = dup_token(&buf, NULL);
4414 if (!options)
Alex Elderdc79b112012-10-25 23:34:41 -05004415 return -ENOMEM;
Alex Elder4fb5d6712012-11-01 10:17:15 -05004416 if (!*options) {
4417 rbd_warn(NULL, "no options provided");
4418 goto out_err;
4419 }
Alex Eldera725f65e2012-02-02 08:13:30 -06004420
Alex Elder859c31d2012-10-25 23:34:42 -05004421 spec = rbd_spec_alloc();
4422 if (!spec)
Alex Elderf28e5652012-10-25 23:34:41 -05004423 goto out_mem;
Alex Elder859c31d2012-10-25 23:34:42 -05004424
4425 spec->pool_name = dup_token(&buf, NULL);
4426 if (!spec->pool_name)
4427 goto out_mem;
Alex Elder4fb5d6712012-11-01 10:17:15 -05004428 if (!*spec->pool_name) {
4429 rbd_warn(NULL, "no pool name provided");
4430 goto out_err;
4431 }
Alex Eldere28fff262012-02-02 08:13:30 -06004432
Alex Elder69e7a022012-11-01 08:39:26 -05004433 spec->image_name = dup_token(&buf, NULL);
Alex Elder859c31d2012-10-25 23:34:42 -05004434 if (!spec->image_name)
Alex Elderf28e5652012-10-25 23:34:41 -05004435 goto out_mem;
Alex Elder4fb5d6712012-11-01 10:17:15 -05004436 if (!*spec->image_name) {
4437 rbd_warn(NULL, "no image name provided");
4438 goto out_err;
4439 }
Alex Eldere28fff262012-02-02 08:13:30 -06004440
Alex Elderf28e5652012-10-25 23:34:41 -05004441 /*
4442 * Snapshot name is optional; default is to use "-"
4443 * (indicating the head/no snapshot).
4444 */
Alex Elder3feeb8942012-08-31 17:29:52 -05004445 len = next_token(&buf);
Alex Elder820a5f32012-07-09 21:04:24 -05004446 if (!len) {
Alex Elder3feeb8942012-08-31 17:29:52 -05004447 buf = RBD_SNAP_HEAD_NAME; /* No snapshot supplied */
4448 len = sizeof (RBD_SNAP_HEAD_NAME) - 1;
Alex Elderf28e5652012-10-25 23:34:41 -05004449 } else if (len > RBD_MAX_SNAP_NAME_LEN) {
Alex Elderdc79b112012-10-25 23:34:41 -05004450 ret = -ENAMETOOLONG;
Alex Elderf28e5652012-10-25 23:34:41 -05004451 goto out_err;
Alex Elder849b4262012-07-09 21:04:24 -05004452 }
Alex Elderecb4dc222013-04-26 09:43:47 -05004453 snap_name = kmemdup(buf, len + 1, GFP_KERNEL);
4454 if (!snap_name)
Alex Elderf28e5652012-10-25 23:34:41 -05004455 goto out_mem;
Alex Elderecb4dc222013-04-26 09:43:47 -05004456 *(snap_name + len) = '\0';
4457 spec->snap_name = snap_name;
Alex Eldere5c35532012-10-25 23:34:41 -05004458
Alex Elder0ddebc02012-10-25 23:34:41 -05004459 /* Initialize all rbd options to the defaults */
Alex Eldere28fff262012-02-02 08:13:30 -06004460
Alex Elder4e9afeba2012-10-25 23:34:41 -05004461 rbd_opts = kzalloc(sizeof (*rbd_opts), GFP_KERNEL);
4462 if (!rbd_opts)
4463 goto out_mem;
4464
4465 rbd_opts->read_only = RBD_READ_ONLY_DEFAULT;
Alex Elderd22f76e2012-07-12 10:46:35 -05004466
Alex Elder859c31d2012-10-25 23:34:42 -05004467 copts = ceph_parse_options(options, mon_addrs,
Alex Elder0ddebc02012-10-25 23:34:41 -05004468 mon_addrs + mon_addrs_size - 1,
Alex Elder4e9afeba2012-10-25 23:34:41 -05004469 parse_rbd_opts_token, rbd_opts);
Alex Elder859c31d2012-10-25 23:34:42 -05004470 if (IS_ERR(copts)) {
4471 ret = PTR_ERR(copts);
Alex Elderdc79b112012-10-25 23:34:41 -05004472 goto out_err;
4473 }
Alex Elder859c31d2012-10-25 23:34:42 -05004474 kfree(options);
4475
4476 *ceph_opts = copts;
Alex Elder4e9afeba2012-10-25 23:34:41 -05004477 *opts = rbd_opts;
Alex Elder859c31d2012-10-25 23:34:42 -05004478 *rbd_spec = spec;
Alex Elder0ddebc02012-10-25 23:34:41 -05004479
Alex Elderdc79b112012-10-25 23:34:41 -05004480 return 0;
Alex Elderf28e5652012-10-25 23:34:41 -05004481out_mem:
Alex Elderdc79b112012-10-25 23:34:41 -05004482 ret = -ENOMEM;
Alex Elderd22f76e2012-07-12 10:46:35 -05004483out_err:
Alex Elder859c31d2012-10-25 23:34:42 -05004484 kfree(rbd_opts);
4485 rbd_spec_put(spec);
Alex Elderf28e5652012-10-25 23:34:41 -05004486 kfree(options);
Alex Elderd22f76e2012-07-12 10:46:35 -05004487
Alex Elderdc79b112012-10-25 23:34:41 -05004488 return ret;
Alex Eldera725f65e2012-02-02 08:13:30 -06004489}
4490
Alex Elder589d30e2012-07-10 20:30:11 -05004491/*
4492 * An rbd format 2 image has a unique identifier, distinct from the
4493 * name given to it by the user. Internally, that identifier is
4494 * what's used to specify the names of objects related to the image.
4495 *
4496 * A special "rbd id" object is used to map an rbd image name to its
4497 * id. If that object doesn't exist, then there is no v2 rbd image
4498 * with the supplied name.
4499 *
4500 * This function will record the given rbd_dev's image_id field if
4501 * it can be determined, and in that case will return 0. If any
4502 * errors occur a negative errno will be returned and the rbd_dev's
4503 * image_id field will be unchanged (and should be NULL).
4504 */
4505static int rbd_dev_image_id(struct rbd_device *rbd_dev)
4506{
4507 int ret;
4508 size_t size;
4509 char *object_name;
4510 void *response;
Alex Elderc0fba362013-04-25 23:15:08 -05004511 char *image_id;
Alex Elder2f82ee52012-10-30 19:40:33 -05004512
Alex Elder589d30e2012-07-10 20:30:11 -05004513 /*
Alex Elder2c0d0a12012-10-30 19:40:33 -05004514 * When probing a parent image, the image id is already
4515 * known (and the image name likely is not). There's no
Alex Elderc0fba362013-04-25 23:15:08 -05004516 * need to fetch the image id again in this case. We
4517 * do still need to set the image format though.
Alex Elder2c0d0a12012-10-30 19:40:33 -05004518 */
Alex Elderc0fba362013-04-25 23:15:08 -05004519 if (rbd_dev->spec->image_id) {
4520 rbd_dev->image_format = *rbd_dev->spec->image_id ? 2 : 1;
4521
Alex Elder2c0d0a12012-10-30 19:40:33 -05004522 return 0;
Alex Elderc0fba362013-04-25 23:15:08 -05004523 }
Alex Elder2c0d0a12012-10-30 19:40:33 -05004524
4525 /*
Alex Elder589d30e2012-07-10 20:30:11 -05004526 * First, see if the format 2 image id file exists, and if
4527 * so, get the image's persistent id from it.
4528 */
Alex Elder69e7a022012-11-01 08:39:26 -05004529 size = sizeof (RBD_ID_PREFIX) + strlen(rbd_dev->spec->image_name);
Alex Elder589d30e2012-07-10 20:30:11 -05004530 object_name = kmalloc(size, GFP_NOIO);
4531 if (!object_name)
4532 return -ENOMEM;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05004533 sprintf(object_name, "%s%s", RBD_ID_PREFIX, rbd_dev->spec->image_name);
Alex Elder589d30e2012-07-10 20:30:11 -05004534 dout("rbd id object name is %s\n", object_name);
4535
4536 /* Response will be an encoded string, which includes a length */
4537
4538 size = sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX;
4539 response = kzalloc(size, GFP_NOIO);
4540 if (!response) {
4541 ret = -ENOMEM;
4542 goto out;
4543 }
4544
Alex Elderc0fba362013-04-25 23:15:08 -05004545 /* If it doesn't exist we'll assume it's a format 1 image */
4546
Alex Elder36be9a72013-01-19 00:30:28 -06004547 ret = rbd_obj_method_sync(rbd_dev, object_name,
Alex Elder41579762013-04-21 12:14:45 -05004548 "rbd", "get_id", NULL, 0,
Alex Elder07b23912012-11-09 08:43:16 -06004549 response, RBD_IMAGE_ID_LEN_MAX, NULL);
Alex Elder36be9a72013-01-19 00:30:28 -06004550 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elderc0fba362013-04-25 23:15:08 -05004551 if (ret == -ENOENT) {
4552 image_id = kstrdup("", GFP_KERNEL);
4553 ret = image_id ? 0 : -ENOMEM;
4554 if (!ret)
4555 rbd_dev->image_format = 1;
4556 } else if (ret > sizeof (__le32)) {
4557 void *p = response;
Alex Elder589d30e2012-07-10 20:30:11 -05004558
Alex Elderc0fba362013-04-25 23:15:08 -05004559 image_id = ceph_extract_encoded_string(&p, p + ret,
Alex Elder979ed482012-11-01 08:39:26 -05004560 NULL, GFP_NOIO);
Alex Elderc0fba362013-04-25 23:15:08 -05004561 ret = IS_ERR(image_id) ? PTR_ERR(image_id) : 0;
4562 if (!ret)
4563 rbd_dev->image_format = 2;
Alex Elder589d30e2012-07-10 20:30:11 -05004564 } else {
Alex Elderc0fba362013-04-25 23:15:08 -05004565 ret = -EINVAL;
4566 }
4567
4568 if (!ret) {
4569 rbd_dev->spec->image_id = image_id;
4570 dout("image_id is %s\n", image_id);
Alex Elder589d30e2012-07-10 20:30:11 -05004571 }
4572out:
4573 kfree(response);
4574 kfree(object_name);
4575
4576 return ret;
4577}
4578
Alex Elder6fd48b32013-04-28 23:32:34 -05004579/* Undo whatever state changes are made by v1 or v2 image probe */
4580
4581static void rbd_dev_unprobe(struct rbd_device *rbd_dev)
4582{
4583 struct rbd_image_header *header;
4584
4585 rbd_dev_remove_parent(rbd_dev);
4586 rbd_spec_put(rbd_dev->parent_spec);
4587 rbd_dev->parent_spec = NULL;
4588 rbd_dev->parent_overlap = 0;
4589
4590 /* Free dynamic fields from the header, then zero it out */
4591
4592 header = &rbd_dev->header;
4593 rbd_snap_context_put(header->snapc);
4594 kfree(header->snap_sizes);
4595 kfree(header->snap_names);
4596 kfree(header->object_prefix);
4597 memset(header, 0, sizeof (*header));
4598}
4599
Alex Eldera30b71b2012-07-10 20:30:11 -05004600static int rbd_dev_v1_probe(struct rbd_device *rbd_dev)
4601{
4602 int ret;
Alex Eldera30b71b2012-07-10 20:30:11 -05004603
4604 /* Populate rbd image metadata */
4605
4606 ret = rbd_read_header(rbd_dev, &rbd_dev->header);
4607 if (ret < 0)
4608 goto out_err;
Alex Elder86b00e02012-10-25 23:34:42 -05004609
4610 /* Version 1 images have no parent (no layering) */
4611
4612 rbd_dev->parent_spec = NULL;
4613 rbd_dev->parent_overlap = 0;
4614
Alex Eldera30b71b2012-07-10 20:30:11 -05004615 dout("discovered version 1 image, header name is %s\n",
4616 rbd_dev->header_name);
4617
4618 return 0;
4619
4620out_err:
4621 kfree(rbd_dev->header_name);
4622 rbd_dev->header_name = NULL;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05004623 kfree(rbd_dev->spec->image_id);
4624 rbd_dev->spec->image_id = NULL;
Alex Eldera30b71b2012-07-10 20:30:11 -05004625
4626 return ret;
4627}
4628
4629static int rbd_dev_v2_probe(struct rbd_device *rbd_dev)
4630{
Alex Elder9d475de52012-07-03 16:01:19 -05004631 int ret;
Alex Elder6e14b1a2012-07-03 16:01:19 -05004632 u64 ver = 0;
Alex Eldera30b71b2012-07-10 20:30:11 -05004633
Alex Elder9d475de52012-07-03 16:01:19 -05004634 ret = rbd_dev_v2_image_size(rbd_dev);
Alex Elder57385b52013-04-21 12:14:45 -05004635 if (ret)
Alex Elder9d475de52012-07-03 16:01:19 -05004636 goto out_err;
Alex Elder1e130192012-07-03 16:01:19 -05004637
4638 /* Get the object prefix (a.k.a. block_name) for the image */
4639
4640 ret = rbd_dev_v2_object_prefix(rbd_dev);
Alex Elder57385b52013-04-21 12:14:45 -05004641 if (ret)
Alex Elder1e130192012-07-03 16:01:19 -05004642 goto out_err;
Alex Elderb1b54022012-07-03 16:01:19 -05004643
Alex Elderd8891402012-10-09 13:50:17 -07004644 /* Get the and check features for the image */
Alex Elderb1b54022012-07-03 16:01:19 -05004645
4646 ret = rbd_dev_v2_features(rbd_dev);
Alex Elder57385b52013-04-21 12:14:45 -05004647 if (ret)
Alex Elderb1b54022012-07-03 16:01:19 -05004648 goto out_err;
Alex Elder35d489f2012-07-03 16:01:19 -05004649
Alex Elder86b00e02012-10-25 23:34:42 -05004650 /* If the image supports layering, get the parent info */
4651
4652 if (rbd_dev->header.features & RBD_FEATURE_LAYERING) {
4653 ret = rbd_dev_v2_parent_info(rbd_dev);
Alex Elder57385b52013-04-21 12:14:45 -05004654 if (ret)
Alex Elder86b00e02012-10-25 23:34:42 -05004655 goto out_err;
Alex Elder770eba62012-10-25 23:34:40 -05004656 rbd_warn(rbd_dev, "WARNING: kernel support for "
4657 "layered rbd images is EXPERIMENTAL!");
Alex Elder86b00e02012-10-25 23:34:42 -05004658 }
4659
Alex Eldercc070d52013-04-21 12:14:45 -05004660 /* If the image supports fancy striping, get its parameters */
4661
4662 if (rbd_dev->header.features & RBD_FEATURE_STRIPINGV2) {
4663 ret = rbd_dev_v2_striping_info(rbd_dev);
4664 if (ret < 0)
4665 goto out_err;
4666 }
4667
Alex Elder6e14b1a2012-07-03 16:01:19 -05004668 /* crypto and compression type aren't (yet) supported for v2 images */
Alex Elder35d489f2012-07-03 16:01:19 -05004669
Alex Elder6e14b1a2012-07-03 16:01:19 -05004670 rbd_dev->header.crypt_type = 0;
4671 rbd_dev->header.comp_type = 0;
4672
4673 /* Get the snapshot context, plus the header version */
4674
4675 ret = rbd_dev_v2_snap_context(rbd_dev, &ver);
Alex Elder35d489f2012-07-03 16:01:19 -05004676 if (ret)
4677 goto out_err;
Alex Elder6e14b1a2012-07-03 16:01:19 -05004678 rbd_dev->header.obj_version = ver;
4679
Alex Eldera30b71b2012-07-10 20:30:11 -05004680 dout("discovered version 2 image, header name is %s\n",
4681 rbd_dev->header_name);
4682
Alex Elder35152972012-08-31 17:29:55 -05004683 return 0;
Alex Elder9d475de52012-07-03 16:01:19 -05004684out_err:
Alex Elder86b00e02012-10-25 23:34:42 -05004685 rbd_dev->parent_overlap = 0;
4686 rbd_spec_put(rbd_dev->parent_spec);
4687 rbd_dev->parent_spec = NULL;
Alex Elder9d475de52012-07-03 16:01:19 -05004688 kfree(rbd_dev->header_name);
4689 rbd_dev->header_name = NULL;
Alex Elder1e130192012-07-03 16:01:19 -05004690 kfree(rbd_dev->header.object_prefix);
4691 rbd_dev->header.object_prefix = NULL;
Alex Elder9d475de52012-07-03 16:01:19 -05004692
4693 return ret;
Alex Eldera30b71b2012-07-10 20:30:11 -05004694}
4695
Alex Elder124afba2013-04-26 15:44:36 -05004696static int rbd_dev_probe_parent(struct rbd_device *rbd_dev)
Alex Elder83a06262012-10-30 15:47:17 -05004697{
Alex Elder2f82ee52012-10-30 19:40:33 -05004698 struct rbd_device *parent = NULL;
Alex Elder124afba2013-04-26 15:44:36 -05004699 struct rbd_spec *parent_spec;
4700 struct rbd_client *rbdc;
4701 int ret;
4702
4703 if (!rbd_dev->parent_spec)
4704 return 0;
4705 /*
4706 * We need to pass a reference to the client and the parent
4707 * spec when creating the parent rbd_dev. Images related by
4708 * parent/child relationships always share both.
4709 */
4710 parent_spec = rbd_spec_get(rbd_dev->parent_spec);
4711 rbdc = __rbd_get_client(rbd_dev->rbd_client);
4712
4713 ret = -ENOMEM;
4714 parent = rbd_dev_create(rbdc, parent_spec);
4715 if (!parent)
4716 goto out_err;
4717
4718 ret = rbd_dev_image_probe(parent);
4719 if (ret < 0)
4720 goto out_err;
4721 rbd_dev->parent = parent;
4722
4723 return 0;
4724out_err:
4725 if (parent) {
4726 rbd_spec_put(rbd_dev->parent_spec);
4727 kfree(rbd_dev->header_name);
4728 rbd_dev_destroy(parent);
4729 } else {
4730 rbd_put_client(rbdc);
4731 rbd_spec_put(parent_spec);
4732 }
4733
4734 return ret;
4735}
4736
Alex Elder200a6a82013-04-28 23:32:34 -05004737static int rbd_dev_device_setup(struct rbd_device *rbd_dev)
Alex Elder124afba2013-04-26 15:44:36 -05004738{
Alex Elder83a06262012-10-30 15:47:17 -05004739 int ret;
Alex Elder83a06262012-10-30 15:47:17 -05004740
Alex Elderd1cf5782013-04-27 09:59:30 -05004741 ret = rbd_dev_mapping_set(rbd_dev);
Alex Elder83a06262012-10-30 15:47:17 -05004742 if (ret)
Alex Elder9bb81c92013-04-27 09:59:30 -05004743 return ret;
Alex Elder5de10f32013-04-26 15:44:37 -05004744
Alex Elder83a06262012-10-30 15:47:17 -05004745 /* generate unique id: find highest unique id, add one */
4746 rbd_dev_id_get(rbd_dev);
4747
4748 /* Fill in the device name, now that we have its id. */
4749 BUILD_BUG_ON(DEV_NAME_LEN
4750 < sizeof (RBD_DRV_NAME) + MAX_INT_FORMAT_WIDTH);
4751 sprintf(rbd_dev->name, "%s%d", RBD_DRV_NAME, rbd_dev->dev_id);
4752
4753 /* Get our block major device number. */
4754
4755 ret = register_blkdev(0, rbd_dev->name);
4756 if (ret < 0)
4757 goto err_out_id;
4758 rbd_dev->major = ret;
4759
4760 /* Set up the blkdev mapping. */
4761
4762 ret = rbd_init_disk(rbd_dev);
4763 if (ret)
4764 goto err_out_blkdev;
4765
4766 ret = rbd_bus_add_dev(rbd_dev);
4767 if (ret)
4768 goto err_out_disk;
4769
Alex Elder83a06262012-10-30 15:47:17 -05004770 /* Everything's ready. Announce the disk to the world. */
4771
Alex Elderb5156e72013-04-26 15:44:36 -05004772 set_capacity(rbd_dev->disk, rbd_dev->mapping.size / SECTOR_SIZE);
Alex Elder129b79d2013-04-26 15:44:36 -05004773 set_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags);
Alex Elder83a06262012-10-30 15:47:17 -05004774 add_disk(rbd_dev->disk);
4775
4776 pr_info("%s: added with size 0x%llx\n", rbd_dev->disk->disk_name,
4777 (unsigned long long) rbd_dev->mapping.size);
4778
4779 return ret;
Alex Elder2f82ee52012-10-30 19:40:33 -05004780
Alex Elder83a06262012-10-30 15:47:17 -05004781err_out_disk:
4782 rbd_free_disk(rbd_dev);
4783err_out_blkdev:
4784 unregister_blkdev(rbd_dev->major, rbd_dev->name);
4785err_out_id:
4786 rbd_dev_id_put(rbd_dev);
Alex Elderd1cf5782013-04-27 09:59:30 -05004787 rbd_dev_mapping_clear(rbd_dev);
Alex Elder83a06262012-10-30 15:47:17 -05004788
4789 return ret;
4790}
4791
Alex Elder332bb122013-04-27 09:59:30 -05004792static int rbd_dev_header_name(struct rbd_device *rbd_dev)
4793{
4794 struct rbd_spec *spec = rbd_dev->spec;
4795 size_t size;
4796
4797 /* Record the header object name for this rbd image. */
4798
4799 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
4800
4801 if (rbd_dev->image_format == 1)
4802 size = strlen(spec->image_name) + sizeof (RBD_SUFFIX);
4803 else
4804 size = sizeof (RBD_HEADER_PREFIX) + strlen(spec->image_id);
4805
4806 rbd_dev->header_name = kmalloc(size, GFP_KERNEL);
4807 if (!rbd_dev->header_name)
4808 return -ENOMEM;
4809
4810 if (rbd_dev->image_format == 1)
4811 sprintf(rbd_dev->header_name, "%s%s",
4812 spec->image_name, RBD_SUFFIX);
4813 else
4814 sprintf(rbd_dev->header_name, "%s%s",
4815 RBD_HEADER_PREFIX, spec->image_id);
4816 return 0;
4817}
4818
Alex Elder200a6a82013-04-28 23:32:34 -05004819static void rbd_dev_image_release(struct rbd_device *rbd_dev)
4820{
Alex Elder6fd48b32013-04-28 23:32:34 -05004821 int ret;
4822
4823 rbd_remove_all_snaps(rbd_dev);
4824 rbd_dev_unprobe(rbd_dev);
4825 ret = rbd_dev_header_watch_sync(rbd_dev, 0);
4826 if (ret)
4827 rbd_warn(rbd_dev, "failed to cancel watch event (%d)\n", ret);
Alex Elder200a6a82013-04-28 23:32:34 -05004828 kfree(rbd_dev->header_name);
Alex Elder6fd48b32013-04-28 23:32:34 -05004829 rbd_dev->header_name = NULL;
4830 rbd_dev->image_format = 0;
4831 kfree(rbd_dev->spec->image_id);
4832 rbd_dev->spec->image_id = NULL;
4833
Alex Elder200a6a82013-04-28 23:32:34 -05004834 rbd_dev_destroy(rbd_dev);
4835}
4836
Alex Eldera30b71b2012-07-10 20:30:11 -05004837/*
4838 * Probe for the existence of the header object for the given rbd
4839 * device. For format 2 images this includes determining the image
4840 * id.
4841 */
Alex Elder71f293e2013-04-26 09:43:48 -05004842static int rbd_dev_image_probe(struct rbd_device *rbd_dev)
Alex Eldera30b71b2012-07-10 20:30:11 -05004843{
4844 int ret;
Alex Elderb644de22013-04-27 09:59:31 -05004845 int tmp;
Alex Eldera30b71b2012-07-10 20:30:11 -05004846
4847 /*
4848 * Get the id from the image id object. If it's not a
4849 * format 2 image, we'll get ENOENT back, and we'll assume
4850 * it's a format 1 image.
4851 */
4852 ret = rbd_dev_image_id(rbd_dev);
4853 if (ret)
Alex Elderc0fba362013-04-25 23:15:08 -05004854 return ret;
4855 rbd_assert(rbd_dev->spec->image_id);
4856 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
4857
Alex Elder332bb122013-04-27 09:59:30 -05004858 ret = rbd_dev_header_name(rbd_dev);
4859 if (ret)
4860 goto err_out_format;
4861
Alex Elderb644de22013-04-27 09:59:31 -05004862 ret = rbd_dev_header_watch_sync(rbd_dev, 1);
4863 if (ret)
4864 goto out_header_name;
4865
Alex Elderc0fba362013-04-25 23:15:08 -05004866 if (rbd_dev->image_format == 1)
Alex Eldera30b71b2012-07-10 20:30:11 -05004867 ret = rbd_dev_v1_probe(rbd_dev);
4868 else
4869 ret = rbd_dev_v2_probe(rbd_dev);
Alex Elder5655c4d2013-04-25 23:15:08 -05004870 if (ret)
Alex Elderb644de22013-04-27 09:59:31 -05004871 goto err_out_watch;
Alex Elder83a06262012-10-30 15:47:17 -05004872
Alex Elder9bb81c92013-04-27 09:59:30 -05004873 ret = rbd_dev_snaps_update(rbd_dev);
4874 if (ret)
Alex Elder6fd48b32013-04-28 23:32:34 -05004875 goto err_out_probe;
Alex Elder9bb81c92013-04-27 09:59:30 -05004876
4877 ret = rbd_dev_spec_update(rbd_dev);
4878 if (ret)
4879 goto err_out_snaps;
4880
4881 ret = rbd_dev_probe_parent(rbd_dev);
4882 if (ret)
4883 goto err_out_snaps;
4884
Alex Elder200a6a82013-04-28 23:32:34 -05004885 ret = rbd_dev_device_setup(rbd_dev);
Alex Elder6fd48b32013-04-28 23:32:34 -05004886 if (!ret)
4887 return 0;
Alex Elder83a06262012-10-30 15:47:17 -05004888
Alex Elder9bb81c92013-04-27 09:59:30 -05004889err_out_snaps:
4890 rbd_remove_all_snaps(rbd_dev);
Alex Elder6fd48b32013-04-28 23:32:34 -05004891err_out_probe:
4892 rbd_dev_unprobe(rbd_dev);
Alex Elderb644de22013-04-27 09:59:31 -05004893err_out_watch:
4894 tmp = rbd_dev_header_watch_sync(rbd_dev, 0);
4895 if (tmp)
4896 rbd_warn(rbd_dev, "unable to tear down watch request\n");
Alex Elder332bb122013-04-27 09:59:30 -05004897out_header_name:
4898 kfree(rbd_dev->header_name);
4899 rbd_dev->header_name = NULL;
4900err_out_format:
4901 rbd_dev->image_format = 0;
Alex Elder5655c4d2013-04-25 23:15:08 -05004902 kfree(rbd_dev->spec->image_id);
4903 rbd_dev->spec->image_id = NULL;
4904
4905 dout("probe failed, returning %d\n", ret);
4906
4907 return ret;
Alex Eldera30b71b2012-07-10 20:30:11 -05004908}
4909
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07004910static ssize_t rbd_add(struct bus_type *bus,
4911 const char *buf,
4912 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004913{
Alex Eldercb8627c2012-07-09 21:04:23 -05004914 struct rbd_device *rbd_dev = NULL;
Alex Elderdc79b112012-10-25 23:34:41 -05004915 struct ceph_options *ceph_opts = NULL;
Alex Elder4e9afeba2012-10-25 23:34:41 -05004916 struct rbd_options *rbd_opts = NULL;
Alex Elder859c31d2012-10-25 23:34:42 -05004917 struct rbd_spec *spec = NULL;
Alex Elder9d3997f2012-10-25 23:34:42 -05004918 struct rbd_client *rbdc;
Alex Elder27cc2592012-02-02 08:13:30 -06004919 struct ceph_osd_client *osdc;
4920 int rc = -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004921
4922 if (!try_module_get(THIS_MODULE))
4923 return -ENODEV;
4924
Alex Eldera725f65e2012-02-02 08:13:30 -06004925 /* parse add command */
Alex Elder859c31d2012-10-25 23:34:42 -05004926 rc = rbd_add_parse_args(buf, &ceph_opts, &rbd_opts, &spec);
Alex Elderdc79b112012-10-25 23:34:41 -05004927 if (rc < 0)
Alex Elderbd4ba652012-10-25 23:34:42 -05004928 goto err_out_module;
Alex Eldera725f65e2012-02-02 08:13:30 -06004929
Alex Elder9d3997f2012-10-25 23:34:42 -05004930 rbdc = rbd_get_client(ceph_opts);
4931 if (IS_ERR(rbdc)) {
4932 rc = PTR_ERR(rbdc);
Alex Elder0ddebc02012-10-25 23:34:41 -05004933 goto err_out_args;
Alex Elder9d3997f2012-10-25 23:34:42 -05004934 }
Alex Elderc53d5892012-10-25 23:34:42 -05004935 ceph_opts = NULL; /* rbd_dev client now owns this */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004936
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004937 /* pick the pool */
Alex Elder9d3997f2012-10-25 23:34:42 -05004938 osdc = &rbdc->client->osdc;
Alex Elder859c31d2012-10-25 23:34:42 -05004939 rc = ceph_pg_poolid_by_name(osdc->osdmap, spec->pool_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004940 if (rc < 0)
4941 goto err_out_client;
Alex Elderc0cd10db2013-04-26 09:43:47 -05004942 spec->pool_id = (u64)rc;
Alex Elder859c31d2012-10-25 23:34:42 -05004943
Alex Elder0903e872012-11-14 12:25:19 -06004944 /* The ceph file layout needs to fit pool id in 32 bits */
4945
Alex Elderc0cd10db2013-04-26 09:43:47 -05004946 if (spec->pool_id > (u64)U32_MAX) {
4947 rbd_warn(NULL, "pool id too large (%llu > %u)\n",
4948 (unsigned long long)spec->pool_id, U32_MAX);
Alex Elder0903e872012-11-14 12:25:19 -06004949 rc = -EIO;
4950 goto err_out_client;
4951 }
4952
Alex Elderc53d5892012-10-25 23:34:42 -05004953 rbd_dev = rbd_dev_create(rbdc, spec);
Alex Elderbd4ba652012-10-25 23:34:42 -05004954 if (!rbd_dev)
4955 goto err_out_client;
Alex Elderc53d5892012-10-25 23:34:42 -05004956 rbdc = NULL; /* rbd_dev now owns this */
4957 spec = NULL; /* rbd_dev now owns this */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004958
Alex Elderbd4ba652012-10-25 23:34:42 -05004959 rbd_dev->mapping.read_only = rbd_opts->read_only;
Alex Elderc53d5892012-10-25 23:34:42 -05004960 kfree(rbd_opts);
4961 rbd_opts = NULL; /* done with this */
Alex Elderbd4ba652012-10-25 23:34:42 -05004962
Alex Elder71f293e2013-04-26 09:43:48 -05004963 rc = rbd_dev_image_probe(rbd_dev);
Alex Eldera30b71b2012-07-10 20:30:11 -05004964 if (rc < 0)
Alex Elderc53d5892012-10-25 23:34:42 -05004965 goto err_out_rbd_dev;
Alex Elder05fd6f62012-08-29 17:11:07 -05004966
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004967 return count;
Alex Elderc53d5892012-10-25 23:34:42 -05004968err_out_rbd_dev:
Alex Elder9f5dffd2013-04-26 09:43:47 -05004969 kfree(rbd_dev->header_name);
Alex Elderc53d5892012-10-25 23:34:42 -05004970 rbd_dev_destroy(rbd_dev);
Alex Elderbd4ba652012-10-25 23:34:42 -05004971err_out_client:
Alex Elder9d3997f2012-10-25 23:34:42 -05004972 rbd_put_client(rbdc);
Alex Elder0ddebc02012-10-25 23:34:41 -05004973err_out_args:
Alex Elder78cea762012-10-25 23:34:41 -05004974 if (ceph_opts)
4975 ceph_destroy_options(ceph_opts);
Alex Elder4e9afeba2012-10-25 23:34:41 -05004976 kfree(rbd_opts);
Alex Elder859c31d2012-10-25 23:34:42 -05004977 rbd_spec_put(spec);
Alex Elderbd4ba652012-10-25 23:34:42 -05004978err_out_module:
4979 module_put(THIS_MODULE);
Alex Elder27cc2592012-02-02 08:13:30 -06004980
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004981 dout("Error adding device %s\n", buf);
Alex Elder27cc2592012-02-02 08:13:30 -06004982
Alex Elderc0cd10db2013-04-26 09:43:47 -05004983 return (ssize_t)rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004984}
4985
Alex Elderde71a292012-07-03 16:01:19 -05004986static struct rbd_device *__rbd_get_dev(unsigned long dev_id)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004987{
4988 struct list_head *tmp;
4989 struct rbd_device *rbd_dev;
4990
Alex Eldere124a82f2012-01-29 13:57:44 -06004991 spin_lock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004992 list_for_each(tmp, &rbd_dev_list) {
4993 rbd_dev = list_entry(tmp, struct rbd_device, node);
Alex Elderde71a292012-07-03 16:01:19 -05004994 if (rbd_dev->dev_id == dev_id) {
Alex Eldere124a82f2012-01-29 13:57:44 -06004995 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004996 return rbd_dev;
Alex Eldere124a82f2012-01-29 13:57:44 -06004997 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004998 }
Alex Eldere124a82f2012-01-29 13:57:44 -06004999 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005000 return NULL;
5001}
5002
Alex Elder200a6a82013-04-28 23:32:34 -05005003static void rbd_dev_device_release(struct device *dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005004{
Alex Elder593a9e72012-02-07 12:03:37 -06005005 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005006
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005007 rbd_free_disk(rbd_dev);
Alex Elder200a6a82013-04-28 23:32:34 -05005008 clear_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags);
5009 rbd_dev_clear_mapping(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005010 unregister_blkdev(rbd_dev->major, rbd_dev->name);
Alex Elder200a6a82013-04-28 23:32:34 -05005011 rbd_dev->major = 0;
Alex Eldere2839302012-08-29 17:11:06 -05005012 rbd_dev_id_put(rbd_dev);
Alex Elderd1cf5782013-04-27 09:59:30 -05005013 rbd_dev_mapping_clear(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005014}
5015
Alex Elder05a46af2013-04-26 15:44:36 -05005016static void rbd_dev_remove_parent(struct rbd_device *rbd_dev)
5017{
Alex Elderad945fc2013-04-26 15:44:36 -05005018 while (rbd_dev->parent) {
Alex Elder05a46af2013-04-26 15:44:36 -05005019 struct rbd_device *first = rbd_dev;
5020 struct rbd_device *second = first->parent;
5021 struct rbd_device *third;
5022
5023 /*
5024 * Follow to the parent with no grandparent and
5025 * remove it.
5026 */
5027 while (second && (third = second->parent)) {
5028 first = second;
5029 second = third;
5030 }
Alex Elderad945fc2013-04-26 15:44:36 -05005031 rbd_assert(second);
Alex Elderb4808152013-04-26 15:44:36 -05005032 rbd_bus_del_dev(second);
Alex Elder8ad42cd2013-04-28 23:32:34 -05005033 rbd_dev_image_release(second);
Alex Elderad945fc2013-04-26 15:44:36 -05005034 first->parent = NULL;
5035 first->parent_overlap = 0;
5036
5037 rbd_assert(first->parent_spec);
Alex Elder05a46af2013-04-26 15:44:36 -05005038 rbd_spec_put(first->parent_spec);
5039 first->parent_spec = NULL;
Alex Elder05a46af2013-04-26 15:44:36 -05005040 }
5041}
5042
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005043static ssize_t rbd_remove(struct bus_type *bus,
5044 const char *buf,
5045 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005046{
5047 struct rbd_device *rbd_dev = NULL;
Alex Elder0d8189e2013-04-27 09:59:30 -05005048 int target_id;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005049 unsigned long ul;
Alex Elder0d8189e2013-04-27 09:59:30 -05005050 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005051
Alex Elder0d8189e2013-04-27 09:59:30 -05005052 ret = strict_strtoul(buf, 10, &ul);
5053 if (ret)
5054 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005055
5056 /* convert to int; abort if we lost anything in the conversion */
5057 target_id = (int) ul;
5058 if (target_id != ul)
5059 return -EINVAL;
5060
5061 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
5062
5063 rbd_dev = __rbd_get_dev(target_id);
5064 if (!rbd_dev) {
5065 ret = -ENOENT;
5066 goto done;
5067 }
5068
Alex Eldera14ea262013-02-05 13:23:12 -06005069 spin_lock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -06005070 if (rbd_dev->open_count)
Alex Elder42382b72012-11-16 09:29:16 -06005071 ret = -EBUSY;
Alex Elderb82d1672013-01-14 12:43:31 -06005072 else
5073 set_bit(RBD_DEV_FLAG_REMOVING, &rbd_dev->flags);
Alex Eldera14ea262013-02-05 13:23:12 -06005074 spin_unlock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -06005075 if (ret < 0)
Alex Elder42382b72012-11-16 09:29:16 -06005076 goto done;
Alex Elder0d8189e2013-04-27 09:59:30 -05005077 ret = count;
Alex Elderb4808152013-04-26 15:44:36 -05005078 rbd_bus_del_dev(rbd_dev);
Alex Elder8ad42cd2013-04-28 23:32:34 -05005079 rbd_dev_image_release(rbd_dev);
Alex Elder79ab7552013-04-28 23:32:34 -05005080 module_put(THIS_MODULE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005081done:
5082 mutex_unlock(&ctl_mutex);
Alex Elderaafb2302012-09-06 16:00:54 -05005083
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005084 return ret;
5085}
5086
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005087/*
5088 * create control files in sysfs
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005089 * /sys/bus/rbd/...
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005090 */
5091static int rbd_sysfs_init(void)
5092{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005093 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005094
Alex Elderfed4c142012-02-07 12:03:36 -06005095 ret = device_register(&rbd_root_dev);
Alex Elder21079782012-01-24 10:08:36 -06005096 if (ret < 0)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005097 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005098
Alex Elderfed4c142012-02-07 12:03:36 -06005099 ret = bus_register(&rbd_bus_type);
5100 if (ret < 0)
5101 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005102
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005103 return ret;
5104}
5105
5106static void rbd_sysfs_cleanup(void)
5107{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005108 bus_unregister(&rbd_bus_type);
Alex Elderfed4c142012-02-07 12:03:36 -06005109 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005110}
5111
Alex Eldercc344fa2013-02-19 12:25:56 -06005112static int __init rbd_init(void)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005113{
5114 int rc;
5115
Alex Elder1e32d342013-01-30 11:13:33 -06005116 if (!libceph_compatible(NULL)) {
5117 rbd_warn(NULL, "libceph incompatibility (quitting)");
5118
5119 return -EINVAL;
5120 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005121 rc = rbd_sysfs_init();
5122 if (rc)
5123 return rc;
Alex Elderf0f8cef2012-01-29 13:57:44 -06005124 pr_info("loaded " RBD_DRV_NAME_LONG "\n");
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005125 return 0;
5126}
5127
Alex Eldercc344fa2013-02-19 12:25:56 -06005128static void __exit rbd_exit(void)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005129{
5130 rbd_sysfs_cleanup();
5131}
5132
5133module_init(rbd_init);
5134module_exit(rbd_exit);
5135
5136MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
5137MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
5138MODULE_DESCRIPTION("rados block device");
5139
5140/* following authorship retained from original osdblk.c */
5141MODULE_AUTHOR("Jeff Garzik <jeff@garzik.org>");
5142
5143MODULE_LICENSE("GPL");