blob: 21468d0b2792d59ca7e35b5750290215f724e762 [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 Elderdf111be2012-08-09 10:33:26 -070055/* It might be useful to have this defined elsewhere too */
56
57#define U64_MAX ((u64) (~0ULL))
58
Alex Elderf0f8cef2012-01-29 13:57:44 -060059#define RBD_DRV_NAME "rbd"
60#define RBD_DRV_NAME_LONG "rbd (rados block device)"
Yehuda Sadeh602adf42010-08-12 16:11:25 -070061
62#define RBD_MINORS_PER_MAJOR 256 /* max minors per blkdev */
63
Alex Elderd4b125e2012-07-03 16:01:19 -050064#define RBD_SNAP_DEV_NAME_PREFIX "snap_"
65#define RBD_MAX_SNAP_NAME_LEN \
66 (NAME_MAX - (sizeof (RBD_SNAP_DEV_NAME_PREFIX) - 1))
67
Alex Elder35d489f2012-07-03 16:01:19 -050068#define RBD_MAX_SNAP_COUNT 510 /* allows max snapc to fit in 4KB */
Yehuda Sadeh602adf42010-08-12 16:11:25 -070069#define RBD_MAX_OPT_LEN 1024
70
71#define RBD_SNAP_HEAD_NAME "-"
72
Alex Elder9e15b772012-10-30 19:40:33 -050073/* This allows a single page to hold an image name sent by OSD */
74#define RBD_IMAGE_NAME_LEN_MAX (PAGE_SIZE - sizeof (__le32) - 1)
Alex Elder1e130192012-07-03 16:01:19 -050075#define RBD_IMAGE_ID_LEN_MAX 64
Alex Elder9e15b772012-10-30 19:40:33 -050076
Alex Elder1e130192012-07-03 16:01:19 -050077#define RBD_OBJ_PREFIX_LEN_MAX 64
Alex Elder589d30e2012-07-10 20:30:11 -050078
Alex Elderd8891402012-10-09 13:50:17 -070079/* Feature bits */
80
81#define RBD_FEATURE_LAYERING 1
82
83/* Features supported by this (client software) implementation. */
84
85#define RBD_FEATURES_ALL (0)
86
Alex Elder81a89792012-02-02 08:13:30 -060087/*
88 * An RBD device name will be "rbd#", where the "rbd" comes from
89 * RBD_DRV_NAME above, and # is a unique integer identifier.
90 * MAX_INT_FORMAT_WIDTH is used in ensuring DEV_NAME_LEN is big
91 * enough to hold all possible device names.
92 */
Yehuda Sadeh602adf42010-08-12 16:11:25 -070093#define DEV_NAME_LEN 32
Alex Elder81a89792012-02-02 08:13:30 -060094#define MAX_INT_FORMAT_WIDTH ((5 * sizeof (int)) / 2 + 1)
Yehuda Sadeh602adf42010-08-12 16:11:25 -070095
Alex Eldercc0538b2012-08-10 13:12:07 -070096#define RBD_READ_ONLY_DEFAULT false
Yehuda Sadeh59c2be12011-03-21 15:10:11 -070097
Yehuda Sadeh602adf42010-08-12 16:11:25 -070098/*
99 * block device image metadata (in-memory version)
100 */
101struct rbd_image_header {
Alex Elderf84344f2012-08-31 17:29:51 -0500102 /* These four fields never change for a given rbd image */
Alex Elder849b4262012-07-09 21:04:24 -0500103 char *object_prefix;
Alex Elder34b13182012-07-13 20:35:12 -0500104 u64 features;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700105 __u8 obj_order;
106 __u8 crypt_type;
107 __u8 comp_type;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700108
Alex Elderf84344f2012-08-31 17:29:51 -0500109 /* The remaining fields need to be updated occasionally */
110 u64 image_size;
111 struct ceph_snap_context *snapc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700112 char *snap_names;
113 u64 *snap_sizes;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700114
115 u64 obj_version;
116};
117
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500118/*
119 * An rbd image specification.
120 *
121 * The tuple (pool_id, image_id, snap_id) is sufficient to uniquely
Alex Elderc66c6e02012-11-01 08:39:26 -0500122 * identify an image. Each rbd_dev structure includes a pointer to
123 * an rbd_spec structure that encapsulates this identity.
124 *
125 * Each of the id's in an rbd_spec has an associated name. For a
126 * user-mapped image, the names are supplied and the id's associated
127 * with them are looked up. For a layered image, a parent image is
128 * defined by the tuple, and the names are looked up.
129 *
130 * An rbd_dev structure contains a parent_spec pointer which is
131 * non-null if the image it represents is a child in a layered
132 * image. This pointer will refer to the rbd_spec structure used
133 * by the parent rbd_dev for its own identity (i.e., the structure
134 * is shared between the parent and child).
135 *
136 * Since these structures are populated once, during the discovery
137 * phase of image construction, they are effectively immutable so
138 * we make no effort to synchronize access to them.
139 *
140 * Note that code herein does not assume the image name is known (it
141 * could be a null pointer).
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500142 */
143struct rbd_spec {
144 u64 pool_id;
145 char *pool_name;
146
147 char *image_id;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500148 char *image_name;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500149
150 u64 snap_id;
151 char *snap_name;
152
153 struct kref kref;
154};
155
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700156struct rbd_options {
Alex Eldercc0538b2012-08-10 13:12:07 -0700157 bool read_only;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700158};
159
160/*
Alex Elderf0f8cef2012-01-29 13:57:44 -0600161 * an instance of the client. multiple devices may share an rbd client.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700162 */
163struct rbd_client {
164 struct ceph_client *client;
165 struct kref kref;
166 struct list_head node;
167};
168
169/*
Alex Elderf0f8cef2012-01-29 13:57:44 -0600170 * a request completion status
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700171 */
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700172struct rbd_req_status {
173 int done;
Alex Elder8986cb32012-11-08 08:01:39 -0600174 s32 rc;
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700175 u64 bytes;
176};
177
178/*
179 * a collection of requests
180 */
181struct rbd_req_coll {
182 int total;
183 int num_done;
184 struct kref kref;
185 struct rbd_req_status status[0];
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700186};
187
Alex Elderf0f8cef2012-01-29 13:57:44 -0600188/*
189 * a single io request
190 */
191struct rbd_request {
192 struct request *rq; /* blk layer request */
193 struct bio *bio; /* cloned bio */
194 struct page **pages; /* list of used pages */
195 u64 len;
196 int coll_index;
197 struct rbd_req_coll *coll;
198};
199
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800200struct rbd_snap {
201 struct device dev;
202 const char *name;
Josh Durgin3591538f2011-12-05 18:25:13 -0800203 u64 size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800204 struct list_head node;
205 u64 id;
Alex Elder34b13182012-07-13 20:35:12 -0500206 u64 features;
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800207};
208
Alex Elderf84344f2012-08-31 17:29:51 -0500209struct rbd_mapping {
Alex Elder99c1f082012-08-30 14:42:15 -0500210 u64 size;
Alex Elder34b13182012-07-13 20:35:12 -0500211 u64 features;
Alex Elderf84344f2012-08-31 17:29:51 -0500212 bool read_only;
213};
214
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700215/*
216 * a single device
217 */
218struct rbd_device {
Alex Elderde71a292012-07-03 16:01:19 -0500219 int dev_id; /* blkdev unique id */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700220
221 int major; /* blkdev assigned major */
222 struct gendisk *disk; /* blkdev's gendisk and rq */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700223
Alex Eldera30b71b2012-07-10 20:30:11 -0500224 u32 image_format; /* Either 1 or 2 */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700225 struct rbd_client *rbd_client;
226
227 char name[DEV_NAME_LEN]; /* blkdev name, e.g. rbd3 */
228
229 spinlock_t lock; /* queue lock */
230
231 struct rbd_image_header header;
Alex Elderdaba5fd2012-10-26 17:25:23 -0500232 bool exists;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500233 struct rbd_spec *spec;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700234
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500235 char *header_name;
Alex Elder971f8392012-10-25 23:34:41 -0500236
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700237 struct ceph_osd_event *watch_event;
238 struct ceph_osd_request *watch_request;
239
Alex Elder86b00e02012-10-25 23:34:42 -0500240 struct rbd_spec *parent_spec;
241 u64 parent_overlap;
242
Josh Durginc6666012011-11-21 17:11:12 -0800243 /* protects updating the header */
244 struct rw_semaphore header_rwsem;
Alex Elderf84344f2012-08-31 17:29:51 -0500245
246 struct rbd_mapping mapping;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700247
248 struct list_head node;
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800249
250 /* list of snapshots */
251 struct list_head snaps;
252
253 /* sysfs related */
254 struct device dev;
Alex Elder42382b72012-11-16 09:29:16 -0600255 unsigned long open_count;
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800256};
257
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700258static DEFINE_MUTEX(ctl_mutex); /* Serialize open/close/setup/teardown */
Alex Eldere124a82f2012-01-29 13:57:44 -0600259
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700260static LIST_HEAD(rbd_dev_list); /* devices */
Alex Eldere124a82f2012-01-29 13:57:44 -0600261static DEFINE_SPINLOCK(rbd_dev_list_lock);
262
Alex Elder432b8582012-01-29 13:57:44 -0600263static LIST_HEAD(rbd_client_list); /* clients */
264static DEFINE_SPINLOCK(rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700265
Alex Elder304f6802012-08-31 17:29:52 -0500266static int rbd_dev_snaps_update(struct rbd_device *rbd_dev);
267static int rbd_dev_snaps_register(struct rbd_device *rbd_dev);
268
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800269static void rbd_dev_release(struct device *dev);
Alex Elder41f38c22012-10-25 23:34:40 -0500270static void rbd_remove_snap_dev(struct rbd_snap *snap);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800271
Alex Elderf0f8cef2012-01-29 13:57:44 -0600272static ssize_t rbd_add(struct bus_type *bus, const char *buf,
273 size_t count);
274static ssize_t rbd_remove(struct bus_type *bus, const char *buf,
275 size_t count);
276
277static struct bus_attribute rbd_bus_attrs[] = {
278 __ATTR(add, S_IWUSR, NULL, rbd_add),
279 __ATTR(remove, S_IWUSR, NULL, rbd_remove),
280 __ATTR_NULL
281};
282
283static struct bus_type rbd_bus_type = {
284 .name = "rbd",
285 .bus_attrs = rbd_bus_attrs,
286};
287
288static void rbd_root_dev_release(struct device *dev)
289{
290}
291
292static struct device rbd_root_dev = {
293 .init_name = "rbd",
294 .release = rbd_root_dev_release,
295};
296
Alex Elder06ecc6c2012-11-01 10:17:15 -0500297static __printf(2, 3)
298void rbd_warn(struct rbd_device *rbd_dev, const char *fmt, ...)
299{
300 struct va_format vaf;
301 va_list args;
302
303 va_start(args, fmt);
304 vaf.fmt = fmt;
305 vaf.va = &args;
306
307 if (!rbd_dev)
308 printk(KERN_WARNING "%s: %pV\n", RBD_DRV_NAME, &vaf);
309 else if (rbd_dev->disk)
310 printk(KERN_WARNING "%s: %s: %pV\n",
311 RBD_DRV_NAME, rbd_dev->disk->disk_name, &vaf);
312 else if (rbd_dev->spec && rbd_dev->spec->image_name)
313 printk(KERN_WARNING "%s: image %s: %pV\n",
314 RBD_DRV_NAME, rbd_dev->spec->image_name, &vaf);
315 else if (rbd_dev->spec && rbd_dev->spec->image_id)
316 printk(KERN_WARNING "%s: id %s: %pV\n",
317 RBD_DRV_NAME, rbd_dev->spec->image_id, &vaf);
318 else /* punt */
319 printk(KERN_WARNING "%s: rbd_dev %p: %pV\n",
320 RBD_DRV_NAME, rbd_dev, &vaf);
321 va_end(args);
322}
323
Alex Elderaafb2302012-09-06 16:00:54 -0500324#ifdef RBD_DEBUG
325#define rbd_assert(expr) \
326 if (unlikely(!(expr))) { \
327 printk(KERN_ERR "\nAssertion failure in %s() " \
328 "at line %d:\n\n" \
329 "\trbd_assert(%s);\n\n", \
330 __func__, __LINE__, #expr); \
331 BUG(); \
332 }
333#else /* !RBD_DEBUG */
334# define rbd_assert(expr) ((void) 0)
335#endif /* !RBD_DEBUG */
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800336
Alex Elder117973f2012-08-31 17:29:55 -0500337static int rbd_dev_refresh(struct rbd_device *rbd_dev, u64 *hver);
338static int rbd_dev_v2_refresh(struct rbd_device *rbd_dev, u64 *hver);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700339
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700340static int rbd_open(struct block_device *bdev, fmode_t mode)
341{
Alex Elderf0f8cef2012-01-29 13:57:44 -0600342 struct rbd_device *rbd_dev = bdev->bd_disk->private_data;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700343
Alex Elderf84344f2012-08-31 17:29:51 -0500344 if ((mode & FMODE_WRITE) && rbd_dev->mapping.read_only)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700345 return -EROFS;
346
Alex Elder42382b72012-11-16 09:29:16 -0600347 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Alex Elderc3e946c2012-11-16 09:29:16 -0600348 (void) get_device(&rbd_dev->dev);
Alex Elderf84344f2012-08-31 17:29:51 -0500349 set_device_ro(bdev, rbd_dev->mapping.read_only);
Alex Elder42382b72012-11-16 09:29:16 -0600350 rbd_dev->open_count++;
351 mutex_unlock(&ctl_mutex);
Alex Elder340c7a22012-08-10 13:12:07 -0700352
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700353 return 0;
354}
355
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800356static int rbd_release(struct gendisk *disk, fmode_t mode)
357{
358 struct rbd_device *rbd_dev = disk->private_data;
359
Alex Elder42382b72012-11-16 09:29:16 -0600360 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
361 rbd_assert(rbd_dev->open_count > 0);
362 rbd_dev->open_count--;
Alex Elderc3e946c2012-11-16 09:29:16 -0600363 put_device(&rbd_dev->dev);
Alex Elder42382b72012-11-16 09:29:16 -0600364 mutex_unlock(&ctl_mutex);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800365
366 return 0;
367}
368
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700369static const struct block_device_operations rbd_bd_ops = {
370 .owner = THIS_MODULE,
371 .open = rbd_open,
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800372 .release = rbd_release,
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700373};
374
375/*
376 * Initialize an rbd client instance.
Alex Elder43ae4702012-07-03 16:01:18 -0500377 * We own *ceph_opts.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700378 */
Alex Elderf8c38922012-08-10 13:12:07 -0700379static struct rbd_client *rbd_client_create(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700380{
381 struct rbd_client *rbdc;
382 int ret = -ENOMEM;
383
384 dout("rbd_client_create\n");
385 rbdc = kmalloc(sizeof(struct rbd_client), GFP_KERNEL);
386 if (!rbdc)
387 goto out_opt;
388
389 kref_init(&rbdc->kref);
390 INIT_LIST_HEAD(&rbdc->node);
391
Alex Elderbc534d82012-01-29 13:57:44 -0600392 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
393
Alex Elder43ae4702012-07-03 16:01:18 -0500394 rbdc->client = ceph_create_client(ceph_opts, rbdc, 0, 0);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700395 if (IS_ERR(rbdc->client))
Alex Elderbc534d82012-01-29 13:57:44 -0600396 goto out_mutex;
Alex Elder43ae4702012-07-03 16:01:18 -0500397 ceph_opts = NULL; /* Now rbdc->client is responsible for ceph_opts */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700398
399 ret = ceph_open_session(rbdc->client);
400 if (ret < 0)
401 goto out_err;
402
Alex Elder432b8582012-01-29 13:57:44 -0600403 spin_lock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700404 list_add_tail(&rbdc->node, &rbd_client_list);
Alex Elder432b8582012-01-29 13:57:44 -0600405 spin_unlock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700406
Alex Elderbc534d82012-01-29 13:57:44 -0600407 mutex_unlock(&ctl_mutex);
408
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700409 dout("rbd_client_create created %p\n", rbdc);
410 return rbdc;
411
412out_err:
413 ceph_destroy_client(rbdc->client);
Alex Elderbc534d82012-01-29 13:57:44 -0600414out_mutex:
415 mutex_unlock(&ctl_mutex);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700416 kfree(rbdc);
417out_opt:
Alex Elder43ae4702012-07-03 16:01:18 -0500418 if (ceph_opts)
419 ceph_destroy_options(ceph_opts);
Vasiliy Kulikov28f259b2010-09-26 12:59:37 +0400420 return ERR_PTR(ret);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700421}
422
423/*
Alex Elder1f7ba332012-08-10 13:12:07 -0700424 * Find a ceph client with specific addr and configuration. If
425 * found, bump its reference count.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700426 */
Alex Elder1f7ba332012-08-10 13:12:07 -0700427static struct rbd_client *rbd_client_find(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700428{
429 struct rbd_client *client_node;
Alex Elder1f7ba332012-08-10 13:12:07 -0700430 bool found = false;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700431
Alex Elder43ae4702012-07-03 16:01:18 -0500432 if (ceph_opts->flags & CEPH_OPT_NOSHARE)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700433 return NULL;
434
Alex Elder1f7ba332012-08-10 13:12:07 -0700435 spin_lock(&rbd_client_list_lock);
436 list_for_each_entry(client_node, &rbd_client_list, node) {
437 if (!ceph_compare_options(ceph_opts, client_node->client)) {
438 kref_get(&client_node->kref);
439 found = true;
440 break;
441 }
442 }
443 spin_unlock(&rbd_client_list_lock);
444
445 return found ? client_node : NULL;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700446}
447
448/*
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700449 * mount options
450 */
451enum {
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700452 Opt_last_int,
453 /* int args above */
454 Opt_last_string,
455 /* string args above */
Alex Eldercc0538b2012-08-10 13:12:07 -0700456 Opt_read_only,
457 Opt_read_write,
458 /* Boolean args above */
459 Opt_last_bool,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700460};
461
Alex Elder43ae4702012-07-03 16:01:18 -0500462static match_table_t rbd_opts_tokens = {
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700463 /* int args above */
464 /* string args above */
Alex Elderbe466c12012-10-22 11:31:26 -0500465 {Opt_read_only, "read_only"},
Alex Eldercc0538b2012-08-10 13:12:07 -0700466 {Opt_read_only, "ro"}, /* Alternate spelling */
467 {Opt_read_write, "read_write"},
468 {Opt_read_write, "rw"}, /* Alternate spelling */
469 /* Boolean args above */
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700470 {-1, NULL}
471};
472
473static int parse_rbd_opts_token(char *c, void *private)
474{
Alex Elder43ae4702012-07-03 16:01:18 -0500475 struct rbd_options *rbd_opts = private;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700476 substring_t argstr[MAX_OPT_ARGS];
477 int token, intval, ret;
478
Alex Elder43ae4702012-07-03 16:01:18 -0500479 token = match_token(c, rbd_opts_tokens, argstr);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700480 if (token < 0)
481 return -EINVAL;
482
483 if (token < Opt_last_int) {
484 ret = match_int(&argstr[0], &intval);
485 if (ret < 0) {
486 pr_err("bad mount option arg (not int) "
487 "at '%s'\n", c);
488 return ret;
489 }
490 dout("got int token %d val %d\n", token, intval);
491 } else if (token > Opt_last_int && token < Opt_last_string) {
492 dout("got string token %d val %s\n", token,
493 argstr[0].from);
Alex Eldercc0538b2012-08-10 13:12:07 -0700494 } else if (token > Opt_last_string && token < Opt_last_bool) {
495 dout("got Boolean token %d\n", token);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700496 } else {
497 dout("got token %d\n", token);
498 }
499
500 switch (token) {
Alex Eldercc0538b2012-08-10 13:12:07 -0700501 case Opt_read_only:
502 rbd_opts->read_only = true;
503 break;
504 case Opt_read_write:
505 rbd_opts->read_only = false;
506 break;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700507 default:
Alex Elderaafb2302012-09-06 16:00:54 -0500508 rbd_assert(false);
509 break;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700510 }
511 return 0;
512}
513
514/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700515 * Get a ceph client with specific addr and configuration, if one does
516 * not exist create it.
517 */
Alex Elder9d3997f2012-10-25 23:34:42 -0500518static struct rbd_client *rbd_get_client(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700519{
Alex Elderf8c38922012-08-10 13:12:07 -0700520 struct rbd_client *rbdc;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700521
Alex Elder1f7ba332012-08-10 13:12:07 -0700522 rbdc = rbd_client_find(ceph_opts);
Alex Elder9d3997f2012-10-25 23:34:42 -0500523 if (rbdc) /* using an existing client */
Alex Elder43ae4702012-07-03 16:01:18 -0500524 ceph_destroy_options(ceph_opts);
Alex Elder9d3997f2012-10-25 23:34:42 -0500525 else
Alex Elderf8c38922012-08-10 13:12:07 -0700526 rbdc = rbd_client_create(ceph_opts);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700527
Alex Elder9d3997f2012-10-25 23:34:42 -0500528 return rbdc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700529}
530
531/*
532 * Destroy ceph client
Alex Elderd23a4b32012-01-29 13:57:43 -0600533 *
Alex Elder432b8582012-01-29 13:57:44 -0600534 * Caller must hold rbd_client_list_lock.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700535 */
536static void rbd_client_release(struct kref *kref)
537{
538 struct rbd_client *rbdc = container_of(kref, struct rbd_client, kref);
539
540 dout("rbd_release_client %p\n", rbdc);
Alex Eldercd9d9f52012-04-04 13:35:44 -0500541 spin_lock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700542 list_del(&rbdc->node);
Alex Eldercd9d9f52012-04-04 13:35:44 -0500543 spin_unlock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700544
545 ceph_destroy_client(rbdc->client);
546 kfree(rbdc);
547}
548
549/*
550 * Drop reference to ceph client node. If it's not referenced anymore, release
551 * it.
552 */
Alex Elder9d3997f2012-10-25 23:34:42 -0500553static void rbd_put_client(struct rbd_client *rbdc)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700554{
Alex Elderc53d5892012-10-25 23:34:42 -0500555 if (rbdc)
556 kref_put(&rbdc->kref, rbd_client_release);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700557}
558
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700559/*
560 * Destroy requests collection
561 */
562static void rbd_coll_release(struct kref *kref)
563{
564 struct rbd_req_coll *coll =
565 container_of(kref, struct rbd_req_coll, kref);
566
567 dout("rbd_coll_release %p\n", coll);
568 kfree(coll);
569}
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700570
Alex Eldera30b71b2012-07-10 20:30:11 -0500571static bool rbd_image_format_valid(u32 image_format)
572{
573 return image_format == 1 || image_format == 2;
574}
575
Alex Elder8e94af82012-07-25 09:32:40 -0500576static bool rbd_dev_ondisk_valid(struct rbd_image_header_ondisk *ondisk)
577{
Alex Elder103a1502012-08-02 11:29:45 -0500578 size_t size;
579 u32 snap_count;
580
581 /* The header has to start with the magic rbd header text */
582 if (memcmp(&ondisk->text, RBD_HEADER_TEXT, sizeof (RBD_HEADER_TEXT)))
583 return false;
584
Alex Elderdb2388b2012-10-20 22:17:27 -0500585 /* The bio layer requires at least sector-sized I/O */
586
587 if (ondisk->options.order < SECTOR_SHIFT)
588 return false;
589
590 /* If we use u64 in a few spots we may be able to loosen this */
591
592 if (ondisk->options.order > 8 * sizeof (int) - 1)
593 return false;
594
Alex Elder103a1502012-08-02 11:29:45 -0500595 /*
596 * The size of a snapshot header has to fit in a size_t, and
597 * that limits the number of snapshots.
598 */
599 snap_count = le32_to_cpu(ondisk->snap_count);
600 size = SIZE_MAX - sizeof (struct ceph_snap_context);
601 if (snap_count > size / sizeof (__le64))
602 return false;
603
604 /*
605 * Not only that, but the size of the entire the snapshot
606 * header must also be representable in a size_t.
607 */
608 size -= snap_count * sizeof (__le64);
609 if ((u64) size < le64_to_cpu(ondisk->snap_names_len))
610 return false;
611
612 return true;
Alex Elder8e94af82012-07-25 09:32:40 -0500613}
614
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700615/*
616 * Create a new header structure, translate header format from the on-disk
617 * header.
618 */
619static int rbd_header_from_disk(struct rbd_image_header *header,
Alex Elder4156d992012-08-02 11:29:46 -0500620 struct rbd_image_header_ondisk *ondisk)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700621{
Alex Elderccece232012-07-10 20:30:10 -0500622 u32 snap_count;
Alex Elder58c17b02012-08-23 23:22:06 -0500623 size_t len;
Alex Elderd2bb24e2012-07-26 23:37:14 -0500624 size_t size;
Alex Elder621901d2012-08-23 23:22:06 -0500625 u32 i;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700626
Alex Elder6a523252012-07-19 17:12:59 -0500627 memset(header, 0, sizeof (*header));
628
Alex Elder103a1502012-08-02 11:29:45 -0500629 snap_count = le32_to_cpu(ondisk->snap_count);
630
Alex Elder58c17b02012-08-23 23:22:06 -0500631 len = strnlen(ondisk->object_prefix, sizeof (ondisk->object_prefix));
632 header->object_prefix = kmalloc(len + 1, GFP_KERNEL);
Alex Elder6a523252012-07-19 17:12:59 -0500633 if (!header->object_prefix)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700634 return -ENOMEM;
Alex Elder58c17b02012-08-23 23:22:06 -0500635 memcpy(header->object_prefix, ondisk->object_prefix, len);
636 header->object_prefix[len] = '\0';
Alex Elder00f1f362012-02-07 12:03:36 -0600637
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700638 if (snap_count) {
Alex Elderf785cc12012-08-23 23:22:06 -0500639 u64 snap_names_len = le64_to_cpu(ondisk->snap_names_len);
640
Alex Elder621901d2012-08-23 23:22:06 -0500641 /* Save a copy of the snapshot names */
642
Alex Elderf785cc12012-08-23 23:22:06 -0500643 if (snap_names_len > (u64) SIZE_MAX)
644 return -EIO;
645 header->snap_names = kmalloc(snap_names_len, GFP_KERNEL);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700646 if (!header->snap_names)
Alex Elder6a523252012-07-19 17:12:59 -0500647 goto out_err;
Alex Elderf785cc12012-08-23 23:22:06 -0500648 /*
649 * Note that rbd_dev_v1_header_read() guarantees
650 * the ondisk buffer we're working with has
651 * snap_names_len bytes beyond the end of the
652 * snapshot id array, this memcpy() is safe.
653 */
654 memcpy(header->snap_names, &ondisk->snaps[snap_count],
655 snap_names_len);
Alex Elder6a523252012-07-19 17:12:59 -0500656
Alex Elder621901d2012-08-23 23:22:06 -0500657 /* Record each snapshot's size */
658
Alex Elderd2bb24e2012-07-26 23:37:14 -0500659 size = snap_count * sizeof (*header->snap_sizes);
660 header->snap_sizes = kmalloc(size, GFP_KERNEL);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700661 if (!header->snap_sizes)
Alex Elder6a523252012-07-19 17:12:59 -0500662 goto out_err;
Alex Elder621901d2012-08-23 23:22:06 -0500663 for (i = 0; i < snap_count; i++)
664 header->snap_sizes[i] =
665 le64_to_cpu(ondisk->snaps[i].image_size);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700666 } else {
Alex Elderccece232012-07-10 20:30:10 -0500667 WARN_ON(ondisk->snap_names_len);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700668 header->snap_names = NULL;
669 header->snap_sizes = NULL;
670 }
Alex Elder849b4262012-07-09 21:04:24 -0500671
Alex Elder34b13182012-07-13 20:35:12 -0500672 header->features = 0; /* No features support in v1 images */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700673 header->obj_order = ondisk->options.order;
674 header->crypt_type = ondisk->options.crypt_type;
675 header->comp_type = ondisk->options.comp_type;
Alex Elder6a523252012-07-19 17:12:59 -0500676
Alex Elder621901d2012-08-23 23:22:06 -0500677 /* Allocate and fill in the snapshot context */
678
Alex Elderf84344f2012-08-31 17:29:51 -0500679 header->image_size = le64_to_cpu(ondisk->image_size);
Alex Elder6a523252012-07-19 17:12:59 -0500680 size = sizeof (struct ceph_snap_context);
681 size += snap_count * sizeof (header->snapc->snaps[0]);
682 header->snapc = kzalloc(size, GFP_KERNEL);
683 if (!header->snapc)
684 goto out_err;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700685
686 atomic_set(&header->snapc->nref, 1);
Alex Elder505cbb92012-07-19 08:49:18 -0500687 header->snapc->seq = le64_to_cpu(ondisk->snap_seq);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700688 header->snapc->num_snaps = snap_count;
Alex Elder621901d2012-08-23 23:22:06 -0500689 for (i = 0; i < snap_count; i++)
690 header->snapc->snaps[i] =
691 le64_to_cpu(ondisk->snaps[i].id);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700692
693 return 0;
694
Alex Elder6a523252012-07-19 17:12:59 -0500695out_err:
Alex Elder849b4262012-07-09 21:04:24 -0500696 kfree(header->snap_sizes);
Alex Elderccece232012-07-10 20:30:10 -0500697 header->snap_sizes = NULL;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700698 kfree(header->snap_names);
Alex Elderccece232012-07-10 20:30:10 -0500699 header->snap_names = NULL;
Alex Elder6a523252012-07-19 17:12:59 -0500700 kfree(header->object_prefix);
701 header->object_prefix = NULL;
Alex Elderccece232012-07-10 20:30:10 -0500702
Alex Elder00f1f362012-02-07 12:03:36 -0600703 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700704}
705
Alex Elder9e15b772012-10-30 19:40:33 -0500706static const char *rbd_snap_name(struct rbd_device *rbd_dev, u64 snap_id)
707{
708 struct rbd_snap *snap;
709
710 if (snap_id == CEPH_NOSNAP)
711 return RBD_SNAP_HEAD_NAME;
712
713 list_for_each_entry(snap, &rbd_dev->snaps, node)
714 if (snap_id == snap->id)
715 return snap->name;
716
717 return NULL;
718}
719
Alex Elder8836b992012-08-30 14:42:15 -0500720static int snap_by_name(struct rbd_device *rbd_dev, const char *snap_name)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700721{
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700722
Alex Eldere86924a2012-07-10 20:30:11 -0500723 struct rbd_snap *snap;
Alex Elder00f1f362012-02-07 12:03:36 -0600724
Alex Eldere86924a2012-07-10 20:30:11 -0500725 list_for_each_entry(snap, &rbd_dev->snaps, node) {
726 if (!strcmp(snap_name, snap->name)) {
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500727 rbd_dev->spec->snap_id = snap->id;
Alex Eldere86924a2012-07-10 20:30:11 -0500728 rbd_dev->mapping.size = snap->size;
Alex Elder34b13182012-07-13 20:35:12 -0500729 rbd_dev->mapping.features = snap->features;
Alex Elder00f1f362012-02-07 12:03:36 -0600730
Alex Eldere86924a2012-07-10 20:30:11 -0500731 return 0;
Alex Elder00f1f362012-02-07 12:03:36 -0600732 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700733 }
Alex Eldere86924a2012-07-10 20:30:11 -0500734
Alex Elder00f1f362012-02-07 12:03:36 -0600735 return -ENOENT;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700736}
737
Alex Elder819d52b2012-10-25 23:34:41 -0500738static int rbd_dev_set_mapping(struct rbd_device *rbd_dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700739{
Alex Elder78dc4472012-07-19 08:49:18 -0500740 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700741
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500742 if (!memcmp(rbd_dev->spec->snap_name, RBD_SNAP_HEAD_NAME,
Josh Durgincc9d7342011-11-21 18:19:13 -0800743 sizeof (RBD_SNAP_HEAD_NAME))) {
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500744 rbd_dev->spec->snap_id = CEPH_NOSNAP;
Alex Elder99c1f082012-08-30 14:42:15 -0500745 rbd_dev->mapping.size = rbd_dev->header.image_size;
Alex Elder34b13182012-07-13 20:35:12 -0500746 rbd_dev->mapping.features = rbd_dev->header.features;
Alex Eldere86924a2012-07-10 20:30:11 -0500747 ret = 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700748 } else {
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500749 ret = snap_by_name(rbd_dev, rbd_dev->spec->snap_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700750 if (ret < 0)
751 goto done;
Alex Elderf84344f2012-08-31 17:29:51 -0500752 rbd_dev->mapping.read_only = true;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700753 }
Alex Elderdaba5fd2012-10-26 17:25:23 -0500754 rbd_dev->exists = true;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700755done:
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700756 return ret;
757}
758
759static void rbd_header_free(struct rbd_image_header *header)
760{
Alex Elder849b4262012-07-09 21:04:24 -0500761 kfree(header->object_prefix);
Alex Elderd78fd7a2012-07-26 23:37:14 -0500762 header->object_prefix = NULL;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700763 kfree(header->snap_sizes);
Alex Elderd78fd7a2012-07-26 23:37:14 -0500764 header->snap_sizes = NULL;
Alex Elder849b4262012-07-09 21:04:24 -0500765 kfree(header->snap_names);
Alex Elderd78fd7a2012-07-26 23:37:14 -0500766 header->snap_names = NULL;
Josh Durgind1d25642011-12-05 14:03:05 -0800767 ceph_put_snap_context(header->snapc);
Alex Elderd78fd7a2012-07-26 23:37:14 -0500768 header->snapc = NULL;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700769}
770
Alex Elder65ccfe22012-08-09 10:33:26 -0700771static char *rbd_segment_name(struct rbd_device *rbd_dev, u64 offset)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700772{
Alex Elder65ccfe22012-08-09 10:33:26 -0700773 char *name;
774 u64 segment;
775 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700776
Alex Elder2fd82b92012-11-09 15:05:54 -0600777 name = kmalloc(MAX_OBJ_NAME_SIZE + 1, GFP_NOIO);
Alex Elder65ccfe22012-08-09 10:33:26 -0700778 if (!name)
779 return NULL;
780 segment = offset >> rbd_dev->header.obj_order;
Alex Elder2fd82b92012-11-09 15:05:54 -0600781 ret = snprintf(name, MAX_OBJ_NAME_SIZE + 1, "%s.%012llx",
Alex Elder65ccfe22012-08-09 10:33:26 -0700782 rbd_dev->header.object_prefix, segment);
Alex Elder2fd82b92012-11-09 15:05:54 -0600783 if (ret < 0 || ret > MAX_OBJ_NAME_SIZE) {
Alex Elder65ccfe22012-08-09 10:33:26 -0700784 pr_err("error formatting segment name for #%llu (%d)\n",
785 segment, ret);
786 kfree(name);
787 name = NULL;
788 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700789
Alex Elder65ccfe22012-08-09 10:33:26 -0700790 return name;
791}
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700792
Alex Elder65ccfe22012-08-09 10:33:26 -0700793static u64 rbd_segment_offset(struct rbd_device *rbd_dev, u64 offset)
794{
795 u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700796
Alex Elder65ccfe22012-08-09 10:33:26 -0700797 return offset & (segment_size - 1);
798}
799
800static u64 rbd_segment_length(struct rbd_device *rbd_dev,
801 u64 offset, u64 length)
802{
803 u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
804
805 offset &= segment_size - 1;
806
Alex Elderaafb2302012-09-06 16:00:54 -0500807 rbd_assert(length <= U64_MAX - offset);
Alex Elder65ccfe22012-08-09 10:33:26 -0700808 if (offset + length > segment_size)
809 length = segment_size - offset;
810
811 return length;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700812}
813
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700814static int rbd_get_num_segments(struct rbd_image_header *header,
815 u64 ofs, u64 len)
816{
Alex Elderdf111be2012-08-09 10:33:26 -0700817 u64 start_seg;
818 u64 end_seg;
819
820 if (!len)
821 return 0;
822 if (len - 1 > U64_MAX - ofs)
823 return -ERANGE;
824
825 start_seg = ofs >> header->obj_order;
826 end_seg = (ofs + len - 1) >> header->obj_order;
827
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700828 return end_seg - start_seg + 1;
829}
830
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700831/*
Josh Durgin029bcbd2011-07-22 11:35:23 -0700832 * returns the size of an object in the image
833 */
834static u64 rbd_obj_bytes(struct rbd_image_header *header)
835{
836 return 1 << header->obj_order;
837}
838
839/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700840 * bio helpers
841 */
842
843static void bio_chain_put(struct bio *chain)
844{
845 struct bio *tmp;
846
847 while (chain) {
848 tmp = chain;
849 chain = chain->bi_next;
850 bio_put(tmp);
851 }
852}
853
854/*
855 * zeros a bio chain, starting at specific offset
856 */
857static void zero_bio_chain(struct bio *chain, int start_ofs)
858{
859 struct bio_vec *bv;
860 unsigned long flags;
861 void *buf;
862 int i;
863 int pos = 0;
864
865 while (chain) {
866 bio_for_each_segment(bv, chain, i) {
867 if (pos + bv->bv_len > start_ofs) {
868 int remainder = max(start_ofs - pos, 0);
869 buf = bvec_kmap_irq(bv, &flags);
870 memset(buf + remainder, 0,
871 bv->bv_len - remainder);
Dan Carpenter85b5aaa2010-10-11 21:15:11 +0200872 bvec_kunmap_irq(buf, &flags);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700873 }
874 pos += bv->bv_len;
875 }
876
877 chain = chain->bi_next;
878 }
879}
880
881/*
Alex Elderf7760da2012-10-20 22:17:27 -0500882 * Clone a portion of a bio, starting at the given byte offset
883 * and continuing for the number of bytes indicated.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700884 */
Alex Elderf7760da2012-10-20 22:17:27 -0500885static struct bio *bio_clone_range(struct bio *bio_src,
886 unsigned int offset,
887 unsigned int len,
888 gfp_t gfpmask)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700889{
Alex Elderf7760da2012-10-20 22:17:27 -0500890 struct bio_vec *bv;
891 unsigned int resid;
892 unsigned short idx;
893 unsigned int voff;
894 unsigned short end_idx;
895 unsigned short vcnt;
896 struct bio *bio;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700897
Alex Elderf7760da2012-10-20 22:17:27 -0500898 /* Handle the easy case for the caller */
899
900 if (!offset && len == bio_src->bi_size)
901 return bio_clone(bio_src, gfpmask);
902
903 if (WARN_ON_ONCE(!len))
904 return NULL;
905 if (WARN_ON_ONCE(len > bio_src->bi_size))
906 return NULL;
907 if (WARN_ON_ONCE(offset > bio_src->bi_size - len))
908 return NULL;
909
910 /* Find first affected segment... */
911
912 resid = offset;
913 __bio_for_each_segment(bv, bio_src, idx, 0) {
914 if (resid < bv->bv_len)
915 break;
916 resid -= bv->bv_len;
917 }
918 voff = resid;
919
920 /* ...and the last affected segment */
921
922 resid += len;
923 __bio_for_each_segment(bv, bio_src, end_idx, idx) {
924 if (resid <= bv->bv_len)
925 break;
926 resid -= bv->bv_len;
927 }
928 vcnt = end_idx - idx + 1;
929
930 /* Build the clone */
931
932 bio = bio_alloc(gfpmask, (unsigned int) vcnt);
933 if (!bio)
934 return NULL; /* ENOMEM */
935
936 bio->bi_bdev = bio_src->bi_bdev;
937 bio->bi_sector = bio_src->bi_sector + (offset >> SECTOR_SHIFT);
938 bio->bi_rw = bio_src->bi_rw;
939 bio->bi_flags |= 1 << BIO_CLONED;
940
941 /*
942 * Copy over our part of the bio_vec, then update the first
943 * and last (or only) entries.
944 */
945 memcpy(&bio->bi_io_vec[0], &bio_src->bi_io_vec[idx],
946 vcnt * sizeof (struct bio_vec));
947 bio->bi_io_vec[0].bv_offset += voff;
948 if (vcnt > 1) {
949 bio->bi_io_vec[0].bv_len -= voff;
950 bio->bi_io_vec[vcnt - 1].bv_len = resid;
951 } else {
952 bio->bi_io_vec[0].bv_len = len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700953 }
954
Alex Elderf7760da2012-10-20 22:17:27 -0500955 bio->bi_vcnt = vcnt;
956 bio->bi_size = len;
957 bio->bi_idx = 0;
Alex Elder542582f2012-08-09 10:33:25 -0700958
Alex Elderf7760da2012-10-20 22:17:27 -0500959 return bio;
960}
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700961
Alex Elderf7760da2012-10-20 22:17:27 -0500962/*
963 * Clone a portion of a bio chain, starting at the given byte offset
964 * into the first bio in the source chain and continuing for the
965 * number of bytes indicated. The result is another bio chain of
966 * exactly the given length, or a null pointer on error.
967 *
968 * The bio_src and offset parameters are both in-out. On entry they
969 * refer to the first source bio and the offset into that bio where
970 * the start of data to be cloned is located.
971 *
972 * On return, bio_src is updated to refer to the bio in the source
973 * chain that contains first un-cloned byte, and *offset will
974 * contain the offset of that byte within that bio.
975 */
976static struct bio *bio_chain_clone_range(struct bio **bio_src,
977 unsigned int *offset,
978 unsigned int len,
979 gfp_t gfpmask)
980{
981 struct bio *bi = *bio_src;
982 unsigned int off = *offset;
983 struct bio *chain = NULL;
984 struct bio **end;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700985
Alex Elderf7760da2012-10-20 22:17:27 -0500986 /* Build up a chain of clone bios up to the limit */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700987
Alex Elderf7760da2012-10-20 22:17:27 -0500988 if (!bi || off >= bi->bi_size || !len)
989 return NULL; /* Nothing to clone */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700990
Alex Elderf7760da2012-10-20 22:17:27 -0500991 end = &chain;
992 while (len) {
993 unsigned int bi_size;
994 struct bio *bio;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700995
Alex Elderf5400b72012-11-01 10:17:15 -0500996 if (!bi) {
997 rbd_warn(NULL, "bio_chain exhausted with %u left", len);
Alex Elderf7760da2012-10-20 22:17:27 -0500998 goto out_err; /* EINVAL; ran out of bio's */
Alex Elderf5400b72012-11-01 10:17:15 -0500999 }
Alex Elderf7760da2012-10-20 22:17:27 -05001000 bi_size = min_t(unsigned int, bi->bi_size - off, len);
1001 bio = bio_clone_range(bi, off, bi_size, gfpmask);
1002 if (!bio)
1003 goto out_err; /* ENOMEM */
1004
1005 *end = bio;
1006 end = &bio->bi_next;
1007
1008 off += bi_size;
1009 if (off == bi->bi_size) {
1010 bi = bi->bi_next;
1011 off = 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001012 }
Alex Elderf7760da2012-10-20 22:17:27 -05001013 len -= bi_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001014 }
Alex Elderf7760da2012-10-20 22:17:27 -05001015 *bio_src = bi;
1016 *offset = off;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001017
Alex Elderf7760da2012-10-20 22:17:27 -05001018 return chain;
1019out_err:
1020 bio_chain_put(chain);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001021
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001022 return NULL;
1023}
1024
1025/*
1026 * helpers for osd request op vectors.
1027 */
Alex Elder57cfc102012-06-26 12:57:03 -07001028static struct ceph_osd_req_op *rbd_create_rw_ops(int num_ops,
1029 int opcode, u32 payload_len)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001030{
Alex Elder57cfc102012-06-26 12:57:03 -07001031 struct ceph_osd_req_op *ops;
1032
1033 ops = kzalloc(sizeof (*ops) * (num_ops + 1), GFP_NOIO);
1034 if (!ops)
1035 return NULL;
1036
1037 ops[0].op = opcode;
1038
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001039 /*
1040 * op extent offset and length will be set later on
1041 * in calc_raw_layout()
1042 */
Alex Elder57cfc102012-06-26 12:57:03 -07001043 ops[0].payload_len = payload_len;
1044
1045 return ops;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001046}
1047
1048static void rbd_destroy_ops(struct ceph_osd_req_op *ops)
1049{
1050 kfree(ops);
1051}
1052
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001053static void rbd_coll_end_req_index(struct request *rq,
1054 struct rbd_req_coll *coll,
1055 int index,
Alex Elder8986cb32012-11-08 08:01:39 -06001056 s32 ret, u64 len)
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001057{
1058 struct request_queue *q;
1059 int min, max, i;
1060
Alex Elderbd919d42012-07-13 20:35:11 -05001061 dout("rbd_coll_end_req_index %p index %d ret %d len %llu\n",
Alex Elder8986cb32012-11-08 08:01:39 -06001062 coll, index, (int)ret, (unsigned long long)len);
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001063
1064 if (!rq)
1065 return;
1066
1067 if (!coll) {
1068 blk_end_request(rq, ret, len);
1069 return;
1070 }
1071
1072 q = rq->q;
1073
1074 spin_lock_irq(q->queue_lock);
1075 coll->status[index].done = 1;
1076 coll->status[index].rc = ret;
1077 coll->status[index].bytes = len;
1078 max = min = coll->num_done;
1079 while (max < coll->total && coll->status[max].done)
1080 max++;
1081
1082 for (i = min; i<max; i++) {
Alex Elder8986cb32012-11-08 08:01:39 -06001083 __blk_end_request(rq, (int)coll->status[i].rc,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001084 coll->status[i].bytes);
1085 coll->num_done++;
1086 kref_put(&coll->kref, rbd_coll_release);
1087 }
1088 spin_unlock_irq(q->queue_lock);
1089}
1090
Alex Elder725afc92012-11-08 08:01:39 -06001091static void rbd_coll_end_req(struct rbd_request *rbd_req,
Alex Elder8986cb32012-11-08 08:01:39 -06001092 s32 ret, u64 len)
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001093{
Alex Elder725afc92012-11-08 08:01:39 -06001094 rbd_coll_end_req_index(rbd_req->rq,
1095 rbd_req->coll, rbd_req->coll_index,
1096 ret, len);
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001097}
1098
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001099/*
1100 * Send ceph osd request
1101 */
1102static int rbd_do_request(struct request *rq,
Alex Elder0ce1a792012-07-03 16:01:18 -05001103 struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001104 struct ceph_snap_context *snapc,
1105 u64 snapid,
Alex Elderaded07e2012-07-03 16:01:18 -05001106 const char *object_name, u64 ofs, u64 len,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001107 struct bio *bio,
1108 struct page **pages,
1109 int num_pages,
1110 int flags,
1111 struct ceph_osd_req_op *ops,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001112 struct rbd_req_coll *coll,
1113 int coll_index,
Alex Elder5f29ddd2012-11-08 08:01:39 -06001114 void (*rbd_cb)(struct ceph_osd_request *,
1115 struct ceph_msg *),
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001116 struct ceph_osd_request **linger_req,
1117 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001118{
Alex Elder5f29ddd2012-11-08 08:01:39 -06001119 struct ceph_osd_request *osd_req;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001120 struct ceph_file_layout *layout;
1121 int ret;
1122 u64 bno;
1123 struct timespec mtime = CURRENT_TIME;
Alex Elder725afc92012-11-08 08:01:39 -06001124 struct rbd_request *rbd_req;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001125 struct ceph_osd_request_head *reqhead;
Alex Elder1dbb4392012-01-24 10:08:37 -06001126 struct ceph_osd_client *osdc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001127
Alex Elder725afc92012-11-08 08:01:39 -06001128 rbd_req = kzalloc(sizeof(*rbd_req), GFP_NOIO);
Alex Eldercd323ac2012-11-08 08:01:39 -06001129 if (!rbd_req)
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001130 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001131
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001132 if (coll) {
Alex Elder725afc92012-11-08 08:01:39 -06001133 rbd_req->coll = coll;
1134 rbd_req->coll_index = coll_index;
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001135 }
1136
Alex Elderf7760da2012-10-20 22:17:27 -05001137 dout("rbd_do_request object_name=%s ofs=%llu len=%llu coll=%p[%d]\n",
1138 object_name, (unsigned long long) ofs,
1139 (unsigned long long) len, coll, coll_index);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001140
Alex Elder0ce1a792012-07-03 16:01:18 -05001141 osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elder5f29ddd2012-11-08 08:01:39 -06001142 osd_req = ceph_osdc_alloc_request(osdc, flags, snapc, ops,
Alex Elder1dbb4392012-01-24 10:08:37 -06001143 false, GFP_NOIO, pages, bio);
Alex Elder5f29ddd2012-11-08 08:01:39 -06001144 if (!osd_req) {
Sage Weil4ad12622011-05-03 09:23:36 -07001145 ret = -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001146 goto done_pages;
1147 }
1148
Alex Elder5f29ddd2012-11-08 08:01:39 -06001149 osd_req->r_callback = rbd_cb;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001150
Alex Elder725afc92012-11-08 08:01:39 -06001151 rbd_req->rq = rq;
1152 rbd_req->bio = bio;
1153 rbd_req->pages = pages;
1154 rbd_req->len = len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001155
Alex Elder5f29ddd2012-11-08 08:01:39 -06001156 osd_req->r_priv = rbd_req;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001157
Alex Elder5f29ddd2012-11-08 08:01:39 -06001158 reqhead = osd_req->r_request->front.iov_base;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001159 reqhead->snapid = cpu_to_le64(CEPH_NOSNAP);
1160
Alex Elder5f29ddd2012-11-08 08:01:39 -06001161 strncpy(osd_req->r_oid, object_name, sizeof(osd_req->r_oid));
1162 osd_req->r_oid_len = strlen(osd_req->r_oid);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001163
Alex Elder5f29ddd2012-11-08 08:01:39 -06001164 layout = &osd_req->r_file_layout;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001165 memset(layout, 0, sizeof(*layout));
1166 layout->fl_stripe_unit = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
1167 layout->fl_stripe_count = cpu_to_le32(1);
1168 layout->fl_object_size = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
Alex Elder0d7dbfc2012-10-25 23:34:41 -05001169 layout->fl_pg_pool = cpu_to_le32((int) rbd_dev->spec->pool_id);
Sage Weil6cae3712012-09-24 21:02:47 -07001170 ret = ceph_calc_raw_layout(osdc, layout, snapid, ofs, &len, &bno,
Alex Elder5f29ddd2012-11-08 08:01:39 -06001171 osd_req, ops);
Sage Weil6cae3712012-09-24 21:02:47 -07001172 rbd_assert(ret == 0);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001173
Alex Elder5f29ddd2012-11-08 08:01:39 -06001174 ceph_osdc_build_request(osd_req, ofs, &len,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001175 ops,
1176 snapc,
1177 &mtime,
Alex Elder5f29ddd2012-11-08 08:01:39 -06001178 osd_req->r_oid, osd_req->r_oid_len);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001179
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001180 if (linger_req) {
Alex Elder5f29ddd2012-11-08 08:01:39 -06001181 ceph_osdc_set_request_linger(osdc, osd_req);
1182 *linger_req = osd_req;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001183 }
1184
Alex Elder5f29ddd2012-11-08 08:01:39 -06001185 ret = ceph_osdc_start_request(osdc, osd_req, false);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001186 if (ret < 0)
1187 goto done_err;
1188
1189 if (!rbd_cb) {
Alex Elder5f29ddd2012-11-08 08:01:39 -06001190 u64 version;
1191
1192 ret = ceph_osdc_wait_request(osdc, osd_req);
1193 version = le64_to_cpu(osd_req->r_reassert_version.version);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001194 if (ver)
Alex Elder5f29ddd2012-11-08 08:01:39 -06001195 *ver = version;
1196 dout("reassert_ver=%llu\n", (unsigned long long) version);
1197 ceph_osdc_put_request(osd_req);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001198 }
1199 return ret;
1200
1201done_err:
Alex Elder725afc92012-11-08 08:01:39 -06001202 bio_chain_put(rbd_req->bio);
Alex Elder5f29ddd2012-11-08 08:01:39 -06001203 ceph_osdc_put_request(osd_req);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001204done_pages:
Alex Elder725afc92012-11-08 08:01:39 -06001205 kfree(rbd_req);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001206 return ret;
1207}
1208
1209/*
1210 * Ceph osd op callback
1211 */
Alex Elder5f29ddd2012-11-08 08:01:39 -06001212static void rbd_req_cb(struct ceph_osd_request *osd_req, struct ceph_msg *msg)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001213{
Alex Elder5f29ddd2012-11-08 08:01:39 -06001214 struct rbd_request *rbd_req = osd_req->r_priv;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001215 struct ceph_osd_reply_head *replyhead;
1216 struct ceph_osd_op *op;
Alex Elder8986cb32012-11-08 08:01:39 -06001217 s32 rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001218 u64 bytes;
1219 int read_op;
1220
1221 /* parse reply */
1222 replyhead = msg->front.iov_base;
1223 WARN_ON(le32_to_cpu(replyhead->num_ops) == 0);
1224 op = (void *)(replyhead + 1);
Alex Elder8986cb32012-11-08 08:01:39 -06001225 rc = (s32)le32_to_cpu(replyhead->result);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001226 bytes = le64_to_cpu(op->extent.length);
Dan Carpenter895cfcc2012-06-06 09:15:33 -05001227 read_op = (le16_to_cpu(op->op) == CEPH_OSD_OP_READ);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001228
Alex Elderbd919d42012-07-13 20:35:11 -05001229 dout("rbd_req_cb bytes=%llu readop=%d rc=%d\n",
1230 (unsigned long long) bytes, read_op, (int) rc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001231
Alex Elder8986cb32012-11-08 08:01:39 -06001232 if (rc == (s32)-ENOENT && read_op) {
Alex Elder725afc92012-11-08 08:01:39 -06001233 zero_bio_chain(rbd_req->bio, 0);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001234 rc = 0;
Alex Elder725afc92012-11-08 08:01:39 -06001235 } else if (rc == 0 && read_op && bytes < rbd_req->len) {
1236 zero_bio_chain(rbd_req->bio, bytes);
1237 bytes = rbd_req->len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001238 }
1239
Alex Elder725afc92012-11-08 08:01:39 -06001240 rbd_coll_end_req(rbd_req, rc, bytes);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001241
Alex Elder725afc92012-11-08 08:01:39 -06001242 if (rbd_req->bio)
1243 bio_chain_put(rbd_req->bio);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001244
Alex Elder5f29ddd2012-11-08 08:01:39 -06001245 ceph_osdc_put_request(osd_req);
Alex Elder725afc92012-11-08 08:01:39 -06001246 kfree(rbd_req);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001247}
1248
Alex Elder5f29ddd2012-11-08 08:01:39 -06001249static void rbd_simple_req_cb(struct ceph_osd_request *osd_req,
1250 struct ceph_msg *msg)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001251{
Alex Elder5f29ddd2012-11-08 08:01:39 -06001252 ceph_osdc_put_request(osd_req);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001253}
1254
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001255/*
1256 * Do a synchronous ceph osd operation
1257 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001258static int rbd_req_sync_op(struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001259 struct ceph_snap_context *snapc,
1260 u64 snapid,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001261 int flags,
Alex Elder913d2fd2012-06-26 12:57:03 -07001262 struct ceph_osd_req_op *ops,
Alex Elderaded07e2012-07-03 16:01:18 -05001263 const char *object_name,
Alex Elderf8d4de62012-07-03 16:01:19 -05001264 u64 ofs, u64 inbound_size,
1265 char *inbound,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001266 struct ceph_osd_request **linger_req,
1267 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001268{
1269 int ret;
1270 struct page **pages;
1271 int num_pages;
Alex Elder913d2fd2012-06-26 12:57:03 -07001272
Alex Elderaafb2302012-09-06 16:00:54 -05001273 rbd_assert(ops != NULL);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001274
Alex Elderf8d4de62012-07-03 16:01:19 -05001275 num_pages = calc_pages_for(ofs, inbound_size);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001276 pages = ceph_alloc_page_vector(num_pages, GFP_KERNEL);
Dan Carpenterb8d06382010-10-11 21:14:23 +02001277 if (IS_ERR(pages))
1278 return PTR_ERR(pages);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001279
Alex Elder0ce1a792012-07-03 16:01:18 -05001280 ret = rbd_do_request(NULL, rbd_dev, snapc, snapid,
Alex Elderf8d4de62012-07-03 16:01:19 -05001281 object_name, ofs, inbound_size, NULL,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001282 pages, num_pages,
1283 flags,
1284 ops,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001285 NULL, 0,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001286 NULL,
1287 linger_req, ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001288 if (ret < 0)
Alex Elder913d2fd2012-06-26 12:57:03 -07001289 goto done;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001290
Alex Elderf8d4de62012-07-03 16:01:19 -05001291 if ((flags & CEPH_OSD_FLAG_READ) && inbound)
1292 ret = ceph_copy_from_page_vector(pages, inbound, ofs, ret);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001293
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001294done:
1295 ceph_release_page_vector(pages, num_pages);
1296 return ret;
1297}
1298
1299/*
1300 * Do an asynchronous ceph osd operation
1301 */
1302static int rbd_do_op(struct request *rq,
Alex Elder0ce1a792012-07-03 16:01:18 -05001303 struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001304 struct ceph_snap_context *snapc,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001305 u64 ofs, u64 len,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001306 struct bio *bio,
1307 struct rbd_req_coll *coll,
1308 int coll_index)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001309{
1310 char *seg_name;
1311 u64 seg_ofs;
1312 u64 seg_len;
1313 int ret;
1314 struct ceph_osd_req_op *ops;
1315 u32 payload_len;
Alex Elderff2e4bb2012-10-10 18:59:29 -07001316 int opcode;
1317 int flags;
Alex Elder46342462012-10-10 18:59:29 -07001318 u64 snapid;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001319
Alex Elder65ccfe22012-08-09 10:33:26 -07001320 seg_name = rbd_segment_name(rbd_dev, ofs);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001321 if (!seg_name)
1322 return -ENOMEM;
Alex Elder65ccfe22012-08-09 10:33:26 -07001323 seg_len = rbd_segment_length(rbd_dev, ofs, len);
1324 seg_ofs = rbd_segment_offset(rbd_dev, ofs);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001325
Alex Elderff2e4bb2012-10-10 18:59:29 -07001326 if (rq_data_dir(rq) == WRITE) {
1327 opcode = CEPH_OSD_OP_WRITE;
1328 flags = CEPH_OSD_FLAG_WRITE|CEPH_OSD_FLAG_ONDISK;
Alex Elder46342462012-10-10 18:59:29 -07001329 snapid = CEPH_NOSNAP;
Alex Elderff2e4bb2012-10-10 18:59:29 -07001330 payload_len = seg_len;
1331 } else {
1332 opcode = CEPH_OSD_OP_READ;
1333 flags = CEPH_OSD_FLAG_READ;
Alex Elder46342462012-10-10 18:59:29 -07001334 snapc = NULL;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05001335 snapid = rbd_dev->spec->snap_id;
Alex Elderff2e4bb2012-10-10 18:59:29 -07001336 payload_len = 0;
1337 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001338
Alex Elder57cfc102012-06-26 12:57:03 -07001339 ret = -ENOMEM;
1340 ops = rbd_create_rw_ops(1, opcode, payload_len);
1341 if (!ops)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001342 goto done;
1343
1344 /* we've taken care of segment sizes earlier when we
1345 cloned the bios. We should never have a segment
1346 truncated at this point */
Alex Elderaafb2302012-09-06 16:00:54 -05001347 rbd_assert(seg_len == len);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001348
1349 ret = rbd_do_request(rq, rbd_dev, snapc, snapid,
1350 seg_name, seg_ofs, seg_len,
1351 bio,
1352 NULL, 0,
1353 flags,
1354 ops,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001355 coll, coll_index,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001356 rbd_req_cb, 0, NULL);
Alex Eldercd323ac2012-11-08 08:01:39 -06001357 if (ret < 0)
1358 rbd_coll_end_req_index(rq, coll, coll_index,
1359 (s32)ret, seg_len);
Sage Weil11f77002011-05-12 16:13:54 -07001360 rbd_destroy_ops(ops);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001361done:
1362 kfree(seg_name);
1363 return ret;
1364}
1365
1366/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001367 * Request sync osd read
1368 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001369static int rbd_req_sync_read(struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001370 u64 snapid,
Alex Elderaded07e2012-07-03 16:01:18 -05001371 const char *object_name,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001372 u64 ofs, u64 len,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001373 char *buf,
1374 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001375{
Alex Elder913d2fd2012-06-26 12:57:03 -07001376 struct ceph_osd_req_op *ops;
1377 int ret;
1378
1379 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_READ, 0);
1380 if (!ops)
1381 return -ENOMEM;
1382
1383 ret = rbd_req_sync_op(rbd_dev, NULL,
Josh Durginb06e6a62011-11-21 18:16:52 -08001384 snapid,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001385 CEPH_OSD_FLAG_READ,
Alex Elder913d2fd2012-06-26 12:57:03 -07001386 ops, object_name, ofs, len, buf, NULL, ver);
1387 rbd_destroy_ops(ops);
1388
1389 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001390}
1391
1392/*
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001393 * Request sync osd watch
1394 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001395static int rbd_req_sync_notify_ack(struct rbd_device *rbd_dev,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001396 u64 ver,
Alex Elder7f0a24d2012-07-25 09:32:40 -05001397 u64 notify_id)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001398{
1399 struct ceph_osd_req_op *ops;
Sage Weil11f77002011-05-12 16:13:54 -07001400 int ret;
1401
Alex Elder57cfc102012-06-26 12:57:03 -07001402 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_NOTIFY_ACK, 0);
1403 if (!ops)
1404 return -ENOMEM;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001405
Josh Durgina71b8912011-12-05 18:10:44 -08001406 ops[0].watch.ver = cpu_to_le64(ver);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001407 ops[0].watch.cookie = notify_id;
1408 ops[0].watch.flag = 0;
1409
Alex Elder0ce1a792012-07-03 16:01:18 -05001410 ret = rbd_do_request(NULL, rbd_dev, NULL, CEPH_NOSNAP,
Alex Elder7f0a24d2012-07-25 09:32:40 -05001411 rbd_dev->header_name, 0, 0, NULL,
Alex Elderad4f2322012-07-03 16:01:19 -05001412 NULL, 0,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001413 CEPH_OSD_FLAG_READ,
1414 ops,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001415 NULL, 0,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001416 rbd_simple_req_cb, 0, NULL);
1417
1418 rbd_destroy_ops(ops);
1419 return ret;
1420}
1421
1422static void rbd_watch_cb(u64 ver, u64 notify_id, u8 opcode, void *data)
1423{
Alex Elder0ce1a792012-07-03 16:01:18 -05001424 struct rbd_device *rbd_dev = (struct rbd_device *)data;
Josh Durgina71b8912011-12-05 18:10:44 -08001425 u64 hver;
Sage Weil13143d22011-05-12 16:08:30 -07001426 int rc;
1427
Alex Elder0ce1a792012-07-03 16:01:18 -05001428 if (!rbd_dev)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001429 return;
1430
Alex Elderbd919d42012-07-13 20:35:11 -05001431 dout("rbd_watch_cb %s notify_id=%llu opcode=%u\n",
1432 rbd_dev->header_name, (unsigned long long) notify_id,
1433 (unsigned int) opcode);
Alex Elder117973f2012-08-31 17:29:55 -05001434 rc = rbd_dev_refresh(rbd_dev, &hver);
Sage Weil13143d22011-05-12 16:08:30 -07001435 if (rc)
Alex Elder06ecc6c2012-11-01 10:17:15 -05001436 rbd_warn(rbd_dev, "got notification but failed to "
1437 " update snaps: %d\n", rc);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001438
Alex Elder7f0a24d2012-07-25 09:32:40 -05001439 rbd_req_sync_notify_ack(rbd_dev, hver, notify_id);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001440}
1441
1442/*
1443 * Request sync osd watch
1444 */
Alex Elder0e6f3222012-07-25 09:32:40 -05001445static int rbd_req_sync_watch(struct rbd_device *rbd_dev)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001446{
1447 struct ceph_osd_req_op *ops;
Alex Elder0ce1a792012-07-03 16:01:18 -05001448 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elder57cfc102012-06-26 12:57:03 -07001449 int ret;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001450
Alex Elder57cfc102012-06-26 12:57:03 -07001451 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_WATCH, 0);
1452 if (!ops)
1453 return -ENOMEM;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001454
1455 ret = ceph_osdc_create_event(osdc, rbd_watch_cb, 0,
Alex Elder0ce1a792012-07-03 16:01:18 -05001456 (void *)rbd_dev, &rbd_dev->watch_event);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001457 if (ret < 0)
1458 goto fail;
1459
Alex Elder0e6f3222012-07-25 09:32:40 -05001460 ops[0].watch.ver = cpu_to_le64(rbd_dev->header.obj_version);
Alex Elder0ce1a792012-07-03 16:01:18 -05001461 ops[0].watch.cookie = cpu_to_le64(rbd_dev->watch_event->cookie);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001462 ops[0].watch.flag = 1;
1463
Alex Elder0ce1a792012-07-03 16:01:18 -05001464 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001465 CEPH_NOSNAP,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001466 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1467 ops,
Alex Elder0e6f3222012-07-25 09:32:40 -05001468 rbd_dev->header_name,
1469 0, 0, NULL,
Alex Elder0ce1a792012-07-03 16:01:18 -05001470 &rbd_dev->watch_request, NULL);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001471
1472 if (ret < 0)
1473 goto fail_event;
1474
1475 rbd_destroy_ops(ops);
1476 return 0;
1477
1478fail_event:
Alex Elder0ce1a792012-07-03 16:01:18 -05001479 ceph_osdc_cancel_event(rbd_dev->watch_event);
1480 rbd_dev->watch_event = NULL;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001481fail:
1482 rbd_destroy_ops(ops);
1483 return ret;
1484}
1485
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001486/*
1487 * Request sync osd unwatch
1488 */
Alex Elder070c6332012-07-25 09:32:41 -05001489static int rbd_req_sync_unwatch(struct rbd_device *rbd_dev)
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001490{
1491 struct ceph_osd_req_op *ops;
Alex Elder57cfc102012-06-26 12:57:03 -07001492 int ret;
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001493
Alex Elder57cfc102012-06-26 12:57:03 -07001494 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_WATCH, 0);
1495 if (!ops)
1496 return -ENOMEM;
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001497
1498 ops[0].watch.ver = 0;
Alex Elder0ce1a792012-07-03 16:01:18 -05001499 ops[0].watch.cookie = cpu_to_le64(rbd_dev->watch_event->cookie);
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001500 ops[0].watch.flag = 0;
1501
Alex Elder0ce1a792012-07-03 16:01:18 -05001502 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001503 CEPH_NOSNAP,
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001504 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1505 ops,
Alex Elder070c6332012-07-25 09:32:41 -05001506 rbd_dev->header_name,
1507 0, 0, NULL, NULL, NULL);
1508
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001509
1510 rbd_destroy_ops(ops);
Alex Elder0ce1a792012-07-03 16:01:18 -05001511 ceph_osdc_cancel_event(rbd_dev->watch_event);
1512 rbd_dev->watch_event = NULL;
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001513 return ret;
1514}
1515
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001516/*
Alex Elder3cb4a682012-06-26 12:57:03 -07001517 * Synchronous osd object method call
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001518 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001519static int rbd_req_sync_exec(struct rbd_device *rbd_dev,
Alex Elderaded07e2012-07-03 16:01:18 -05001520 const char *object_name,
1521 const char *class_name,
1522 const char *method_name,
Alex Elder3cb4a682012-06-26 12:57:03 -07001523 const char *outbound,
1524 size_t outbound_size,
Alex Elderf8d4de62012-07-03 16:01:19 -05001525 char *inbound,
1526 size_t inbound_size,
Alex Elder3cb4a682012-06-26 12:57:03 -07001527 int flags,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001528 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001529{
1530 struct ceph_osd_req_op *ops;
Alex Elderaded07e2012-07-03 16:01:18 -05001531 int class_name_len = strlen(class_name);
1532 int method_name_len = strlen(method_name);
Alex Elder3cb4a682012-06-26 12:57:03 -07001533 int payload_size;
Alex Elder57cfc102012-06-26 12:57:03 -07001534 int ret;
1535
Alex Elder3cb4a682012-06-26 12:57:03 -07001536 /*
1537 * Any input parameters required by the method we're calling
1538 * will be sent along with the class and method names as
1539 * part of the message payload. That data and its size are
1540 * supplied via the indata and indata_len fields (named from
1541 * the perspective of the server side) in the OSD request
1542 * operation.
1543 */
1544 payload_size = class_name_len + method_name_len + outbound_size;
1545 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_CALL, payload_size);
Alex Elder57cfc102012-06-26 12:57:03 -07001546 if (!ops)
1547 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001548
Alex Elderaded07e2012-07-03 16:01:18 -05001549 ops[0].cls.class_name = class_name;
1550 ops[0].cls.class_len = (__u8) class_name_len;
1551 ops[0].cls.method_name = method_name;
1552 ops[0].cls.method_len = (__u8) method_name_len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001553 ops[0].cls.argc = 0;
Alex Elder3cb4a682012-06-26 12:57:03 -07001554 ops[0].cls.indata = outbound;
1555 ops[0].cls.indata_len = outbound_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001556
Alex Elder0ce1a792012-07-03 16:01:18 -05001557 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001558 CEPH_NOSNAP,
Alex Elder3cb4a682012-06-26 12:57:03 -07001559 flags, ops,
Alex Elderf8d4de62012-07-03 16:01:19 -05001560 object_name, 0, inbound_size, inbound,
1561 NULL, ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001562
1563 rbd_destroy_ops(ops);
1564
1565 dout("cls_exec returned %d\n", ret);
1566 return ret;
1567}
1568
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001569static struct rbd_req_coll *rbd_alloc_coll(int num_reqs)
1570{
1571 struct rbd_req_coll *coll =
1572 kzalloc(sizeof(struct rbd_req_coll) +
1573 sizeof(struct rbd_req_status) * num_reqs,
1574 GFP_ATOMIC);
1575
1576 if (!coll)
1577 return NULL;
1578 coll->total = num_reqs;
1579 kref_init(&coll->kref);
1580 return coll;
1581}
1582
Alex Elder8295cda2012-11-08 08:01:39 -06001583static int rbd_dev_do_request(struct request *rq,
1584 struct rbd_device *rbd_dev,
1585 struct ceph_snap_context *snapc,
1586 u64 ofs, unsigned int size,
1587 struct bio *bio_chain)
1588{
1589 int num_segs;
1590 struct rbd_req_coll *coll;
1591 unsigned int bio_offset;
1592 int cur_seg = 0;
1593
1594 dout("%s 0x%x bytes at 0x%llx\n",
1595 rq_data_dir(rq) == WRITE ? "write" : "read",
1596 size, (unsigned long long) blk_rq_pos(rq) * SECTOR_SIZE);
1597
1598 num_segs = rbd_get_num_segments(&rbd_dev->header, ofs, size);
1599 if (num_segs <= 0)
1600 return num_segs;
1601
1602 coll = rbd_alloc_coll(num_segs);
1603 if (!coll)
1604 return -ENOMEM;
1605
1606 bio_offset = 0;
1607 do {
1608 u64 limit = rbd_segment_length(rbd_dev, ofs, size);
1609 unsigned int clone_size;
1610 struct bio *bio_clone;
1611
1612 BUG_ON(limit > (u64)UINT_MAX);
1613 clone_size = (unsigned int)limit;
1614 dout("bio_chain->bi_vcnt=%hu\n", bio_chain->bi_vcnt);
1615
1616 kref_get(&coll->kref);
1617
1618 /* Pass a cloned bio chain via an osd request */
1619
1620 bio_clone = bio_chain_clone_range(&bio_chain,
1621 &bio_offset, clone_size,
1622 GFP_ATOMIC);
1623 if (bio_clone)
1624 (void)rbd_do_op(rq, rbd_dev, snapc,
1625 ofs, clone_size,
1626 bio_clone, coll, cur_seg);
1627 else
1628 rbd_coll_end_req_index(rq, coll, cur_seg,
1629 (s32)-ENOMEM,
1630 clone_size);
1631 size -= clone_size;
1632 ofs += clone_size;
1633
1634 cur_seg++;
1635 } while (size > 0);
1636 kref_put(&coll->kref, rbd_coll_release);
1637
1638 return 0;
1639}
1640
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001641/*
1642 * block device queue callback
1643 */
1644static void rbd_rq_fn(struct request_queue *q)
1645{
1646 struct rbd_device *rbd_dev = q->queuedata;
1647 struct request *rq;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001648
Alex Elder00f1f362012-02-07 12:03:36 -06001649 while ((rq = blk_fetch_request(q))) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001650 struct bio *bio;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001651 bool do_write;
Alex Elderbd919d42012-07-13 20:35:11 -05001652 unsigned int size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001653 u64 ofs;
Josh Durgind1d25642011-12-05 14:03:05 -08001654 struct ceph_snap_context *snapc;
Alex Elder8295cda2012-11-08 08:01:39 -06001655 int result;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001656
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001657 dout("fetched request\n");
1658
1659 /* filter out block requests we don't understand */
1660 if ((rq->cmd_type != REQ_TYPE_FS)) {
1661 __blk_end_request_all(rq, 0);
Alex Elder00f1f362012-02-07 12:03:36 -06001662 continue;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001663 }
1664
1665 /* deduce our operation (read, write) */
1666 do_write = (rq_data_dir(rq) == WRITE);
Alex Elderf84344f2012-08-31 17:29:51 -05001667 if (do_write && rbd_dev->mapping.read_only) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001668 __blk_end_request_all(rq, -EROFS);
Alex Elder00f1f362012-02-07 12:03:36 -06001669 continue;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001670 }
1671
1672 spin_unlock_irq(q->queue_lock);
1673
Josh Durgind1d25642011-12-05 14:03:05 -08001674 down_read(&rbd_dev->header_rwsem);
Josh Durgine88a36e2011-11-21 18:14:25 -08001675
Alex Elderdaba5fd2012-10-26 17:25:23 -05001676 if (!rbd_dev->exists) {
Alex Elder0d7dbfc2012-10-25 23:34:41 -05001677 rbd_assert(rbd_dev->spec->snap_id != CEPH_NOSNAP);
Josh Durgine88a36e2011-11-21 18:14:25 -08001678 up_read(&rbd_dev->header_rwsem);
Josh Durgind1d25642011-12-05 14:03:05 -08001679 dout("request for non-existent snapshot");
1680 spin_lock_irq(q->queue_lock);
1681 __blk_end_request_all(rq, -ENXIO);
1682 continue;
Josh Durgine88a36e2011-11-21 18:14:25 -08001683 }
1684
Josh Durgind1d25642011-12-05 14:03:05 -08001685 snapc = ceph_get_snap_context(rbd_dev->header.snapc);
1686
1687 up_read(&rbd_dev->header_rwsem);
1688
Alex Elderf7760da2012-10-20 22:17:27 -05001689 size = blk_rq_bytes(rq);
1690 ofs = blk_rq_pos(rq) * SECTOR_SIZE;
1691 bio = rq->bio;
1692
Alex Elder8295cda2012-11-08 08:01:39 -06001693 result = rbd_dev_do_request(rq, rbd_dev, snapc, ofs, size, bio);
Josh Durgind1d25642011-12-05 14:03:05 -08001694 ceph_put_snap_context(snapc);
Alex Elder8295cda2012-11-08 08:01:39 -06001695 spin_lock_irq(q->queue_lock);
1696 if (!size || result < 0)
1697 __blk_end_request_all(rq, result);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001698 }
1699}
1700
1701/*
1702 * a queue callback. Makes sure that we don't create a bio that spans across
1703 * multiple osd objects. One exception would be with a single page bios,
Alex Elderf7760da2012-10-20 22:17:27 -05001704 * which we handle later at bio_chain_clone_range()
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001705 */
1706static int rbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bmd,
1707 struct bio_vec *bvec)
1708{
1709 struct rbd_device *rbd_dev = q->queuedata;
Alex Eldere5cfeed22012-10-20 22:17:27 -05001710 sector_t sector_offset;
1711 sector_t sectors_per_obj;
1712 sector_t obj_sector_offset;
1713 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001714
Alex Eldere5cfeed22012-10-20 22:17:27 -05001715 /*
1716 * Find how far into its rbd object the partition-relative
1717 * bio start sector is to offset relative to the enclosing
1718 * device.
1719 */
1720 sector_offset = get_start_sect(bmd->bi_bdev) + bmd->bi_sector;
1721 sectors_per_obj = 1 << (rbd_dev->header.obj_order - SECTOR_SHIFT);
1722 obj_sector_offset = sector_offset & (sectors_per_obj - 1);
Alex Elder593a9e72012-02-07 12:03:37 -06001723
Alex Eldere5cfeed22012-10-20 22:17:27 -05001724 /*
1725 * Compute the number of bytes from that offset to the end
1726 * of the object. Account for what's already used by the bio.
1727 */
1728 ret = (int) (sectors_per_obj - obj_sector_offset) << SECTOR_SHIFT;
1729 if (ret > bmd->bi_size)
1730 ret -= bmd->bi_size;
1731 else
1732 ret = 0;
1733
1734 /*
1735 * Don't send back more than was asked for. And if the bio
1736 * was empty, let the whole thing through because: "Note
1737 * that a block device *must* allow a single page to be
1738 * added to an empty bio."
1739 */
1740 rbd_assert(bvec->bv_len <= PAGE_SIZE);
1741 if (ret > (int) bvec->bv_len || !bmd->bi_size)
1742 ret = (int) bvec->bv_len;
1743
1744 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001745}
1746
1747static void rbd_free_disk(struct rbd_device *rbd_dev)
1748{
1749 struct gendisk *disk = rbd_dev->disk;
1750
1751 if (!disk)
1752 return;
1753
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001754 if (disk->flags & GENHD_FL_UP)
1755 del_gendisk(disk);
1756 if (disk->queue)
1757 blk_cleanup_queue(disk->queue);
1758 put_disk(disk);
1759}
1760
1761/*
Alex Elder4156d992012-08-02 11:29:46 -05001762 * Read the complete header for the given rbd device.
1763 *
1764 * Returns a pointer to a dynamically-allocated buffer containing
1765 * the complete and validated header. Caller can pass the address
1766 * of a variable that will be filled in with the version of the
1767 * header object at the time it was read.
1768 *
1769 * Returns a pointer-coded errno if a failure occurs.
1770 */
1771static struct rbd_image_header_ondisk *
1772rbd_dev_v1_header_read(struct rbd_device *rbd_dev, u64 *version)
1773{
1774 struct rbd_image_header_ondisk *ondisk = NULL;
1775 u32 snap_count = 0;
1776 u64 names_size = 0;
1777 u32 want_count;
1778 int ret;
1779
1780 /*
1781 * The complete header will include an array of its 64-bit
1782 * snapshot ids, followed by the names of those snapshots as
1783 * a contiguous block of NUL-terminated strings. Note that
1784 * the number of snapshots could change by the time we read
1785 * it in, in which case we re-read it.
1786 */
1787 do {
1788 size_t size;
1789
1790 kfree(ondisk);
1791
1792 size = sizeof (*ondisk);
1793 size += snap_count * sizeof (struct rbd_image_snap_ondisk);
1794 size += names_size;
1795 ondisk = kmalloc(size, GFP_KERNEL);
1796 if (!ondisk)
1797 return ERR_PTR(-ENOMEM);
1798
1799 ret = rbd_req_sync_read(rbd_dev, CEPH_NOSNAP,
1800 rbd_dev->header_name,
1801 0, size,
1802 (char *) ondisk, version);
1803
1804 if (ret < 0)
1805 goto out_err;
1806 if (WARN_ON((size_t) ret < size)) {
1807 ret = -ENXIO;
Alex Elder06ecc6c2012-11-01 10:17:15 -05001808 rbd_warn(rbd_dev, "short header read (want %zd got %d)",
1809 size, ret);
Alex Elder4156d992012-08-02 11:29:46 -05001810 goto out_err;
1811 }
1812 if (!rbd_dev_ondisk_valid(ondisk)) {
1813 ret = -ENXIO;
Alex Elder06ecc6c2012-11-01 10:17:15 -05001814 rbd_warn(rbd_dev, "invalid header");
Alex Elder4156d992012-08-02 11:29:46 -05001815 goto out_err;
1816 }
1817
1818 names_size = le64_to_cpu(ondisk->snap_names_len);
1819 want_count = snap_count;
1820 snap_count = le32_to_cpu(ondisk->snap_count);
1821 } while (snap_count != want_count);
1822
1823 return ondisk;
1824
1825out_err:
1826 kfree(ondisk);
1827
1828 return ERR_PTR(ret);
1829}
1830
1831/*
1832 * reload the ondisk the header
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001833 */
1834static int rbd_read_header(struct rbd_device *rbd_dev,
1835 struct rbd_image_header *header)
1836{
Alex Elder4156d992012-08-02 11:29:46 -05001837 struct rbd_image_header_ondisk *ondisk;
1838 u64 ver = 0;
1839 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001840
Alex Elder4156d992012-08-02 11:29:46 -05001841 ondisk = rbd_dev_v1_header_read(rbd_dev, &ver);
1842 if (IS_ERR(ondisk))
1843 return PTR_ERR(ondisk);
1844 ret = rbd_header_from_disk(header, ondisk);
1845 if (ret >= 0)
1846 header->obj_version = ver;
1847 kfree(ondisk);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001848
Alex Elder4156d992012-08-02 11:29:46 -05001849 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001850}
1851
Alex Elder41f38c22012-10-25 23:34:40 -05001852static void rbd_remove_all_snaps(struct rbd_device *rbd_dev)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001853{
1854 struct rbd_snap *snap;
Alex Eldera0593292012-07-19 09:09:27 -05001855 struct rbd_snap *next;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001856
Alex Eldera0593292012-07-19 09:09:27 -05001857 list_for_each_entry_safe(snap, next, &rbd_dev->snaps, node)
Alex Elder41f38c22012-10-25 23:34:40 -05001858 rbd_remove_snap_dev(snap);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001859}
1860
Alex Elder94785542012-10-09 13:50:17 -07001861static void rbd_update_mapping_size(struct rbd_device *rbd_dev)
1862{
1863 sector_t size;
1864
Alex Elder0d7dbfc2012-10-25 23:34:41 -05001865 if (rbd_dev->spec->snap_id != CEPH_NOSNAP)
Alex Elder94785542012-10-09 13:50:17 -07001866 return;
1867
1868 size = (sector_t) rbd_dev->header.image_size / SECTOR_SIZE;
1869 dout("setting size to %llu sectors", (unsigned long long) size);
1870 rbd_dev->mapping.size = (u64) size;
1871 set_capacity(rbd_dev->disk, size);
1872}
1873
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001874/*
1875 * only read the first part of the ondisk header, without the snaps info
1876 */
Alex Elder117973f2012-08-31 17:29:55 -05001877static int rbd_dev_v1_refresh(struct rbd_device *rbd_dev, u64 *hver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001878{
1879 int ret;
1880 struct rbd_image_header h;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001881
1882 ret = rbd_read_header(rbd_dev, &h);
1883 if (ret < 0)
1884 return ret;
1885
Josh Durgina51aa0c2011-12-05 10:35:04 -08001886 down_write(&rbd_dev->header_rwsem);
1887
Alex Elder94785542012-10-09 13:50:17 -07001888 /* Update image size, and check for resize of mapped image */
1889 rbd_dev->header.image_size = h.image_size;
1890 rbd_update_mapping_size(rbd_dev);
Sage Weil9db4b3e2011-04-19 22:49:06 -07001891
Alex Elder849b4262012-07-09 21:04:24 -05001892 /* rbd_dev->header.object_prefix shouldn't change */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001893 kfree(rbd_dev->header.snap_sizes);
Alex Elder849b4262012-07-09 21:04:24 -05001894 kfree(rbd_dev->header.snap_names);
Josh Durgind1d25642011-12-05 14:03:05 -08001895 /* osd requests may still refer to snapc */
1896 ceph_put_snap_context(rbd_dev->header.snapc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001897
Alex Elderb8136232012-07-25 09:32:41 -05001898 if (hver)
1899 *hver = h.obj_version;
Josh Durgina71b8912011-12-05 18:10:44 -08001900 rbd_dev->header.obj_version = h.obj_version;
Josh Durgin93a24e02011-12-05 10:41:28 -08001901 rbd_dev->header.image_size = h.image_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001902 rbd_dev->header.snapc = h.snapc;
1903 rbd_dev->header.snap_names = h.snap_names;
1904 rbd_dev->header.snap_sizes = h.snap_sizes;
Alex Elder849b4262012-07-09 21:04:24 -05001905 /* Free the extra copy of the object prefix */
1906 WARN_ON(strcmp(rbd_dev->header.object_prefix, h.object_prefix));
1907 kfree(h.object_prefix);
1908
Alex Elder304f6802012-08-31 17:29:52 -05001909 ret = rbd_dev_snaps_update(rbd_dev);
1910 if (!ret)
1911 ret = rbd_dev_snaps_register(rbd_dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001912
Josh Durginc6666012011-11-21 17:11:12 -08001913 up_write(&rbd_dev->header_rwsem);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001914
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001915 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001916}
1917
Alex Elder117973f2012-08-31 17:29:55 -05001918static int rbd_dev_refresh(struct rbd_device *rbd_dev, u64 *hver)
Alex Elder1fe5e992012-07-25 09:32:41 -05001919{
1920 int ret;
1921
Alex Elder117973f2012-08-31 17:29:55 -05001922 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
Alex Elder1fe5e992012-07-25 09:32:41 -05001923 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Alex Elder117973f2012-08-31 17:29:55 -05001924 if (rbd_dev->image_format == 1)
1925 ret = rbd_dev_v1_refresh(rbd_dev, hver);
1926 else
1927 ret = rbd_dev_v2_refresh(rbd_dev, hver);
Alex Elder1fe5e992012-07-25 09:32:41 -05001928 mutex_unlock(&ctl_mutex);
1929
1930 return ret;
1931}
1932
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001933static int rbd_init_disk(struct rbd_device *rbd_dev)
1934{
1935 struct gendisk *disk;
1936 struct request_queue *q;
Alex Elder593a9e72012-02-07 12:03:37 -06001937 u64 segment_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001938
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001939 /* create gendisk info */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001940 disk = alloc_disk(RBD_MINORS_PER_MAJOR);
1941 if (!disk)
Alex Elder1fcdb8a2012-08-29 17:11:06 -05001942 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001943
Alex Elderf0f8cef2012-01-29 13:57:44 -06001944 snprintf(disk->disk_name, sizeof(disk->disk_name), RBD_DRV_NAME "%d",
Alex Elderde71a292012-07-03 16:01:19 -05001945 rbd_dev->dev_id);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001946 disk->major = rbd_dev->major;
1947 disk->first_minor = 0;
1948 disk->fops = &rbd_bd_ops;
1949 disk->private_data = rbd_dev;
1950
1951 /* init rq */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001952 q = blk_init_queue(rbd_rq_fn, &rbd_dev->lock);
1953 if (!q)
1954 goto out_disk;
Josh Durgin029bcbd2011-07-22 11:35:23 -07001955
Alex Elder593a9e72012-02-07 12:03:37 -06001956 /* We use the default size, but let's be explicit about it. */
1957 blk_queue_physical_block_size(q, SECTOR_SIZE);
1958
Josh Durgin029bcbd2011-07-22 11:35:23 -07001959 /* set io sizes to object size */
Alex Elder593a9e72012-02-07 12:03:37 -06001960 segment_size = rbd_obj_bytes(&rbd_dev->header);
1961 blk_queue_max_hw_sectors(q, segment_size / SECTOR_SIZE);
1962 blk_queue_max_segment_size(q, segment_size);
1963 blk_queue_io_min(q, segment_size);
1964 blk_queue_io_opt(q, segment_size);
Josh Durgin029bcbd2011-07-22 11:35:23 -07001965
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001966 blk_queue_merge_bvec(q, rbd_merge_bvec);
1967 disk->queue = q;
1968
1969 q->queuedata = rbd_dev;
1970
1971 rbd_dev->disk = disk;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001972
Alex Elder12f02942012-08-29 17:11:07 -05001973 set_capacity(rbd_dev->disk, rbd_dev->mapping.size / SECTOR_SIZE);
1974
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001975 return 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001976out_disk:
1977 put_disk(disk);
Alex Elder1fcdb8a2012-08-29 17:11:06 -05001978
1979 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001980}
1981
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001982/*
1983 sysfs
1984*/
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001985
Alex Elder593a9e72012-02-07 12:03:37 -06001986static struct rbd_device *dev_to_rbd_dev(struct device *dev)
1987{
1988 return container_of(dev, struct rbd_device, dev);
1989}
1990
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001991static ssize_t rbd_size_show(struct device *dev,
1992 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001993{
Alex Elder593a9e72012-02-07 12:03:37 -06001994 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Josh Durgina51aa0c2011-12-05 10:35:04 -08001995 sector_t size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001996
Josh Durgina51aa0c2011-12-05 10:35:04 -08001997 down_read(&rbd_dev->header_rwsem);
1998 size = get_capacity(rbd_dev->disk);
1999 up_read(&rbd_dev->header_rwsem);
2000
2001 return sprintf(buf, "%llu\n", (unsigned long long) size * SECTOR_SIZE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002002}
2003
Alex Elder34b13182012-07-13 20:35:12 -05002004/*
2005 * Note this shows the features for whatever's mapped, which is not
2006 * necessarily the base image.
2007 */
2008static ssize_t rbd_features_show(struct device *dev,
2009 struct device_attribute *attr, char *buf)
2010{
2011 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2012
2013 return sprintf(buf, "0x%016llx\n",
2014 (unsigned long long) rbd_dev->mapping.features);
2015}
2016
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002017static ssize_t rbd_major_show(struct device *dev,
2018 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002019{
Alex Elder593a9e72012-02-07 12:03:37 -06002020 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002021
2022 return sprintf(buf, "%d\n", rbd_dev->major);
2023}
2024
2025static ssize_t rbd_client_id_show(struct device *dev,
2026 struct device_attribute *attr, char *buf)
2027{
Alex Elder593a9e72012-02-07 12:03:37 -06002028 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002029
Alex Elder1dbb4392012-01-24 10:08:37 -06002030 return sprintf(buf, "client%lld\n",
2031 ceph_client_id(rbd_dev->rbd_client->client));
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002032}
2033
2034static ssize_t rbd_pool_show(struct device *dev,
2035 struct device_attribute *attr, char *buf)
2036{
Alex Elder593a9e72012-02-07 12:03:37 -06002037 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002038
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002039 return sprintf(buf, "%s\n", rbd_dev->spec->pool_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002040}
2041
Alex Elder9bb2f332012-07-12 10:46:35 -05002042static ssize_t rbd_pool_id_show(struct device *dev,
2043 struct device_attribute *attr, char *buf)
2044{
2045 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2046
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002047 return sprintf(buf, "%llu\n",
2048 (unsigned long long) rbd_dev->spec->pool_id);
Alex Elder9bb2f332012-07-12 10:46:35 -05002049}
2050
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002051static ssize_t rbd_name_show(struct device *dev,
2052 struct device_attribute *attr, char *buf)
2053{
Alex Elder593a9e72012-02-07 12:03:37 -06002054 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002055
Alex Eldera92ffdf2012-10-30 19:40:33 -05002056 if (rbd_dev->spec->image_name)
2057 return sprintf(buf, "%s\n", rbd_dev->spec->image_name);
2058
2059 return sprintf(buf, "(unknown)\n");
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002060}
2061
Alex Elder589d30e2012-07-10 20:30:11 -05002062static ssize_t rbd_image_id_show(struct device *dev,
2063 struct device_attribute *attr, char *buf)
2064{
2065 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2066
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002067 return sprintf(buf, "%s\n", rbd_dev->spec->image_id);
Alex Elder589d30e2012-07-10 20:30:11 -05002068}
2069
Alex Elder34b13182012-07-13 20:35:12 -05002070/*
2071 * Shows the name of the currently-mapped snapshot (or
2072 * RBD_SNAP_HEAD_NAME for the base image).
2073 */
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002074static ssize_t rbd_snap_show(struct device *dev,
2075 struct device_attribute *attr,
2076 char *buf)
2077{
Alex Elder593a9e72012-02-07 12:03:37 -06002078 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002079
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002080 return sprintf(buf, "%s\n", rbd_dev->spec->snap_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002081}
2082
Alex Elder86b00e02012-10-25 23:34:42 -05002083/*
2084 * For an rbd v2 image, shows the pool id, image id, and snapshot id
2085 * for the parent image. If there is no parent, simply shows
2086 * "(no parent image)".
2087 */
2088static ssize_t rbd_parent_show(struct device *dev,
2089 struct device_attribute *attr,
2090 char *buf)
2091{
2092 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2093 struct rbd_spec *spec = rbd_dev->parent_spec;
2094 int count;
2095 char *bufp = buf;
2096
2097 if (!spec)
2098 return sprintf(buf, "(no parent image)\n");
2099
2100 count = sprintf(bufp, "pool_id %llu\npool_name %s\n",
2101 (unsigned long long) spec->pool_id, spec->pool_name);
2102 if (count < 0)
2103 return count;
2104 bufp += count;
2105
2106 count = sprintf(bufp, "image_id %s\nimage_name %s\n", spec->image_id,
2107 spec->image_name ? spec->image_name : "(unknown)");
2108 if (count < 0)
2109 return count;
2110 bufp += count;
2111
2112 count = sprintf(bufp, "snap_id %llu\nsnap_name %s\n",
2113 (unsigned long long) spec->snap_id, spec->snap_name);
2114 if (count < 0)
2115 return count;
2116 bufp += count;
2117
2118 count = sprintf(bufp, "overlap %llu\n", rbd_dev->parent_overlap);
2119 if (count < 0)
2120 return count;
2121 bufp += count;
2122
2123 return (ssize_t) (bufp - buf);
2124}
2125
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002126static ssize_t rbd_image_refresh(struct device *dev,
2127 struct device_attribute *attr,
2128 const char *buf,
2129 size_t size)
2130{
Alex Elder593a9e72012-02-07 12:03:37 -06002131 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Alex Elderb8136232012-07-25 09:32:41 -05002132 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002133
Alex Elder117973f2012-08-31 17:29:55 -05002134 ret = rbd_dev_refresh(rbd_dev, NULL);
Alex Elderb8136232012-07-25 09:32:41 -05002135
2136 return ret < 0 ? ret : size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002137}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002138
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002139static DEVICE_ATTR(size, S_IRUGO, rbd_size_show, NULL);
Alex Elder34b13182012-07-13 20:35:12 -05002140static DEVICE_ATTR(features, S_IRUGO, rbd_features_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002141static DEVICE_ATTR(major, S_IRUGO, rbd_major_show, NULL);
2142static DEVICE_ATTR(client_id, S_IRUGO, rbd_client_id_show, NULL);
2143static DEVICE_ATTR(pool, S_IRUGO, rbd_pool_show, NULL);
Alex Elder9bb2f332012-07-12 10:46:35 -05002144static DEVICE_ATTR(pool_id, S_IRUGO, rbd_pool_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002145static DEVICE_ATTR(name, S_IRUGO, rbd_name_show, NULL);
Alex Elder589d30e2012-07-10 20:30:11 -05002146static DEVICE_ATTR(image_id, S_IRUGO, rbd_image_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002147static DEVICE_ATTR(refresh, S_IWUSR, NULL, rbd_image_refresh);
2148static DEVICE_ATTR(current_snap, S_IRUGO, rbd_snap_show, NULL);
Alex Elder86b00e02012-10-25 23:34:42 -05002149static DEVICE_ATTR(parent, S_IRUGO, rbd_parent_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002150
2151static struct attribute *rbd_attrs[] = {
2152 &dev_attr_size.attr,
Alex Elder34b13182012-07-13 20:35:12 -05002153 &dev_attr_features.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002154 &dev_attr_major.attr,
2155 &dev_attr_client_id.attr,
2156 &dev_attr_pool.attr,
Alex Elder9bb2f332012-07-12 10:46:35 -05002157 &dev_attr_pool_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002158 &dev_attr_name.attr,
Alex Elder589d30e2012-07-10 20:30:11 -05002159 &dev_attr_image_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002160 &dev_attr_current_snap.attr,
Alex Elder86b00e02012-10-25 23:34:42 -05002161 &dev_attr_parent.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002162 &dev_attr_refresh.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002163 NULL
2164};
2165
2166static struct attribute_group rbd_attr_group = {
2167 .attrs = rbd_attrs,
2168};
2169
2170static const struct attribute_group *rbd_attr_groups[] = {
2171 &rbd_attr_group,
2172 NULL
2173};
2174
2175static void rbd_sysfs_dev_release(struct device *dev)
2176{
2177}
2178
2179static struct device_type rbd_device_type = {
2180 .name = "rbd",
2181 .groups = rbd_attr_groups,
2182 .release = rbd_sysfs_dev_release,
2183};
2184
2185
2186/*
2187 sysfs - snapshots
2188*/
2189
2190static ssize_t rbd_snap_size_show(struct device *dev,
2191 struct device_attribute *attr,
2192 char *buf)
2193{
2194 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2195
Josh Durgin3591538f2011-12-05 18:25:13 -08002196 return sprintf(buf, "%llu\n", (unsigned long long)snap->size);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002197}
2198
2199static ssize_t rbd_snap_id_show(struct device *dev,
2200 struct device_attribute *attr,
2201 char *buf)
2202{
2203 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2204
Josh Durgin3591538f2011-12-05 18:25:13 -08002205 return sprintf(buf, "%llu\n", (unsigned long long)snap->id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002206}
2207
Alex Elder34b13182012-07-13 20:35:12 -05002208static ssize_t rbd_snap_features_show(struct device *dev,
2209 struct device_attribute *attr,
2210 char *buf)
2211{
2212 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2213
2214 return sprintf(buf, "0x%016llx\n",
2215 (unsigned long long) snap->features);
2216}
2217
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002218static DEVICE_ATTR(snap_size, S_IRUGO, rbd_snap_size_show, NULL);
2219static DEVICE_ATTR(snap_id, S_IRUGO, rbd_snap_id_show, NULL);
Alex Elder34b13182012-07-13 20:35:12 -05002220static DEVICE_ATTR(snap_features, S_IRUGO, rbd_snap_features_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002221
2222static struct attribute *rbd_snap_attrs[] = {
2223 &dev_attr_snap_size.attr,
2224 &dev_attr_snap_id.attr,
Alex Elder34b13182012-07-13 20:35:12 -05002225 &dev_attr_snap_features.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002226 NULL,
2227};
2228
2229static struct attribute_group rbd_snap_attr_group = {
2230 .attrs = rbd_snap_attrs,
2231};
2232
2233static void rbd_snap_dev_release(struct device *dev)
2234{
2235 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2236 kfree(snap->name);
2237 kfree(snap);
2238}
2239
2240static const struct attribute_group *rbd_snap_attr_groups[] = {
2241 &rbd_snap_attr_group,
2242 NULL
2243};
2244
2245static struct device_type rbd_snap_device_type = {
2246 .groups = rbd_snap_attr_groups,
2247 .release = rbd_snap_dev_release,
2248};
2249
Alex Elder8b8fb992012-10-26 17:25:24 -05002250static struct rbd_spec *rbd_spec_get(struct rbd_spec *spec)
2251{
2252 kref_get(&spec->kref);
2253
2254 return spec;
2255}
2256
2257static void rbd_spec_free(struct kref *kref);
2258static void rbd_spec_put(struct rbd_spec *spec)
2259{
2260 if (spec)
2261 kref_put(&spec->kref, rbd_spec_free);
2262}
2263
2264static struct rbd_spec *rbd_spec_alloc(void)
2265{
2266 struct rbd_spec *spec;
2267
2268 spec = kzalloc(sizeof (*spec), GFP_KERNEL);
2269 if (!spec)
2270 return NULL;
2271 kref_init(&spec->kref);
2272
2273 rbd_spec_put(rbd_spec_get(spec)); /* TEMPORARY */
2274
2275 return spec;
2276}
2277
2278static void rbd_spec_free(struct kref *kref)
2279{
2280 struct rbd_spec *spec = container_of(kref, struct rbd_spec, kref);
2281
2282 kfree(spec->pool_name);
2283 kfree(spec->image_id);
2284 kfree(spec->image_name);
2285 kfree(spec->snap_name);
2286 kfree(spec);
2287}
2288
Alex Elderc53d5892012-10-25 23:34:42 -05002289struct rbd_device *rbd_dev_create(struct rbd_client *rbdc,
2290 struct rbd_spec *spec)
2291{
2292 struct rbd_device *rbd_dev;
2293
2294 rbd_dev = kzalloc(sizeof (*rbd_dev), GFP_KERNEL);
2295 if (!rbd_dev)
2296 return NULL;
2297
2298 spin_lock_init(&rbd_dev->lock);
2299 INIT_LIST_HEAD(&rbd_dev->node);
2300 INIT_LIST_HEAD(&rbd_dev->snaps);
2301 init_rwsem(&rbd_dev->header_rwsem);
2302
2303 rbd_dev->spec = spec;
2304 rbd_dev->rbd_client = rbdc;
2305
2306 return rbd_dev;
2307}
2308
2309static void rbd_dev_destroy(struct rbd_device *rbd_dev)
2310{
Alex Elder86b00e02012-10-25 23:34:42 -05002311 rbd_spec_put(rbd_dev->parent_spec);
Alex Elderc53d5892012-10-25 23:34:42 -05002312 kfree(rbd_dev->header_name);
2313 rbd_put_client(rbd_dev->rbd_client);
2314 rbd_spec_put(rbd_dev->spec);
2315 kfree(rbd_dev);
2316}
2317
Alex Elder304f6802012-08-31 17:29:52 -05002318static bool rbd_snap_registered(struct rbd_snap *snap)
2319{
2320 bool ret = snap->dev.type == &rbd_snap_device_type;
2321 bool reg = device_is_registered(&snap->dev);
2322
2323 rbd_assert(!ret ^ reg);
2324
2325 return ret;
2326}
2327
Alex Elder41f38c22012-10-25 23:34:40 -05002328static void rbd_remove_snap_dev(struct rbd_snap *snap)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002329{
2330 list_del(&snap->node);
Alex Elder304f6802012-08-31 17:29:52 -05002331 if (device_is_registered(&snap->dev))
2332 device_unregister(&snap->dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002333}
2334
Alex Elder14e70852012-07-19 09:09:27 -05002335static int rbd_register_snap_dev(struct rbd_snap *snap,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002336 struct device *parent)
2337{
2338 struct device *dev = &snap->dev;
2339 int ret;
2340
2341 dev->type = &rbd_snap_device_type;
2342 dev->parent = parent;
2343 dev->release = rbd_snap_dev_release;
Alex Elderd4b125e2012-07-03 16:01:19 -05002344 dev_set_name(dev, "%s%s", RBD_SNAP_DEV_NAME_PREFIX, snap->name);
Alex Elder304f6802012-08-31 17:29:52 -05002345 dout("%s: registering device for snapshot %s\n", __func__, snap->name);
2346
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002347 ret = device_register(dev);
2348
2349 return ret;
2350}
2351
Alex Elder4e891e02012-07-10 20:30:10 -05002352static struct rbd_snap *__rbd_add_snap_dev(struct rbd_device *rbd_dev,
Alex Elderc8d18422012-07-10 20:30:11 -05002353 const char *snap_name,
Alex Elder34b13182012-07-13 20:35:12 -05002354 u64 snap_id, u64 snap_size,
2355 u64 snap_features)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002356{
Alex Elder4e891e02012-07-10 20:30:10 -05002357 struct rbd_snap *snap;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002358 int ret;
Alex Elder4e891e02012-07-10 20:30:10 -05002359
2360 snap = kzalloc(sizeof (*snap), GFP_KERNEL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002361 if (!snap)
Alex Elder4e891e02012-07-10 20:30:10 -05002362 return ERR_PTR(-ENOMEM);
2363
2364 ret = -ENOMEM;
Alex Elderc8d18422012-07-10 20:30:11 -05002365 snap->name = kstrdup(snap_name, GFP_KERNEL);
Alex Elder4e891e02012-07-10 20:30:10 -05002366 if (!snap->name)
2367 goto err;
2368
Alex Elderc8d18422012-07-10 20:30:11 -05002369 snap->id = snap_id;
2370 snap->size = snap_size;
Alex Elder34b13182012-07-13 20:35:12 -05002371 snap->features = snap_features;
Alex Elder4e891e02012-07-10 20:30:10 -05002372
2373 return snap;
2374
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002375err:
2376 kfree(snap->name);
2377 kfree(snap);
Alex Elder4e891e02012-07-10 20:30:10 -05002378
2379 return ERR_PTR(ret);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002380}
2381
Alex Eldercd892122012-07-03 16:01:19 -05002382static char *rbd_dev_v1_snap_info(struct rbd_device *rbd_dev, u32 which,
2383 u64 *snap_size, u64 *snap_features)
2384{
2385 char *snap_name;
2386
2387 rbd_assert(which < rbd_dev->header.snapc->num_snaps);
2388
2389 *snap_size = rbd_dev->header.snap_sizes[which];
2390 *snap_features = 0; /* No features for v1 */
2391
2392 /* Skip over names until we find the one we are looking for */
2393
2394 snap_name = rbd_dev->header.snap_names;
2395 while (which--)
2396 snap_name += strlen(snap_name) + 1;
2397
2398 return snap_name;
2399}
2400
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002401/*
Alex Elder9d475de2012-07-03 16:01:19 -05002402 * Get the size and object order for an image snapshot, or if
2403 * snap_id is CEPH_NOSNAP, gets this information for the base
2404 * image.
2405 */
2406static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
2407 u8 *order, u64 *snap_size)
2408{
2409 __le64 snapid = cpu_to_le64(snap_id);
2410 int ret;
2411 struct {
2412 u8 order;
2413 __le64 size;
2414 } __attribute__ ((packed)) size_buf = { 0 };
2415
2416 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2417 "rbd", "get_size",
2418 (char *) &snapid, sizeof (snapid),
2419 (char *) &size_buf, sizeof (size_buf),
2420 CEPH_OSD_FLAG_READ, NULL);
2421 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2422 if (ret < 0)
2423 return ret;
2424
2425 *order = size_buf.order;
2426 *snap_size = le64_to_cpu(size_buf.size);
2427
2428 dout(" snap_id 0x%016llx order = %u, snap_size = %llu\n",
2429 (unsigned long long) snap_id, (unsigned int) *order,
2430 (unsigned long long) *snap_size);
2431
2432 return 0;
2433}
2434
2435static int rbd_dev_v2_image_size(struct rbd_device *rbd_dev)
2436{
2437 return _rbd_dev_v2_snap_size(rbd_dev, CEPH_NOSNAP,
2438 &rbd_dev->header.obj_order,
2439 &rbd_dev->header.image_size);
2440}
2441
Alex Elder1e130192012-07-03 16:01:19 -05002442static int rbd_dev_v2_object_prefix(struct rbd_device *rbd_dev)
2443{
2444 void *reply_buf;
2445 int ret;
2446 void *p;
2447
2448 reply_buf = kzalloc(RBD_OBJ_PREFIX_LEN_MAX, GFP_KERNEL);
2449 if (!reply_buf)
2450 return -ENOMEM;
2451
2452 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2453 "rbd", "get_object_prefix",
2454 NULL, 0,
2455 reply_buf, RBD_OBJ_PREFIX_LEN_MAX,
2456 CEPH_OSD_FLAG_READ, NULL);
2457 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2458 if (ret < 0)
2459 goto out;
Alex Eldera0ea3a42012-10-10 21:19:13 -07002460 ret = 0; /* rbd_req_sync_exec() can return positive */
Alex Elder1e130192012-07-03 16:01:19 -05002461
2462 p = reply_buf;
2463 rbd_dev->header.object_prefix = ceph_extract_encoded_string(&p,
2464 p + RBD_OBJ_PREFIX_LEN_MAX,
2465 NULL, GFP_NOIO);
2466
2467 if (IS_ERR(rbd_dev->header.object_prefix)) {
2468 ret = PTR_ERR(rbd_dev->header.object_prefix);
2469 rbd_dev->header.object_prefix = NULL;
2470 } else {
2471 dout(" object_prefix = %s\n", rbd_dev->header.object_prefix);
2472 }
2473
2474out:
2475 kfree(reply_buf);
2476
2477 return ret;
2478}
2479
Alex Elderb1b54022012-07-03 16:01:19 -05002480static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
2481 u64 *snap_features)
2482{
2483 __le64 snapid = cpu_to_le64(snap_id);
2484 struct {
2485 __le64 features;
2486 __le64 incompat;
2487 } features_buf = { 0 };
Alex Elderd8891402012-10-09 13:50:17 -07002488 u64 incompat;
Alex Elderb1b54022012-07-03 16:01:19 -05002489 int ret;
2490
2491 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2492 "rbd", "get_features",
2493 (char *) &snapid, sizeof (snapid),
2494 (char *) &features_buf, sizeof (features_buf),
2495 CEPH_OSD_FLAG_READ, NULL);
2496 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2497 if (ret < 0)
2498 return ret;
Alex Elderd8891402012-10-09 13:50:17 -07002499
2500 incompat = le64_to_cpu(features_buf.incompat);
2501 if (incompat & ~RBD_FEATURES_ALL)
Alex Elderb8f5c6e2012-11-01 08:39:26 -05002502 return -ENXIO;
Alex Elderd8891402012-10-09 13:50:17 -07002503
Alex Elderb1b54022012-07-03 16:01:19 -05002504 *snap_features = le64_to_cpu(features_buf.features);
2505
2506 dout(" snap_id 0x%016llx features = 0x%016llx incompat = 0x%016llx\n",
2507 (unsigned long long) snap_id,
2508 (unsigned long long) *snap_features,
2509 (unsigned long long) le64_to_cpu(features_buf.incompat));
2510
2511 return 0;
2512}
2513
2514static int rbd_dev_v2_features(struct rbd_device *rbd_dev)
2515{
2516 return _rbd_dev_v2_snap_features(rbd_dev, CEPH_NOSNAP,
2517 &rbd_dev->header.features);
2518}
2519
Alex Elder86b00e02012-10-25 23:34:42 -05002520static int rbd_dev_v2_parent_info(struct rbd_device *rbd_dev)
2521{
2522 struct rbd_spec *parent_spec;
2523 size_t size;
2524 void *reply_buf = NULL;
2525 __le64 snapid;
2526 void *p;
2527 void *end;
2528 char *image_id;
2529 u64 overlap;
Alex Elder86b00e02012-10-25 23:34:42 -05002530 int ret;
2531
2532 parent_spec = rbd_spec_alloc();
2533 if (!parent_spec)
2534 return -ENOMEM;
2535
2536 size = sizeof (__le64) + /* pool_id */
2537 sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX + /* image_id */
2538 sizeof (__le64) + /* snap_id */
2539 sizeof (__le64); /* overlap */
2540 reply_buf = kmalloc(size, GFP_KERNEL);
2541 if (!reply_buf) {
2542 ret = -ENOMEM;
2543 goto out_err;
2544 }
2545
2546 snapid = cpu_to_le64(CEPH_NOSNAP);
2547 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2548 "rbd", "get_parent",
2549 (char *) &snapid, sizeof (snapid),
2550 (char *) reply_buf, size,
2551 CEPH_OSD_FLAG_READ, NULL);
2552 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2553 if (ret < 0)
2554 goto out_err;
2555
2556 ret = -ERANGE;
2557 p = reply_buf;
2558 end = (char *) reply_buf + size;
2559 ceph_decode_64_safe(&p, end, parent_spec->pool_id, out_err);
2560 if (parent_spec->pool_id == CEPH_NOPOOL)
2561 goto out; /* No parent? No problem. */
2562
Alex Elder979ed482012-11-01 08:39:26 -05002563 image_id = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
Alex Elder86b00e02012-10-25 23:34:42 -05002564 if (IS_ERR(image_id)) {
2565 ret = PTR_ERR(image_id);
2566 goto out_err;
2567 }
2568 parent_spec->image_id = image_id;
2569 ceph_decode_64_safe(&p, end, parent_spec->snap_id, out_err);
2570 ceph_decode_64_safe(&p, end, overlap, out_err);
2571
2572 rbd_dev->parent_overlap = overlap;
2573 rbd_dev->parent_spec = parent_spec;
2574 parent_spec = NULL; /* rbd_dev now owns this */
2575out:
2576 ret = 0;
2577out_err:
2578 kfree(reply_buf);
2579 rbd_spec_put(parent_spec);
2580
2581 return ret;
2582}
2583
Alex Elder9e15b772012-10-30 19:40:33 -05002584static char *rbd_dev_image_name(struct rbd_device *rbd_dev)
2585{
2586 size_t image_id_size;
2587 char *image_id;
2588 void *p;
2589 void *end;
2590 size_t size;
2591 void *reply_buf = NULL;
2592 size_t len = 0;
2593 char *image_name = NULL;
2594 int ret;
2595
2596 rbd_assert(!rbd_dev->spec->image_name);
2597
Alex Elder69e7a022012-11-01 08:39:26 -05002598 len = strlen(rbd_dev->spec->image_id);
2599 image_id_size = sizeof (__le32) + len;
Alex Elder9e15b772012-10-30 19:40:33 -05002600 image_id = kmalloc(image_id_size, GFP_KERNEL);
2601 if (!image_id)
2602 return NULL;
2603
2604 p = image_id;
2605 end = (char *) image_id + image_id_size;
Alex Elder69e7a022012-11-01 08:39:26 -05002606 ceph_encode_string(&p, end, rbd_dev->spec->image_id, (u32) len);
Alex Elder9e15b772012-10-30 19:40:33 -05002607
2608 size = sizeof (__le32) + RBD_IMAGE_NAME_LEN_MAX;
2609 reply_buf = kmalloc(size, GFP_KERNEL);
2610 if (!reply_buf)
2611 goto out;
2612
2613 ret = rbd_req_sync_exec(rbd_dev, RBD_DIRECTORY,
2614 "rbd", "dir_get_name",
2615 image_id, image_id_size,
2616 (char *) reply_buf, size,
2617 CEPH_OSD_FLAG_READ, NULL);
2618 if (ret < 0)
2619 goto out;
2620 p = reply_buf;
2621 end = (char *) reply_buf + size;
2622 image_name = ceph_extract_encoded_string(&p, end, &len, GFP_KERNEL);
2623 if (IS_ERR(image_name))
2624 image_name = NULL;
2625 else
2626 dout("%s: name is %s len is %zd\n", __func__, image_name, len);
2627out:
2628 kfree(reply_buf);
2629 kfree(image_id);
2630
2631 return image_name;
2632}
2633
2634/*
2635 * When a parent image gets probed, we only have the pool, image,
2636 * and snapshot ids but not the names of any of them. This call
2637 * is made later to fill in those names. It has to be done after
2638 * rbd_dev_snaps_update() has completed because some of the
2639 * information (in particular, snapshot name) is not available
2640 * until then.
2641 */
2642static int rbd_dev_probe_update_spec(struct rbd_device *rbd_dev)
2643{
2644 struct ceph_osd_client *osdc;
2645 const char *name;
2646 void *reply_buf = NULL;
2647 int ret;
2648
2649 if (rbd_dev->spec->pool_name)
2650 return 0; /* Already have the names */
2651
2652 /* Look up the pool name */
2653
2654 osdc = &rbd_dev->rbd_client->client->osdc;
2655 name = ceph_pg_pool_name_by_id(osdc->osdmap, rbd_dev->spec->pool_id);
Alex Elder935dc892012-11-01 10:17:15 -05002656 if (!name) {
2657 rbd_warn(rbd_dev, "there is no pool with id %llu",
2658 rbd_dev->spec->pool_id); /* Really a BUG() */
2659 return -EIO;
2660 }
Alex Elder9e15b772012-10-30 19:40:33 -05002661
2662 rbd_dev->spec->pool_name = kstrdup(name, GFP_KERNEL);
2663 if (!rbd_dev->spec->pool_name)
2664 return -ENOMEM;
2665
2666 /* Fetch the image name; tolerate failure here */
2667
2668 name = rbd_dev_image_name(rbd_dev);
Alex Elder69e7a022012-11-01 08:39:26 -05002669 if (name)
Alex Elder9e15b772012-10-30 19:40:33 -05002670 rbd_dev->spec->image_name = (char *) name;
Alex Elder69e7a022012-11-01 08:39:26 -05002671 else
Alex Elder06ecc6c2012-11-01 10:17:15 -05002672 rbd_warn(rbd_dev, "unable to get image name");
Alex Elder9e15b772012-10-30 19:40:33 -05002673
2674 /* Look up the snapshot name. */
2675
2676 name = rbd_snap_name(rbd_dev, rbd_dev->spec->snap_id);
2677 if (!name) {
Alex Elder935dc892012-11-01 10:17:15 -05002678 rbd_warn(rbd_dev, "no snapshot with id %llu",
2679 rbd_dev->spec->snap_id); /* Really a BUG() */
Alex Elder9e15b772012-10-30 19:40:33 -05002680 ret = -EIO;
2681 goto out_err;
2682 }
2683 rbd_dev->spec->snap_name = kstrdup(name, GFP_KERNEL);
2684 if(!rbd_dev->spec->snap_name)
2685 goto out_err;
2686
2687 return 0;
2688out_err:
2689 kfree(reply_buf);
2690 kfree(rbd_dev->spec->pool_name);
2691 rbd_dev->spec->pool_name = NULL;
2692
2693 return ret;
2694}
2695
Alex Elder6e14b1a2012-07-03 16:01:19 -05002696static int rbd_dev_v2_snap_context(struct rbd_device *rbd_dev, u64 *ver)
Alex Elder35d489f2012-07-03 16:01:19 -05002697{
2698 size_t size;
2699 int ret;
2700 void *reply_buf;
2701 void *p;
2702 void *end;
2703 u64 seq;
2704 u32 snap_count;
2705 struct ceph_snap_context *snapc;
2706 u32 i;
2707
2708 /*
2709 * We'll need room for the seq value (maximum snapshot id),
2710 * snapshot count, and array of that many snapshot ids.
2711 * For now we have a fixed upper limit on the number we're
2712 * prepared to receive.
2713 */
2714 size = sizeof (__le64) + sizeof (__le32) +
2715 RBD_MAX_SNAP_COUNT * sizeof (__le64);
2716 reply_buf = kzalloc(size, GFP_KERNEL);
2717 if (!reply_buf)
2718 return -ENOMEM;
2719
2720 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2721 "rbd", "get_snapcontext",
2722 NULL, 0,
2723 reply_buf, size,
Alex Elder6e14b1a2012-07-03 16:01:19 -05002724 CEPH_OSD_FLAG_READ, ver);
Alex Elder35d489f2012-07-03 16:01:19 -05002725 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2726 if (ret < 0)
2727 goto out;
2728
2729 ret = -ERANGE;
2730 p = reply_buf;
2731 end = (char *) reply_buf + size;
2732 ceph_decode_64_safe(&p, end, seq, out);
2733 ceph_decode_32_safe(&p, end, snap_count, out);
2734
2735 /*
2736 * Make sure the reported number of snapshot ids wouldn't go
2737 * beyond the end of our buffer. But before checking that,
2738 * make sure the computed size of the snapshot context we
2739 * allocate is representable in a size_t.
2740 */
2741 if (snap_count > (SIZE_MAX - sizeof (struct ceph_snap_context))
2742 / sizeof (u64)) {
2743 ret = -EINVAL;
2744 goto out;
2745 }
2746 if (!ceph_has_room(&p, end, snap_count * sizeof (__le64)))
2747 goto out;
2748
2749 size = sizeof (struct ceph_snap_context) +
2750 snap_count * sizeof (snapc->snaps[0]);
2751 snapc = kmalloc(size, GFP_KERNEL);
2752 if (!snapc) {
2753 ret = -ENOMEM;
2754 goto out;
2755 }
2756
2757 atomic_set(&snapc->nref, 1);
2758 snapc->seq = seq;
2759 snapc->num_snaps = snap_count;
2760 for (i = 0; i < snap_count; i++)
2761 snapc->snaps[i] = ceph_decode_64(&p);
2762
2763 rbd_dev->header.snapc = snapc;
2764
2765 dout(" snap context seq = %llu, snap_count = %u\n",
2766 (unsigned long long) seq, (unsigned int) snap_count);
2767
2768out:
2769 kfree(reply_buf);
2770
2771 return 0;
2772}
2773
Alex Elderb8b1e2d2012-07-03 16:01:19 -05002774static char *rbd_dev_v2_snap_name(struct rbd_device *rbd_dev, u32 which)
2775{
2776 size_t size;
2777 void *reply_buf;
2778 __le64 snap_id;
2779 int ret;
2780 void *p;
2781 void *end;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05002782 char *snap_name;
2783
2784 size = sizeof (__le32) + RBD_MAX_SNAP_NAME_LEN;
2785 reply_buf = kmalloc(size, GFP_KERNEL);
2786 if (!reply_buf)
2787 return ERR_PTR(-ENOMEM);
2788
2789 snap_id = cpu_to_le64(rbd_dev->header.snapc->snaps[which]);
2790 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2791 "rbd", "get_snapshot_name",
2792 (char *) &snap_id, sizeof (snap_id),
2793 reply_buf, size,
2794 CEPH_OSD_FLAG_READ, NULL);
2795 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2796 if (ret < 0)
2797 goto out;
2798
2799 p = reply_buf;
2800 end = (char *) reply_buf + size;
Alex Eldere5c35532012-10-25 23:34:41 -05002801 snap_name = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05002802 if (IS_ERR(snap_name)) {
2803 ret = PTR_ERR(snap_name);
2804 goto out;
2805 } else {
2806 dout(" snap_id 0x%016llx snap_name = %s\n",
2807 (unsigned long long) le64_to_cpu(snap_id), snap_name);
2808 }
2809 kfree(reply_buf);
2810
2811 return snap_name;
2812out:
2813 kfree(reply_buf);
2814
2815 return ERR_PTR(ret);
2816}
2817
2818static char *rbd_dev_v2_snap_info(struct rbd_device *rbd_dev, u32 which,
2819 u64 *snap_size, u64 *snap_features)
2820{
2821 __le64 snap_id;
2822 u8 order;
2823 int ret;
2824
2825 snap_id = rbd_dev->header.snapc->snaps[which];
2826 ret = _rbd_dev_v2_snap_size(rbd_dev, snap_id, &order, snap_size);
2827 if (ret)
2828 return ERR_PTR(ret);
2829 ret = _rbd_dev_v2_snap_features(rbd_dev, snap_id, snap_features);
2830 if (ret)
2831 return ERR_PTR(ret);
2832
2833 return rbd_dev_v2_snap_name(rbd_dev, which);
2834}
2835
2836static char *rbd_dev_snap_info(struct rbd_device *rbd_dev, u32 which,
2837 u64 *snap_size, u64 *snap_features)
2838{
2839 if (rbd_dev->image_format == 1)
2840 return rbd_dev_v1_snap_info(rbd_dev, which,
2841 snap_size, snap_features);
2842 if (rbd_dev->image_format == 2)
2843 return rbd_dev_v2_snap_info(rbd_dev, which,
2844 snap_size, snap_features);
2845 return ERR_PTR(-EINVAL);
2846}
2847
Alex Elder117973f2012-08-31 17:29:55 -05002848static int rbd_dev_v2_refresh(struct rbd_device *rbd_dev, u64 *hver)
2849{
2850 int ret;
2851 __u8 obj_order;
2852
2853 down_write(&rbd_dev->header_rwsem);
2854
2855 /* Grab old order first, to see if it changes */
2856
2857 obj_order = rbd_dev->header.obj_order,
2858 ret = rbd_dev_v2_image_size(rbd_dev);
2859 if (ret)
2860 goto out;
2861 if (rbd_dev->header.obj_order != obj_order) {
2862 ret = -EIO;
2863 goto out;
2864 }
2865 rbd_update_mapping_size(rbd_dev);
2866
2867 ret = rbd_dev_v2_snap_context(rbd_dev, hver);
2868 dout("rbd_dev_v2_snap_context returned %d\n", ret);
2869 if (ret)
2870 goto out;
2871 ret = rbd_dev_snaps_update(rbd_dev);
2872 dout("rbd_dev_snaps_update returned %d\n", ret);
2873 if (ret)
2874 goto out;
2875 ret = rbd_dev_snaps_register(rbd_dev);
2876 dout("rbd_dev_snaps_register returned %d\n", ret);
2877out:
2878 up_write(&rbd_dev->header_rwsem);
2879
2880 return ret;
2881}
2882
Alex Elder9d475de2012-07-03 16:01:19 -05002883/*
Alex Elder35938152012-08-02 11:29:46 -05002884 * Scan the rbd device's current snapshot list and compare it to the
2885 * newly-received snapshot context. Remove any existing snapshots
2886 * not present in the new snapshot context. Add a new snapshot for
2887 * any snaphots in the snapshot context not in the current list.
2888 * And verify there are no changes to snapshots we already know
2889 * about.
2890 *
2891 * Assumes the snapshots in the snapshot context are sorted by
2892 * snapshot id, highest id first. (Snapshots in the rbd_dev's list
2893 * are also maintained in that order.)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002894 */
Alex Elder304f6802012-08-31 17:29:52 -05002895static int rbd_dev_snaps_update(struct rbd_device *rbd_dev)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002896{
Alex Elder35938152012-08-02 11:29:46 -05002897 struct ceph_snap_context *snapc = rbd_dev->header.snapc;
2898 const u32 snap_count = snapc->num_snaps;
Alex Elder35938152012-08-02 11:29:46 -05002899 struct list_head *head = &rbd_dev->snaps;
2900 struct list_head *links = head->next;
2901 u32 index = 0;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002902
Alex Elder9fcbb802012-08-23 23:48:49 -05002903 dout("%s: snap count is %u\n", __func__, (unsigned int) snap_count);
Alex Elder35938152012-08-02 11:29:46 -05002904 while (index < snap_count || links != head) {
2905 u64 snap_id;
2906 struct rbd_snap *snap;
Alex Eldercd892122012-07-03 16:01:19 -05002907 char *snap_name;
2908 u64 snap_size = 0;
2909 u64 snap_features = 0;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002910
Alex Elder35938152012-08-02 11:29:46 -05002911 snap_id = index < snap_count ? snapc->snaps[index]
2912 : CEPH_NOSNAP;
2913 snap = links != head ? list_entry(links, struct rbd_snap, node)
2914 : NULL;
Alex Elderaafb2302012-09-06 16:00:54 -05002915 rbd_assert(!snap || snap->id != CEPH_NOSNAP);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002916
Alex Elder35938152012-08-02 11:29:46 -05002917 if (snap_id == CEPH_NOSNAP || (snap && snap->id > snap_id)) {
2918 struct list_head *next = links->next;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002919
Alex Elder35938152012-08-02 11:29:46 -05002920 /* Existing snapshot not in the new snap context */
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002921
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002922 if (rbd_dev->spec->snap_id == snap->id)
Alex Elderdaba5fd2012-10-26 17:25:23 -05002923 rbd_dev->exists = false;
Alex Elder41f38c22012-10-25 23:34:40 -05002924 rbd_remove_snap_dev(snap);
Alex Elder9fcbb802012-08-23 23:48:49 -05002925 dout("%ssnap id %llu has been removed\n",
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002926 rbd_dev->spec->snap_id == snap->id ?
2927 "mapped " : "",
Alex Elder9fcbb802012-08-23 23:48:49 -05002928 (unsigned long long) snap->id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002929
Alex Elder35938152012-08-02 11:29:46 -05002930 /* Done with this list entry; advance */
2931
2932 links = next;
2933 continue;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002934 }
Alex Elder35938152012-08-02 11:29:46 -05002935
Alex Elderb8b1e2d2012-07-03 16:01:19 -05002936 snap_name = rbd_dev_snap_info(rbd_dev, index,
2937 &snap_size, &snap_features);
Alex Eldercd892122012-07-03 16:01:19 -05002938 if (IS_ERR(snap_name))
2939 return PTR_ERR(snap_name);
2940
Alex Elder9fcbb802012-08-23 23:48:49 -05002941 dout("entry %u: snap_id = %llu\n", (unsigned int) snap_count,
2942 (unsigned long long) snap_id);
Alex Elder35938152012-08-02 11:29:46 -05002943 if (!snap || (snap_id != CEPH_NOSNAP && snap->id < snap_id)) {
2944 struct rbd_snap *new_snap;
2945
2946 /* We haven't seen this snapshot before */
2947
Alex Elderc8d18422012-07-10 20:30:11 -05002948 new_snap = __rbd_add_snap_dev(rbd_dev, snap_name,
Alex Eldercd892122012-07-03 16:01:19 -05002949 snap_id, snap_size, snap_features);
Alex Elder9fcbb802012-08-23 23:48:49 -05002950 if (IS_ERR(new_snap)) {
2951 int err = PTR_ERR(new_snap);
2952
2953 dout(" failed to add dev, error %d\n", err);
2954
2955 return err;
2956 }
Alex Elder35938152012-08-02 11:29:46 -05002957
2958 /* New goes before existing, or at end of list */
2959
Alex Elder9fcbb802012-08-23 23:48:49 -05002960 dout(" added dev%s\n", snap ? "" : " at end\n");
Alex Elder35938152012-08-02 11:29:46 -05002961 if (snap)
2962 list_add_tail(&new_snap->node, &snap->node);
2963 else
Alex Elder523f3252012-08-30 00:16:37 -05002964 list_add_tail(&new_snap->node, head);
Alex Elder35938152012-08-02 11:29:46 -05002965 } else {
2966 /* Already have this one */
2967
Alex Elder9fcbb802012-08-23 23:48:49 -05002968 dout(" already present\n");
2969
Alex Eldercd892122012-07-03 16:01:19 -05002970 rbd_assert(snap->size == snap_size);
Alex Elderaafb2302012-09-06 16:00:54 -05002971 rbd_assert(!strcmp(snap->name, snap_name));
Alex Eldercd892122012-07-03 16:01:19 -05002972 rbd_assert(snap->features == snap_features);
Alex Elder35938152012-08-02 11:29:46 -05002973
2974 /* Done with this list entry; advance */
2975
2976 links = links->next;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002977 }
Alex Elder35938152012-08-02 11:29:46 -05002978
2979 /* Advance to the next entry in the snapshot context */
2980
2981 index++;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002982 }
Alex Elder9fcbb802012-08-23 23:48:49 -05002983 dout("%s: done\n", __func__);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002984
2985 return 0;
2986}
2987
Alex Elder304f6802012-08-31 17:29:52 -05002988/*
2989 * Scan the list of snapshots and register the devices for any that
2990 * have not already been registered.
2991 */
2992static int rbd_dev_snaps_register(struct rbd_device *rbd_dev)
2993{
2994 struct rbd_snap *snap;
2995 int ret = 0;
2996
2997 dout("%s called\n", __func__);
Alex Elder86ff77b2012-08-31 17:29:53 -05002998 if (WARN_ON(!device_is_registered(&rbd_dev->dev)))
2999 return -EIO;
Alex Elder304f6802012-08-31 17:29:52 -05003000
3001 list_for_each_entry(snap, &rbd_dev->snaps, node) {
3002 if (!rbd_snap_registered(snap)) {
3003 ret = rbd_register_snap_dev(snap, &rbd_dev->dev);
3004 if (ret < 0)
3005 break;
3006 }
3007 }
3008 dout("%s: returning %d\n", __func__, ret);
3009
3010 return ret;
3011}
3012
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003013static int rbd_bus_add_dev(struct rbd_device *rbd_dev)
3014{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003015 struct device *dev;
Alex Eldercd789ab2012-08-30 00:16:38 -05003016 int ret;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003017
3018 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003019
Alex Eldercd789ab2012-08-30 00:16:38 -05003020 dev = &rbd_dev->dev;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003021 dev->bus = &rbd_bus_type;
3022 dev->type = &rbd_device_type;
3023 dev->parent = &rbd_root_dev;
3024 dev->release = rbd_dev_release;
Alex Elderde71a292012-07-03 16:01:19 -05003025 dev_set_name(dev, "%d", rbd_dev->dev_id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003026 ret = device_register(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003027
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003028 mutex_unlock(&ctl_mutex);
Alex Eldercd789ab2012-08-30 00:16:38 -05003029
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003030 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003031}
3032
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003033static void rbd_bus_del_dev(struct rbd_device *rbd_dev)
3034{
3035 device_unregister(&rbd_dev->dev);
3036}
3037
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003038static int rbd_init_watch_dev(struct rbd_device *rbd_dev)
3039{
3040 int ret, rc;
3041
3042 do {
Alex Elder0e6f3222012-07-25 09:32:40 -05003043 ret = rbd_req_sync_watch(rbd_dev);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003044 if (ret == -ERANGE) {
Alex Elder117973f2012-08-31 17:29:55 -05003045 rc = rbd_dev_refresh(rbd_dev, NULL);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003046 if (rc < 0)
3047 return rc;
3048 }
3049 } while (ret == -ERANGE);
3050
3051 return ret;
3052}
3053
Alex Eldere2839302012-08-29 17:11:06 -05003054static atomic64_t rbd_dev_id_max = ATOMIC64_INIT(0);
Alex Elder1ddbe942012-01-29 13:57:44 -06003055
3056/*
Alex Elder499afd52012-02-02 08:13:29 -06003057 * Get a unique rbd identifier for the given new rbd_dev, and add
3058 * the rbd_dev to the global list. The minimum rbd id is 1.
Alex Elder1ddbe942012-01-29 13:57:44 -06003059 */
Alex Eldere2839302012-08-29 17:11:06 -05003060static void rbd_dev_id_get(struct rbd_device *rbd_dev)
Alex Elderb7f23c32012-01-29 13:57:43 -06003061{
Alex Eldere2839302012-08-29 17:11:06 -05003062 rbd_dev->dev_id = atomic64_inc_return(&rbd_dev_id_max);
Alex Elder499afd52012-02-02 08:13:29 -06003063
3064 spin_lock(&rbd_dev_list_lock);
3065 list_add_tail(&rbd_dev->node, &rbd_dev_list);
3066 spin_unlock(&rbd_dev_list_lock);
Alex Eldere2839302012-08-29 17:11:06 -05003067 dout("rbd_dev %p given dev id %llu\n", rbd_dev,
3068 (unsigned long long) rbd_dev->dev_id);
Alex Elder1ddbe942012-01-29 13:57:44 -06003069}
Alex Elderb7f23c32012-01-29 13:57:43 -06003070
Alex Elder1ddbe942012-01-29 13:57:44 -06003071/*
Alex Elder499afd52012-02-02 08:13:29 -06003072 * Remove an rbd_dev from the global list, and record that its
3073 * identifier is no longer in use.
Alex Elder1ddbe942012-01-29 13:57:44 -06003074 */
Alex Eldere2839302012-08-29 17:11:06 -05003075static void rbd_dev_id_put(struct rbd_device *rbd_dev)
Alex Elder1ddbe942012-01-29 13:57:44 -06003076{
Alex Elderd184f6b2012-01-29 13:57:44 -06003077 struct list_head *tmp;
Alex Elderde71a292012-07-03 16:01:19 -05003078 int rbd_id = rbd_dev->dev_id;
Alex Elderd184f6b2012-01-29 13:57:44 -06003079 int max_id;
3080
Alex Elderaafb2302012-09-06 16:00:54 -05003081 rbd_assert(rbd_id > 0);
Alex Elder499afd52012-02-02 08:13:29 -06003082
Alex Eldere2839302012-08-29 17:11:06 -05003083 dout("rbd_dev %p released dev id %llu\n", rbd_dev,
3084 (unsigned long long) rbd_dev->dev_id);
Alex Elder499afd52012-02-02 08:13:29 -06003085 spin_lock(&rbd_dev_list_lock);
3086 list_del_init(&rbd_dev->node);
Alex Elderd184f6b2012-01-29 13:57:44 -06003087
3088 /*
3089 * If the id being "put" is not the current maximum, there
3090 * is nothing special we need to do.
3091 */
Alex Eldere2839302012-08-29 17:11:06 -05003092 if (rbd_id != atomic64_read(&rbd_dev_id_max)) {
Alex Elderd184f6b2012-01-29 13:57:44 -06003093 spin_unlock(&rbd_dev_list_lock);
3094 return;
3095 }
3096
3097 /*
3098 * We need to update the current maximum id. Search the
3099 * list to find out what it is. We're more likely to find
3100 * the maximum at the end, so search the list backward.
3101 */
3102 max_id = 0;
3103 list_for_each_prev(tmp, &rbd_dev_list) {
3104 struct rbd_device *rbd_dev;
3105
3106 rbd_dev = list_entry(tmp, struct rbd_device, node);
Alex Elderb213e0b2012-10-10 21:19:13 -07003107 if (rbd_dev->dev_id > max_id)
3108 max_id = rbd_dev->dev_id;
Alex Elderd184f6b2012-01-29 13:57:44 -06003109 }
Alex Elder499afd52012-02-02 08:13:29 -06003110 spin_unlock(&rbd_dev_list_lock);
Alex Elderb7f23c32012-01-29 13:57:43 -06003111
Alex Elder1ddbe942012-01-29 13:57:44 -06003112 /*
Alex Eldere2839302012-08-29 17:11:06 -05003113 * The max id could have been updated by rbd_dev_id_get(), in
Alex Elderd184f6b2012-01-29 13:57:44 -06003114 * which case it now accurately reflects the new maximum.
3115 * Be careful not to overwrite the maximum value in that
3116 * case.
Alex Elder1ddbe942012-01-29 13:57:44 -06003117 */
Alex Eldere2839302012-08-29 17:11:06 -05003118 atomic64_cmpxchg(&rbd_dev_id_max, rbd_id, max_id);
3119 dout(" max dev id has been reset\n");
Alex Elderb7f23c32012-01-29 13:57:43 -06003120}
3121
Alex Eldera725f65e2012-02-02 08:13:30 -06003122/*
Alex Eldere28fff262012-02-02 08:13:30 -06003123 * Skips over white space at *buf, and updates *buf to point to the
3124 * first found non-space character (if any). Returns the length of
Alex Elder593a9e72012-02-07 12:03:37 -06003125 * the token (string of non-white space characters) found. Note
3126 * that *buf must be terminated with '\0'.
Alex Eldere28fff262012-02-02 08:13:30 -06003127 */
3128static inline size_t next_token(const char **buf)
3129{
3130 /*
3131 * These are the characters that produce nonzero for
3132 * isspace() in the "C" and "POSIX" locales.
3133 */
3134 const char *spaces = " \f\n\r\t\v";
3135
3136 *buf += strspn(*buf, spaces); /* Find start of token */
3137
3138 return strcspn(*buf, spaces); /* Return token length */
3139}
3140
3141/*
3142 * Finds the next token in *buf, and if the provided token buffer is
3143 * big enough, copies the found token into it. The result, if
Alex Elder593a9e72012-02-07 12:03:37 -06003144 * copied, is guaranteed to be terminated with '\0'. Note that *buf
3145 * must be terminated with '\0' on entry.
Alex Eldere28fff262012-02-02 08:13:30 -06003146 *
3147 * Returns the length of the token found (not including the '\0').
3148 * Return value will be 0 if no token is found, and it will be >=
3149 * token_size if the token would not fit.
3150 *
Alex Elder593a9e72012-02-07 12:03:37 -06003151 * The *buf pointer will be updated to point beyond the end of the
Alex Eldere28fff262012-02-02 08:13:30 -06003152 * found token. Note that this occurs even if the token buffer is
3153 * too small to hold it.
3154 */
3155static inline size_t copy_token(const char **buf,
3156 char *token,
3157 size_t token_size)
3158{
3159 size_t len;
3160
3161 len = next_token(buf);
3162 if (len < token_size) {
3163 memcpy(token, *buf, len);
3164 *(token + len) = '\0';
3165 }
3166 *buf += len;
3167
3168 return len;
3169}
3170
3171/*
Alex Elderea3352f2012-07-09 21:04:23 -05003172 * Finds the next token in *buf, dynamically allocates a buffer big
3173 * enough to hold a copy of it, and copies the token into the new
3174 * buffer. The copy is guaranteed to be terminated with '\0'. Note
3175 * that a duplicate buffer is created even for a zero-length token.
3176 *
3177 * Returns a pointer to the newly-allocated duplicate, or a null
3178 * pointer if memory for the duplicate was not available. If
3179 * the lenp argument is a non-null pointer, the length of the token
3180 * (not including the '\0') is returned in *lenp.
3181 *
3182 * If successful, the *buf pointer will be updated to point beyond
3183 * the end of the found token.
3184 *
3185 * Note: uses GFP_KERNEL for allocation.
3186 */
3187static inline char *dup_token(const char **buf, size_t *lenp)
3188{
3189 char *dup;
3190 size_t len;
3191
3192 len = next_token(buf);
Alex Elder4caf35f2012-11-01 08:39:27 -05003193 dup = kmemdup(*buf, len + 1, GFP_KERNEL);
Alex Elderea3352f2012-07-09 21:04:23 -05003194 if (!dup)
3195 return NULL;
Alex Elderea3352f2012-07-09 21:04:23 -05003196 *(dup + len) = '\0';
3197 *buf += len;
3198
3199 if (lenp)
3200 *lenp = len;
3201
3202 return dup;
3203}
3204
3205/*
Alex Elder859c31d2012-10-25 23:34:42 -05003206 * Parse the options provided for an "rbd add" (i.e., rbd image
3207 * mapping) request. These arrive via a write to /sys/bus/rbd/add,
3208 * and the data written is passed here via a NUL-terminated buffer.
3209 * Returns 0 if successful or an error code otherwise.
Alex Elderd22f76e2012-07-12 10:46:35 -05003210 *
Alex Elder859c31d2012-10-25 23:34:42 -05003211 * The information extracted from these options is recorded in
3212 * the other parameters which return dynamically-allocated
3213 * structures:
3214 * ceph_opts
3215 * The address of a pointer that will refer to a ceph options
3216 * structure. Caller must release the returned pointer using
3217 * ceph_destroy_options() when it is no longer needed.
3218 * rbd_opts
3219 * Address of an rbd options pointer. Fully initialized by
3220 * this function; caller must release with kfree().
3221 * spec
3222 * Address of an rbd image specification pointer. Fully
3223 * initialized by this function based on parsed options.
3224 * Caller must release with rbd_spec_put().
3225 *
3226 * The options passed take this form:
3227 * <mon_addrs> <options> <pool_name> <image_name> [<snap_id>]
3228 * where:
3229 * <mon_addrs>
3230 * A comma-separated list of one or more monitor addresses.
3231 * A monitor address is an ip address, optionally followed
3232 * by a port number (separated by a colon).
3233 * I.e.: ip1[:port1][,ip2[:port2]...]
3234 * <options>
3235 * A comma-separated list of ceph and/or rbd options.
3236 * <pool_name>
3237 * The name of the rados pool containing the rbd image.
3238 * <image_name>
3239 * The name of the image in that pool to map.
3240 * <snap_id>
3241 * An optional snapshot id. If provided, the mapping will
3242 * present data from the image at the time that snapshot was
3243 * created. The image head is used if no snapshot id is
3244 * provided. Snapshot mappings are always read-only.
Alex Eldera725f65e2012-02-02 08:13:30 -06003245 */
Alex Elder859c31d2012-10-25 23:34:42 -05003246static int rbd_add_parse_args(const char *buf,
Alex Elderdc79b112012-10-25 23:34:41 -05003247 struct ceph_options **ceph_opts,
Alex Elder859c31d2012-10-25 23:34:42 -05003248 struct rbd_options **opts,
3249 struct rbd_spec **rbd_spec)
Alex Eldera725f65e2012-02-02 08:13:30 -06003250{
Alex Elderd22f76e2012-07-12 10:46:35 -05003251 size_t len;
Alex Elder859c31d2012-10-25 23:34:42 -05003252 char *options;
Alex Elder0ddebc02012-10-25 23:34:41 -05003253 const char *mon_addrs;
3254 size_t mon_addrs_size;
Alex Elder859c31d2012-10-25 23:34:42 -05003255 struct rbd_spec *spec = NULL;
Alex Elder4e9afeb2012-10-25 23:34:41 -05003256 struct rbd_options *rbd_opts = NULL;
Alex Elder859c31d2012-10-25 23:34:42 -05003257 struct ceph_options *copts;
Alex Elderdc79b112012-10-25 23:34:41 -05003258 int ret;
Alex Eldere28fff262012-02-02 08:13:30 -06003259
3260 /* The first four tokens are required */
3261
Alex Elder7ef32142012-02-02 08:13:30 -06003262 len = next_token(&buf);
Alex Elder4fb5d6712012-11-01 10:17:15 -05003263 if (!len) {
3264 rbd_warn(NULL, "no monitor address(es) provided");
3265 return -EINVAL;
3266 }
Alex Elder0ddebc02012-10-25 23:34:41 -05003267 mon_addrs = buf;
Alex Elderf28e5652012-10-25 23:34:41 -05003268 mon_addrs_size = len + 1;
Alex Elder7ef32142012-02-02 08:13:30 -06003269 buf += len;
Alex Eldera725f65e2012-02-02 08:13:30 -06003270
Alex Elderdc79b112012-10-25 23:34:41 -05003271 ret = -EINVAL;
Alex Elderf28e5652012-10-25 23:34:41 -05003272 options = dup_token(&buf, NULL);
3273 if (!options)
Alex Elderdc79b112012-10-25 23:34:41 -05003274 return -ENOMEM;
Alex Elder4fb5d6712012-11-01 10:17:15 -05003275 if (!*options) {
3276 rbd_warn(NULL, "no options provided");
3277 goto out_err;
3278 }
Alex Eldera725f65e2012-02-02 08:13:30 -06003279
Alex Elder859c31d2012-10-25 23:34:42 -05003280 spec = rbd_spec_alloc();
3281 if (!spec)
Alex Elderf28e5652012-10-25 23:34:41 -05003282 goto out_mem;
Alex Elder859c31d2012-10-25 23:34:42 -05003283
3284 spec->pool_name = dup_token(&buf, NULL);
3285 if (!spec->pool_name)
3286 goto out_mem;
Alex Elder4fb5d6712012-11-01 10:17:15 -05003287 if (!*spec->pool_name) {
3288 rbd_warn(NULL, "no pool name provided");
3289 goto out_err;
3290 }
Alex Eldere28fff262012-02-02 08:13:30 -06003291
Alex Elder69e7a022012-11-01 08:39:26 -05003292 spec->image_name = dup_token(&buf, NULL);
Alex Elder859c31d2012-10-25 23:34:42 -05003293 if (!spec->image_name)
Alex Elderf28e5652012-10-25 23:34:41 -05003294 goto out_mem;
Alex Elder4fb5d6712012-11-01 10:17:15 -05003295 if (!*spec->image_name) {
3296 rbd_warn(NULL, "no image name provided");
3297 goto out_err;
3298 }
Alex Eldere28fff262012-02-02 08:13:30 -06003299
Alex Elderf28e5652012-10-25 23:34:41 -05003300 /*
3301 * Snapshot name is optional; default is to use "-"
3302 * (indicating the head/no snapshot).
3303 */
Alex Elder3feeb8942012-08-31 17:29:52 -05003304 len = next_token(&buf);
Alex Elder820a5f32012-07-09 21:04:24 -05003305 if (!len) {
Alex Elder3feeb8942012-08-31 17:29:52 -05003306 buf = RBD_SNAP_HEAD_NAME; /* No snapshot supplied */
3307 len = sizeof (RBD_SNAP_HEAD_NAME) - 1;
Alex Elderf28e5652012-10-25 23:34:41 -05003308 } else if (len > RBD_MAX_SNAP_NAME_LEN) {
Alex Elderdc79b112012-10-25 23:34:41 -05003309 ret = -ENAMETOOLONG;
Alex Elderf28e5652012-10-25 23:34:41 -05003310 goto out_err;
Alex Elder849b4262012-07-09 21:04:24 -05003311 }
Alex Elder4caf35f2012-11-01 08:39:27 -05003312 spec->snap_name = kmemdup(buf, len + 1, GFP_KERNEL);
Alex Elder859c31d2012-10-25 23:34:42 -05003313 if (!spec->snap_name)
Alex Elderf28e5652012-10-25 23:34:41 -05003314 goto out_mem;
Alex Elder859c31d2012-10-25 23:34:42 -05003315 *(spec->snap_name + len) = '\0';
Alex Eldere5c35532012-10-25 23:34:41 -05003316
Alex Elder0ddebc02012-10-25 23:34:41 -05003317 /* Initialize all rbd options to the defaults */
Alex Eldere28fff262012-02-02 08:13:30 -06003318
Alex Elder4e9afeb2012-10-25 23:34:41 -05003319 rbd_opts = kzalloc(sizeof (*rbd_opts), GFP_KERNEL);
3320 if (!rbd_opts)
3321 goto out_mem;
3322
3323 rbd_opts->read_only = RBD_READ_ONLY_DEFAULT;
Alex Elderd22f76e2012-07-12 10:46:35 -05003324
Alex Elder859c31d2012-10-25 23:34:42 -05003325 copts = ceph_parse_options(options, mon_addrs,
Alex Elder0ddebc02012-10-25 23:34:41 -05003326 mon_addrs + mon_addrs_size - 1,
Alex Elder4e9afeb2012-10-25 23:34:41 -05003327 parse_rbd_opts_token, rbd_opts);
Alex Elder859c31d2012-10-25 23:34:42 -05003328 if (IS_ERR(copts)) {
3329 ret = PTR_ERR(copts);
Alex Elderdc79b112012-10-25 23:34:41 -05003330 goto out_err;
3331 }
Alex Elder859c31d2012-10-25 23:34:42 -05003332 kfree(options);
3333
3334 *ceph_opts = copts;
Alex Elder4e9afeb2012-10-25 23:34:41 -05003335 *opts = rbd_opts;
Alex Elder859c31d2012-10-25 23:34:42 -05003336 *rbd_spec = spec;
Alex Elder0ddebc02012-10-25 23:34:41 -05003337
Alex Elderdc79b112012-10-25 23:34:41 -05003338 return 0;
Alex Elderf28e5652012-10-25 23:34:41 -05003339out_mem:
Alex Elderdc79b112012-10-25 23:34:41 -05003340 ret = -ENOMEM;
Alex Elderd22f76e2012-07-12 10:46:35 -05003341out_err:
Alex Elder859c31d2012-10-25 23:34:42 -05003342 kfree(rbd_opts);
3343 rbd_spec_put(spec);
Alex Elderf28e5652012-10-25 23:34:41 -05003344 kfree(options);
Alex Elderd22f76e2012-07-12 10:46:35 -05003345
Alex Elderdc79b112012-10-25 23:34:41 -05003346 return ret;
Alex Eldera725f65e2012-02-02 08:13:30 -06003347}
3348
Alex Elder589d30e2012-07-10 20:30:11 -05003349/*
3350 * An rbd format 2 image has a unique identifier, distinct from the
3351 * name given to it by the user. Internally, that identifier is
3352 * what's used to specify the names of objects related to the image.
3353 *
3354 * A special "rbd id" object is used to map an rbd image name to its
3355 * id. If that object doesn't exist, then there is no v2 rbd image
3356 * with the supplied name.
3357 *
3358 * This function will record the given rbd_dev's image_id field if
3359 * it can be determined, and in that case will return 0. If any
3360 * errors occur a negative errno will be returned and the rbd_dev's
3361 * image_id field will be unchanged (and should be NULL).
3362 */
3363static int rbd_dev_image_id(struct rbd_device *rbd_dev)
3364{
3365 int ret;
3366 size_t size;
3367 char *object_name;
3368 void *response;
3369 void *p;
3370
3371 /*
Alex Elder2c0d0a12012-10-30 19:40:33 -05003372 * When probing a parent image, the image id is already
3373 * known (and the image name likely is not). There's no
3374 * need to fetch the image id again in this case.
3375 */
3376 if (rbd_dev->spec->image_id)
3377 return 0;
3378
3379 /*
Alex Elder589d30e2012-07-10 20:30:11 -05003380 * First, see if the format 2 image id file exists, and if
3381 * so, get the image's persistent id from it.
3382 */
Alex Elder69e7a022012-11-01 08:39:26 -05003383 size = sizeof (RBD_ID_PREFIX) + strlen(rbd_dev->spec->image_name);
Alex Elder589d30e2012-07-10 20:30:11 -05003384 object_name = kmalloc(size, GFP_NOIO);
3385 if (!object_name)
3386 return -ENOMEM;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003387 sprintf(object_name, "%s%s", RBD_ID_PREFIX, rbd_dev->spec->image_name);
Alex Elder589d30e2012-07-10 20:30:11 -05003388 dout("rbd id object name is %s\n", object_name);
3389
3390 /* Response will be an encoded string, which includes a length */
3391
3392 size = sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX;
3393 response = kzalloc(size, GFP_NOIO);
3394 if (!response) {
3395 ret = -ENOMEM;
3396 goto out;
3397 }
3398
3399 ret = rbd_req_sync_exec(rbd_dev, object_name,
3400 "rbd", "get_id",
3401 NULL, 0,
3402 response, RBD_IMAGE_ID_LEN_MAX,
3403 CEPH_OSD_FLAG_READ, NULL);
3404 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
3405 if (ret < 0)
3406 goto out;
Alex Eldera0ea3a42012-10-10 21:19:13 -07003407 ret = 0; /* rbd_req_sync_exec() can return positive */
Alex Elder589d30e2012-07-10 20:30:11 -05003408
3409 p = response;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003410 rbd_dev->spec->image_id = ceph_extract_encoded_string(&p,
Alex Elder589d30e2012-07-10 20:30:11 -05003411 p + RBD_IMAGE_ID_LEN_MAX,
Alex Elder979ed482012-11-01 08:39:26 -05003412 NULL, GFP_NOIO);
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003413 if (IS_ERR(rbd_dev->spec->image_id)) {
3414 ret = PTR_ERR(rbd_dev->spec->image_id);
3415 rbd_dev->spec->image_id = NULL;
Alex Elder589d30e2012-07-10 20:30:11 -05003416 } else {
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003417 dout("image_id is %s\n", rbd_dev->spec->image_id);
Alex Elder589d30e2012-07-10 20:30:11 -05003418 }
3419out:
3420 kfree(response);
3421 kfree(object_name);
3422
3423 return ret;
3424}
3425
Alex Eldera30b71b2012-07-10 20:30:11 -05003426static int rbd_dev_v1_probe(struct rbd_device *rbd_dev)
3427{
3428 int ret;
3429 size_t size;
3430
3431 /* Version 1 images have no id; empty string is used */
3432
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003433 rbd_dev->spec->image_id = kstrdup("", GFP_KERNEL);
3434 if (!rbd_dev->spec->image_id)
Alex Eldera30b71b2012-07-10 20:30:11 -05003435 return -ENOMEM;
Alex Eldera30b71b2012-07-10 20:30:11 -05003436
3437 /* Record the header object name for this rbd image. */
3438
Alex Elder69e7a022012-11-01 08:39:26 -05003439 size = strlen(rbd_dev->spec->image_name) + sizeof (RBD_SUFFIX);
Alex Eldera30b71b2012-07-10 20:30:11 -05003440 rbd_dev->header_name = kmalloc(size, GFP_KERNEL);
3441 if (!rbd_dev->header_name) {
3442 ret = -ENOMEM;
3443 goto out_err;
3444 }
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003445 sprintf(rbd_dev->header_name, "%s%s",
3446 rbd_dev->spec->image_name, RBD_SUFFIX);
Alex Eldera30b71b2012-07-10 20:30:11 -05003447
3448 /* Populate rbd image metadata */
3449
3450 ret = rbd_read_header(rbd_dev, &rbd_dev->header);
3451 if (ret < 0)
3452 goto out_err;
Alex Elder86b00e02012-10-25 23:34:42 -05003453
3454 /* Version 1 images have no parent (no layering) */
3455
3456 rbd_dev->parent_spec = NULL;
3457 rbd_dev->parent_overlap = 0;
3458
Alex Eldera30b71b2012-07-10 20:30:11 -05003459 rbd_dev->image_format = 1;
3460
3461 dout("discovered version 1 image, header name is %s\n",
3462 rbd_dev->header_name);
3463
3464 return 0;
3465
3466out_err:
3467 kfree(rbd_dev->header_name);
3468 rbd_dev->header_name = NULL;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003469 kfree(rbd_dev->spec->image_id);
3470 rbd_dev->spec->image_id = NULL;
Alex Eldera30b71b2012-07-10 20:30:11 -05003471
3472 return ret;
3473}
3474
3475static int rbd_dev_v2_probe(struct rbd_device *rbd_dev)
3476{
3477 size_t size;
Alex Elder9d475de2012-07-03 16:01:19 -05003478 int ret;
Alex Elder6e14b1a2012-07-03 16:01:19 -05003479 u64 ver = 0;
Alex Eldera30b71b2012-07-10 20:30:11 -05003480
3481 /*
3482 * Image id was filled in by the caller. Record the header
3483 * object name for this rbd image.
3484 */
Alex Elder979ed482012-11-01 08:39:26 -05003485 size = sizeof (RBD_HEADER_PREFIX) + strlen(rbd_dev->spec->image_id);
Alex Eldera30b71b2012-07-10 20:30:11 -05003486 rbd_dev->header_name = kmalloc(size, GFP_KERNEL);
3487 if (!rbd_dev->header_name)
3488 return -ENOMEM;
3489 sprintf(rbd_dev->header_name, "%s%s",
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003490 RBD_HEADER_PREFIX, rbd_dev->spec->image_id);
Alex Elder9d475de2012-07-03 16:01:19 -05003491
3492 /* Get the size and object order for the image */
3493
3494 ret = rbd_dev_v2_image_size(rbd_dev);
3495 if (ret < 0)
3496 goto out_err;
Alex Elder1e130192012-07-03 16:01:19 -05003497
3498 /* Get the object prefix (a.k.a. block_name) for the image */
3499
3500 ret = rbd_dev_v2_object_prefix(rbd_dev);
3501 if (ret < 0)
3502 goto out_err;
Alex Elderb1b54022012-07-03 16:01:19 -05003503
Alex Elderd8891402012-10-09 13:50:17 -07003504 /* Get the and check features for the image */
Alex Elderb1b54022012-07-03 16:01:19 -05003505
3506 ret = rbd_dev_v2_features(rbd_dev);
3507 if (ret < 0)
3508 goto out_err;
Alex Elder35d489f2012-07-03 16:01:19 -05003509
Alex Elder86b00e02012-10-25 23:34:42 -05003510 /* If the image supports layering, get the parent info */
3511
3512 if (rbd_dev->header.features & RBD_FEATURE_LAYERING) {
3513 ret = rbd_dev_v2_parent_info(rbd_dev);
3514 if (ret < 0)
3515 goto out_err;
3516 }
3517
Alex Elder6e14b1a2012-07-03 16:01:19 -05003518 /* crypto and compression type aren't (yet) supported for v2 images */
Alex Elder35d489f2012-07-03 16:01:19 -05003519
Alex Elder6e14b1a2012-07-03 16:01:19 -05003520 rbd_dev->header.crypt_type = 0;
3521 rbd_dev->header.comp_type = 0;
3522
3523 /* Get the snapshot context, plus the header version */
3524
3525 ret = rbd_dev_v2_snap_context(rbd_dev, &ver);
Alex Elder35d489f2012-07-03 16:01:19 -05003526 if (ret)
3527 goto out_err;
Alex Elder6e14b1a2012-07-03 16:01:19 -05003528 rbd_dev->header.obj_version = ver;
3529
Alex Eldera30b71b2012-07-10 20:30:11 -05003530 rbd_dev->image_format = 2;
3531
3532 dout("discovered version 2 image, header name is %s\n",
3533 rbd_dev->header_name);
3534
Alex Elder35152972012-08-31 17:29:55 -05003535 return 0;
Alex Elder9d475de2012-07-03 16:01:19 -05003536out_err:
Alex Elder86b00e02012-10-25 23:34:42 -05003537 rbd_dev->parent_overlap = 0;
3538 rbd_spec_put(rbd_dev->parent_spec);
3539 rbd_dev->parent_spec = NULL;
Alex Elder9d475de2012-07-03 16:01:19 -05003540 kfree(rbd_dev->header_name);
3541 rbd_dev->header_name = NULL;
Alex Elder1e130192012-07-03 16:01:19 -05003542 kfree(rbd_dev->header.object_prefix);
3543 rbd_dev->header.object_prefix = NULL;
Alex Elder9d475de2012-07-03 16:01:19 -05003544
3545 return ret;
Alex Eldera30b71b2012-07-10 20:30:11 -05003546}
3547
Alex Elder83a06262012-10-30 15:47:17 -05003548static int rbd_dev_probe_finish(struct rbd_device *rbd_dev)
3549{
3550 int ret;
3551
3552 /* no need to lock here, as rbd_dev is not registered yet */
3553 ret = rbd_dev_snaps_update(rbd_dev);
3554 if (ret)
3555 return ret;
3556
Alex Elder9e15b772012-10-30 19:40:33 -05003557 ret = rbd_dev_probe_update_spec(rbd_dev);
3558 if (ret)
3559 goto err_out_snaps;
3560
Alex Elder83a06262012-10-30 15:47:17 -05003561 ret = rbd_dev_set_mapping(rbd_dev);
3562 if (ret)
3563 goto err_out_snaps;
3564
3565 /* generate unique id: find highest unique id, add one */
3566 rbd_dev_id_get(rbd_dev);
3567
3568 /* Fill in the device name, now that we have its id. */
3569 BUILD_BUG_ON(DEV_NAME_LEN
3570 < sizeof (RBD_DRV_NAME) + MAX_INT_FORMAT_WIDTH);
3571 sprintf(rbd_dev->name, "%s%d", RBD_DRV_NAME, rbd_dev->dev_id);
3572
3573 /* Get our block major device number. */
3574
3575 ret = register_blkdev(0, rbd_dev->name);
3576 if (ret < 0)
3577 goto err_out_id;
3578 rbd_dev->major = ret;
3579
3580 /* Set up the blkdev mapping. */
3581
3582 ret = rbd_init_disk(rbd_dev);
3583 if (ret)
3584 goto err_out_blkdev;
3585
3586 ret = rbd_bus_add_dev(rbd_dev);
3587 if (ret)
3588 goto err_out_disk;
3589
3590 /*
3591 * At this point cleanup in the event of an error is the job
3592 * of the sysfs code (initiated by rbd_bus_del_dev()).
3593 */
3594 down_write(&rbd_dev->header_rwsem);
3595 ret = rbd_dev_snaps_register(rbd_dev);
3596 up_write(&rbd_dev->header_rwsem);
3597 if (ret)
3598 goto err_out_bus;
3599
3600 ret = rbd_init_watch_dev(rbd_dev);
3601 if (ret)
3602 goto err_out_bus;
3603
3604 /* Everything's ready. Announce the disk to the world. */
3605
3606 add_disk(rbd_dev->disk);
3607
3608 pr_info("%s: added with size 0x%llx\n", rbd_dev->disk->disk_name,
3609 (unsigned long long) rbd_dev->mapping.size);
3610
3611 return ret;
3612err_out_bus:
3613 /* this will also clean up rest of rbd_dev stuff */
3614
3615 rbd_bus_del_dev(rbd_dev);
3616
3617 return ret;
3618err_out_disk:
3619 rbd_free_disk(rbd_dev);
3620err_out_blkdev:
3621 unregister_blkdev(rbd_dev->major, rbd_dev->name);
3622err_out_id:
3623 rbd_dev_id_put(rbd_dev);
3624err_out_snaps:
3625 rbd_remove_all_snaps(rbd_dev);
3626
3627 return ret;
3628}
3629
Alex Eldera30b71b2012-07-10 20:30:11 -05003630/*
3631 * Probe for the existence of the header object for the given rbd
3632 * device. For format 2 images this includes determining the image
3633 * id.
3634 */
3635static int rbd_dev_probe(struct rbd_device *rbd_dev)
3636{
3637 int ret;
3638
3639 /*
3640 * Get the id from the image id object. If it's not a
3641 * format 2 image, we'll get ENOENT back, and we'll assume
3642 * it's a format 1 image.
3643 */
3644 ret = rbd_dev_image_id(rbd_dev);
3645 if (ret)
3646 ret = rbd_dev_v1_probe(rbd_dev);
3647 else
3648 ret = rbd_dev_v2_probe(rbd_dev);
Alex Elder83a06262012-10-30 15:47:17 -05003649 if (ret) {
Alex Eldera30b71b2012-07-10 20:30:11 -05003650 dout("probe failed, returning %d\n", ret);
3651
Alex Elder83a06262012-10-30 15:47:17 -05003652 return ret;
3653 }
3654
3655 ret = rbd_dev_probe_finish(rbd_dev);
3656 if (ret)
3657 rbd_header_free(&rbd_dev->header);
3658
Alex Eldera30b71b2012-07-10 20:30:11 -05003659 return ret;
3660}
3661
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003662static ssize_t rbd_add(struct bus_type *bus,
3663 const char *buf,
3664 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003665{
Alex Eldercb8627c2012-07-09 21:04:23 -05003666 struct rbd_device *rbd_dev = NULL;
Alex Elderdc79b112012-10-25 23:34:41 -05003667 struct ceph_options *ceph_opts = NULL;
Alex Elder4e9afeb2012-10-25 23:34:41 -05003668 struct rbd_options *rbd_opts = NULL;
Alex Elder859c31d2012-10-25 23:34:42 -05003669 struct rbd_spec *spec = NULL;
Alex Elder9d3997f2012-10-25 23:34:42 -05003670 struct rbd_client *rbdc;
Alex Elder27cc2592012-02-02 08:13:30 -06003671 struct ceph_osd_client *osdc;
3672 int rc = -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003673
3674 if (!try_module_get(THIS_MODULE))
3675 return -ENODEV;
3676
Alex Eldera725f65e2012-02-02 08:13:30 -06003677 /* parse add command */
Alex Elder859c31d2012-10-25 23:34:42 -05003678 rc = rbd_add_parse_args(buf, &ceph_opts, &rbd_opts, &spec);
Alex Elderdc79b112012-10-25 23:34:41 -05003679 if (rc < 0)
Alex Elderbd4ba652012-10-25 23:34:42 -05003680 goto err_out_module;
Alex Eldera725f65e2012-02-02 08:13:30 -06003681
Alex Elder9d3997f2012-10-25 23:34:42 -05003682 rbdc = rbd_get_client(ceph_opts);
3683 if (IS_ERR(rbdc)) {
3684 rc = PTR_ERR(rbdc);
Alex Elder0ddebc02012-10-25 23:34:41 -05003685 goto err_out_args;
Alex Elder9d3997f2012-10-25 23:34:42 -05003686 }
Alex Elderc53d5892012-10-25 23:34:42 -05003687 ceph_opts = NULL; /* rbd_dev client now owns this */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003688
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003689 /* pick the pool */
Alex Elder9d3997f2012-10-25 23:34:42 -05003690 osdc = &rbdc->client->osdc;
Alex Elder859c31d2012-10-25 23:34:42 -05003691 rc = ceph_pg_poolid_by_name(osdc->osdmap, spec->pool_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003692 if (rc < 0)
3693 goto err_out_client;
Alex Elder859c31d2012-10-25 23:34:42 -05003694 spec->pool_id = (u64) rc;
3695
Alex Elderc53d5892012-10-25 23:34:42 -05003696 rbd_dev = rbd_dev_create(rbdc, spec);
Alex Elderbd4ba652012-10-25 23:34:42 -05003697 if (!rbd_dev)
3698 goto err_out_client;
Alex Elderc53d5892012-10-25 23:34:42 -05003699 rbdc = NULL; /* rbd_dev now owns this */
3700 spec = NULL; /* rbd_dev now owns this */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003701
Alex Elderbd4ba652012-10-25 23:34:42 -05003702 rbd_dev->mapping.read_only = rbd_opts->read_only;
Alex Elderc53d5892012-10-25 23:34:42 -05003703 kfree(rbd_opts);
3704 rbd_opts = NULL; /* done with this */
Alex Elderbd4ba652012-10-25 23:34:42 -05003705
Alex Eldera30b71b2012-07-10 20:30:11 -05003706 rc = rbd_dev_probe(rbd_dev);
3707 if (rc < 0)
Alex Elderc53d5892012-10-25 23:34:42 -05003708 goto err_out_rbd_dev;
Alex Elder05fd6f62012-08-29 17:11:07 -05003709
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003710 return count;
Alex Elderc53d5892012-10-25 23:34:42 -05003711err_out_rbd_dev:
3712 rbd_dev_destroy(rbd_dev);
Alex Elderbd4ba652012-10-25 23:34:42 -05003713err_out_client:
Alex Elder9d3997f2012-10-25 23:34:42 -05003714 rbd_put_client(rbdc);
Alex Elder0ddebc02012-10-25 23:34:41 -05003715err_out_args:
Alex Elder78cea762012-10-25 23:34:41 -05003716 if (ceph_opts)
3717 ceph_destroy_options(ceph_opts);
Alex Elder4e9afeb2012-10-25 23:34:41 -05003718 kfree(rbd_opts);
Alex Elder859c31d2012-10-25 23:34:42 -05003719 rbd_spec_put(spec);
Alex Elderbd4ba652012-10-25 23:34:42 -05003720err_out_module:
3721 module_put(THIS_MODULE);
Alex Elder27cc2592012-02-02 08:13:30 -06003722
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003723 dout("Error adding device %s\n", buf);
Alex Elder27cc2592012-02-02 08:13:30 -06003724
3725 return (ssize_t) rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003726}
3727
Alex Elderde71a292012-07-03 16:01:19 -05003728static struct rbd_device *__rbd_get_dev(unsigned long dev_id)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003729{
3730 struct list_head *tmp;
3731 struct rbd_device *rbd_dev;
3732
Alex Eldere124a82f2012-01-29 13:57:44 -06003733 spin_lock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003734 list_for_each(tmp, &rbd_dev_list) {
3735 rbd_dev = list_entry(tmp, struct rbd_device, node);
Alex Elderde71a292012-07-03 16:01:19 -05003736 if (rbd_dev->dev_id == dev_id) {
Alex Eldere124a82f2012-01-29 13:57:44 -06003737 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003738 return rbd_dev;
Alex Eldere124a82f2012-01-29 13:57:44 -06003739 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003740 }
Alex Eldere124a82f2012-01-29 13:57:44 -06003741 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003742 return NULL;
3743}
3744
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003745static void rbd_dev_release(struct device *dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003746{
Alex Elder593a9e72012-02-07 12:03:37 -06003747 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003748
Alex Elder1dbb4392012-01-24 10:08:37 -06003749 if (rbd_dev->watch_request) {
3750 struct ceph_client *client = rbd_dev->rbd_client->client;
3751
3752 ceph_osdc_unregister_linger_request(&client->osdc,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003753 rbd_dev->watch_request);
Alex Elder1dbb4392012-01-24 10:08:37 -06003754 }
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003755 if (rbd_dev->watch_event)
Alex Elder070c6332012-07-25 09:32:41 -05003756 rbd_req_sync_unwatch(rbd_dev);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003757
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003758
3759 /* clean up and free blkdev */
3760 rbd_free_disk(rbd_dev);
3761 unregister_blkdev(rbd_dev->major, rbd_dev->name);
Alex Elder32eec682012-02-08 16:11:14 -06003762
Alex Elder2ac4e752012-07-10 20:30:10 -05003763 /* release allocated disk header fields */
3764 rbd_header_free(&rbd_dev->header);
3765
Alex Elder32eec682012-02-08 16:11:14 -06003766 /* done with the id, and with the rbd_dev */
Alex Eldere2839302012-08-29 17:11:06 -05003767 rbd_dev_id_put(rbd_dev);
Alex Elderc53d5892012-10-25 23:34:42 -05003768 rbd_assert(rbd_dev->rbd_client != NULL);
3769 rbd_dev_destroy(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003770
3771 /* release module ref */
3772 module_put(THIS_MODULE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003773}
3774
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003775static ssize_t rbd_remove(struct bus_type *bus,
3776 const char *buf,
3777 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003778{
3779 struct rbd_device *rbd_dev = NULL;
3780 int target_id, rc;
3781 unsigned long ul;
3782 int ret = count;
3783
3784 rc = strict_strtoul(buf, 10, &ul);
3785 if (rc)
3786 return rc;
3787
3788 /* convert to int; abort if we lost anything in the conversion */
3789 target_id = (int) ul;
3790 if (target_id != ul)
3791 return -EINVAL;
3792
3793 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
3794
3795 rbd_dev = __rbd_get_dev(target_id);
3796 if (!rbd_dev) {
3797 ret = -ENOENT;
3798 goto done;
3799 }
3800
Alex Elder42382b72012-11-16 09:29:16 -06003801 if (rbd_dev->open_count) {
3802 ret = -EBUSY;
3803 goto done;
3804 }
3805
Alex Elder41f38c22012-10-25 23:34:40 -05003806 rbd_remove_all_snaps(rbd_dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003807 rbd_bus_del_dev(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003808
3809done:
3810 mutex_unlock(&ctl_mutex);
Alex Elderaafb2302012-09-06 16:00:54 -05003811
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003812 return ret;
3813}
3814
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003815/*
3816 * create control files in sysfs
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003817 * /sys/bus/rbd/...
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003818 */
3819static int rbd_sysfs_init(void)
3820{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003821 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003822
Alex Elderfed4c142012-02-07 12:03:36 -06003823 ret = device_register(&rbd_root_dev);
Alex Elder21079782012-01-24 10:08:36 -06003824 if (ret < 0)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003825 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003826
Alex Elderfed4c142012-02-07 12:03:36 -06003827 ret = bus_register(&rbd_bus_type);
3828 if (ret < 0)
3829 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003830
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003831 return ret;
3832}
3833
3834static void rbd_sysfs_cleanup(void)
3835{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003836 bus_unregister(&rbd_bus_type);
Alex Elderfed4c142012-02-07 12:03:36 -06003837 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003838}
3839
3840int __init rbd_init(void)
3841{
3842 int rc;
3843
3844 rc = rbd_sysfs_init();
3845 if (rc)
3846 return rc;
Alex Elderf0f8cef2012-01-29 13:57:44 -06003847 pr_info("loaded " RBD_DRV_NAME_LONG "\n");
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003848 return 0;
3849}
3850
3851void __exit rbd_exit(void)
3852{
3853 rbd_sysfs_cleanup();
3854}
3855
3856module_init(rbd_init);
3857module_exit(rbd_exit);
3858
3859MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
3860MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
3861MODULE_DESCRIPTION("rados block device");
3862
3863/* following authorship retained from original osdblk.c */
3864MODULE_AUTHOR("Jeff Garzik <jeff@garzik.org>");
3865
3866MODULE_LICENSE("GPL");