blob: 0091fa466f83b698438b3ea3f8eb15e782953f1c [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;
174 int rc;
175 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 Durgin35915382011-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 Eldere124a822012-01-29 13:57:44 -0600259
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700260static LIST_HEAD(rbd_dev_list); /* devices */
Alex Eldere124a822012-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 Elderbc534d862012-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 Elderbc534d862012-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 Elderbc534d862012-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 Elderbc534d862012-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,
1056 int ret, u64 len)
1057{
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",
1062 coll, index, 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++) {
1083 __blk_end_request(rq, coll->status[i].rc,
1084 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,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001092 int ret, u64 len)
1093{
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,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001114 void (*rbd_cb)(struct ceph_osd_request *req,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001115 struct ceph_msg *msg),
1116 struct ceph_osd_request **linger_req,
1117 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001118{
1119 struct ceph_osd_request *req;
1120 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);
1129 if (!rbd_req) {
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001130 if (coll)
1131 rbd_coll_end_req_index(rq, coll, coll_index,
1132 -ENOMEM, len);
1133 return -ENOMEM;
1134 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001135
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001136 if (coll) {
Alex Elder725afc92012-11-08 08:01:39 -06001137 rbd_req->coll = coll;
1138 rbd_req->coll_index = coll_index;
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001139 }
1140
Alex Elderf7760da2012-10-20 22:17:27 -05001141 dout("rbd_do_request object_name=%s ofs=%llu len=%llu coll=%p[%d]\n",
1142 object_name, (unsigned long long) ofs,
1143 (unsigned long long) len, coll, coll_index);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001144
Alex Elder0ce1a792012-07-03 16:01:18 -05001145 osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elder1dbb4392012-01-24 10:08:37 -06001146 req = ceph_osdc_alloc_request(osdc, flags, snapc, ops,
1147 false, GFP_NOIO, pages, bio);
Sage Weil4ad12622011-05-03 09:23:36 -07001148 if (!req) {
Sage Weil4ad12622011-05-03 09:23:36 -07001149 ret = -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001150 goto done_pages;
1151 }
1152
1153 req->r_callback = rbd_cb;
1154
Alex Elder725afc92012-11-08 08:01:39 -06001155 rbd_req->rq = rq;
1156 rbd_req->bio = bio;
1157 rbd_req->pages = pages;
1158 rbd_req->len = len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001159
Alex Elder725afc92012-11-08 08:01:39 -06001160 req->r_priv = rbd_req;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001161
1162 reqhead = req->r_request->front.iov_base;
1163 reqhead->snapid = cpu_to_le64(CEPH_NOSNAP);
1164
Alex Elderaded07e2012-07-03 16:01:18 -05001165 strncpy(req->r_oid, object_name, sizeof(req->r_oid));
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001166 req->r_oid_len = strlen(req->r_oid);
1167
1168 layout = &req->r_file_layout;
1169 memset(layout, 0, sizeof(*layout));
1170 layout->fl_stripe_unit = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
1171 layout->fl_stripe_count = cpu_to_le32(1);
1172 layout->fl_object_size = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
Alex Elder0d7dbfc2012-10-25 23:34:41 -05001173 layout->fl_pg_pool = cpu_to_le32((int) rbd_dev->spec->pool_id);
Sage Weil6cae3712012-09-24 21:02:47 -07001174 ret = ceph_calc_raw_layout(osdc, layout, snapid, ofs, &len, &bno,
1175 req, ops);
1176 rbd_assert(ret == 0);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001177
1178 ceph_osdc_build_request(req, ofs, &len,
1179 ops,
1180 snapc,
1181 &mtime,
1182 req->r_oid, req->r_oid_len);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001183
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001184 if (linger_req) {
Alex Elder1dbb4392012-01-24 10:08:37 -06001185 ceph_osdc_set_request_linger(osdc, req);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001186 *linger_req = req;
1187 }
1188
Alex Elder1dbb4392012-01-24 10:08:37 -06001189 ret = ceph_osdc_start_request(osdc, req, false);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001190 if (ret < 0)
1191 goto done_err;
1192
1193 if (!rbd_cb) {
Alex Elder1dbb4392012-01-24 10:08:37 -06001194 ret = ceph_osdc_wait_request(osdc, req);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001195 if (ver)
1196 *ver = le64_to_cpu(req->r_reassert_version.version);
Alex Elderbd919d42012-07-13 20:35:11 -05001197 dout("reassert_ver=%llu\n",
1198 (unsigned long long)
1199 le64_to_cpu(req->r_reassert_version.version));
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001200 ceph_osdc_put_request(req);
1201 }
1202 return ret;
1203
1204done_err:
Alex Elder725afc92012-11-08 08:01:39 -06001205 bio_chain_put(rbd_req->bio);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001206 ceph_osdc_put_request(req);
1207done_pages:
Alex Elder725afc92012-11-08 08:01:39 -06001208 rbd_coll_end_req(rbd_req, ret, len);
1209 kfree(rbd_req);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001210 return ret;
1211}
1212
1213/*
1214 * Ceph osd op callback
1215 */
1216static void rbd_req_cb(struct ceph_osd_request *req, struct ceph_msg *msg)
1217{
Alex Elder725afc92012-11-08 08:01:39 -06001218 struct rbd_request *rbd_req = req->r_priv;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001219 struct ceph_osd_reply_head *replyhead;
1220 struct ceph_osd_op *op;
1221 __s32 rc;
1222 u64 bytes;
1223 int read_op;
1224
1225 /* parse reply */
1226 replyhead = msg->front.iov_base;
1227 WARN_ON(le32_to_cpu(replyhead->num_ops) == 0);
1228 op = (void *)(replyhead + 1);
1229 rc = le32_to_cpu(replyhead->result);
1230 bytes = le64_to_cpu(op->extent.length);
Dan Carpenter895cfcc2012-06-06 09:15:33 -05001231 read_op = (le16_to_cpu(op->op) == CEPH_OSD_OP_READ);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001232
Alex Elderbd919d42012-07-13 20:35:11 -05001233 dout("rbd_req_cb bytes=%llu readop=%d rc=%d\n",
1234 (unsigned long long) bytes, read_op, (int) rc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001235
1236 if (rc == -ENOENT && read_op) {
Alex Elder725afc92012-11-08 08:01:39 -06001237 zero_bio_chain(rbd_req->bio, 0);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001238 rc = 0;
Alex Elder725afc92012-11-08 08:01:39 -06001239 } else if (rc == 0 && read_op && bytes < rbd_req->len) {
1240 zero_bio_chain(rbd_req->bio, bytes);
1241 bytes = rbd_req->len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001242 }
1243
Alex Elder725afc92012-11-08 08:01:39 -06001244 rbd_coll_end_req(rbd_req, rc, bytes);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001245
Alex Elder725afc92012-11-08 08:01:39 -06001246 if (rbd_req->bio)
1247 bio_chain_put(rbd_req->bio);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001248
1249 ceph_osdc_put_request(req);
Alex Elder725afc92012-11-08 08:01:39 -06001250 kfree(rbd_req);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001251}
1252
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001253static void rbd_simple_req_cb(struct ceph_osd_request *req, struct ceph_msg *msg)
1254{
1255 ceph_osdc_put_request(req);
1256}
1257
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001258/*
1259 * Do a synchronous ceph osd operation
1260 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001261static int rbd_req_sync_op(struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001262 struct ceph_snap_context *snapc,
1263 u64 snapid,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001264 int flags,
Alex Elder913d2fd2012-06-26 12:57:03 -07001265 struct ceph_osd_req_op *ops,
Alex Elderaded07e2012-07-03 16:01:18 -05001266 const char *object_name,
Alex Elderf8d4de62012-07-03 16:01:19 -05001267 u64 ofs, u64 inbound_size,
1268 char *inbound,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001269 struct ceph_osd_request **linger_req,
1270 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001271{
1272 int ret;
1273 struct page **pages;
1274 int num_pages;
Alex Elder913d2fd2012-06-26 12:57:03 -07001275
Alex Elderaafb2302012-09-06 16:00:54 -05001276 rbd_assert(ops != NULL);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001277
Alex Elderf8d4de62012-07-03 16:01:19 -05001278 num_pages = calc_pages_for(ofs, inbound_size);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001279 pages = ceph_alloc_page_vector(num_pages, GFP_KERNEL);
Dan Carpenterb8d06382010-10-11 21:14:23 +02001280 if (IS_ERR(pages))
1281 return PTR_ERR(pages);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001282
Alex Elder0ce1a792012-07-03 16:01:18 -05001283 ret = rbd_do_request(NULL, rbd_dev, snapc, snapid,
Alex Elderf8d4de62012-07-03 16:01:19 -05001284 object_name, ofs, inbound_size, NULL,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001285 pages, num_pages,
1286 flags,
1287 ops,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001288 NULL, 0,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001289 NULL,
1290 linger_req, ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001291 if (ret < 0)
Alex Elder913d2fd2012-06-26 12:57:03 -07001292 goto done;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001293
Alex Elderf8d4de62012-07-03 16:01:19 -05001294 if ((flags & CEPH_OSD_FLAG_READ) && inbound)
1295 ret = ceph_copy_from_page_vector(pages, inbound, ofs, ret);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001296
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001297done:
1298 ceph_release_page_vector(pages, num_pages);
1299 return ret;
1300}
1301
1302/*
1303 * Do an asynchronous ceph osd operation
1304 */
1305static int rbd_do_op(struct request *rq,
Alex Elder0ce1a792012-07-03 16:01:18 -05001306 struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001307 struct ceph_snap_context *snapc,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001308 u64 ofs, u64 len,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001309 struct bio *bio,
1310 struct rbd_req_coll *coll,
1311 int coll_index)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001312{
1313 char *seg_name;
1314 u64 seg_ofs;
1315 u64 seg_len;
1316 int ret;
1317 struct ceph_osd_req_op *ops;
1318 u32 payload_len;
Alex Elderff2e4bb2012-10-10 18:59:29 -07001319 int opcode;
1320 int flags;
Alex Elder46342462012-10-10 18:59:29 -07001321 u64 snapid;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001322
Alex Elder65ccfe22012-08-09 10:33:26 -07001323 seg_name = rbd_segment_name(rbd_dev, ofs);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001324 if (!seg_name)
1325 return -ENOMEM;
Alex Elder65ccfe22012-08-09 10:33:26 -07001326 seg_len = rbd_segment_length(rbd_dev, ofs, len);
1327 seg_ofs = rbd_segment_offset(rbd_dev, ofs);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001328
Alex Elderff2e4bb2012-10-10 18:59:29 -07001329 if (rq_data_dir(rq) == WRITE) {
1330 opcode = CEPH_OSD_OP_WRITE;
1331 flags = CEPH_OSD_FLAG_WRITE|CEPH_OSD_FLAG_ONDISK;
Alex Elder46342462012-10-10 18:59:29 -07001332 snapid = CEPH_NOSNAP;
Alex Elderff2e4bb2012-10-10 18:59:29 -07001333 payload_len = seg_len;
1334 } else {
1335 opcode = CEPH_OSD_OP_READ;
1336 flags = CEPH_OSD_FLAG_READ;
Alex Elder46342462012-10-10 18:59:29 -07001337 snapc = NULL;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05001338 snapid = rbd_dev->spec->snap_id;
Alex Elderff2e4bb2012-10-10 18:59:29 -07001339 payload_len = 0;
1340 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001341
Alex Elder57cfc102012-06-26 12:57:03 -07001342 ret = -ENOMEM;
1343 ops = rbd_create_rw_ops(1, opcode, payload_len);
1344 if (!ops)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001345 goto done;
1346
1347 /* we've taken care of segment sizes earlier when we
1348 cloned the bios. We should never have a segment
1349 truncated at this point */
Alex Elderaafb2302012-09-06 16:00:54 -05001350 rbd_assert(seg_len == len);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001351
1352 ret = rbd_do_request(rq, rbd_dev, snapc, snapid,
1353 seg_name, seg_ofs, seg_len,
1354 bio,
1355 NULL, 0,
1356 flags,
1357 ops,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001358 coll, coll_index,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001359 rbd_req_cb, 0, NULL);
Sage Weil11f77002011-05-12 16:13:54 -07001360
1361 rbd_destroy_ops(ops);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001362done:
1363 kfree(seg_name);
1364 return ret;
1365}
1366
1367/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001368 * Request sync osd read
1369 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001370static int rbd_req_sync_read(struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001371 u64 snapid,
Alex Elderaded07e2012-07-03 16:01:18 -05001372 const char *object_name,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001373 u64 ofs, u64 len,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001374 char *buf,
1375 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001376{
Alex Elder913d2fd2012-06-26 12:57:03 -07001377 struct ceph_osd_req_op *ops;
1378 int ret;
1379
1380 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_READ, 0);
1381 if (!ops)
1382 return -ENOMEM;
1383
1384 ret = rbd_req_sync_op(rbd_dev, NULL,
Josh Durginb06e6a62011-11-21 18:16:52 -08001385 snapid,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001386 CEPH_OSD_FLAG_READ,
Alex Elder913d2fd2012-06-26 12:57:03 -07001387 ops, object_name, ofs, len, buf, NULL, ver);
1388 rbd_destroy_ops(ops);
1389
1390 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001391}
1392
1393/*
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001394 * Request sync osd watch
1395 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001396static int rbd_req_sync_notify_ack(struct rbd_device *rbd_dev,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001397 u64 ver,
Alex Elder7f0a24d2012-07-25 09:32:40 -05001398 u64 notify_id)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001399{
1400 struct ceph_osd_req_op *ops;
Sage Weil11f77002011-05-12 16:13:54 -07001401 int ret;
1402
Alex Elder57cfc102012-06-26 12:57:03 -07001403 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_NOTIFY_ACK, 0);
1404 if (!ops)
1405 return -ENOMEM;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001406
Josh Durgina71b8912011-12-05 18:10:44 -08001407 ops[0].watch.ver = cpu_to_le64(ver);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001408 ops[0].watch.cookie = notify_id;
1409 ops[0].watch.flag = 0;
1410
Alex Elder0ce1a792012-07-03 16:01:18 -05001411 ret = rbd_do_request(NULL, rbd_dev, NULL, CEPH_NOSNAP,
Alex Elder7f0a24d2012-07-25 09:32:40 -05001412 rbd_dev->header_name, 0, 0, NULL,
Alex Elderad4f2322012-07-03 16:01:19 -05001413 NULL, 0,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001414 CEPH_OSD_FLAG_READ,
1415 ops,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001416 NULL, 0,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001417 rbd_simple_req_cb, 0, NULL);
1418
1419 rbd_destroy_ops(ops);
1420 return ret;
1421}
1422
1423static void rbd_watch_cb(u64 ver, u64 notify_id, u8 opcode, void *data)
1424{
Alex Elder0ce1a792012-07-03 16:01:18 -05001425 struct rbd_device *rbd_dev = (struct rbd_device *)data;
Josh Durgina71b8912011-12-05 18:10:44 -08001426 u64 hver;
Sage Weil13143d22011-05-12 16:08:30 -07001427 int rc;
1428
Alex Elder0ce1a792012-07-03 16:01:18 -05001429 if (!rbd_dev)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001430 return;
1431
Alex Elderbd919d42012-07-13 20:35:11 -05001432 dout("rbd_watch_cb %s notify_id=%llu opcode=%u\n",
1433 rbd_dev->header_name, (unsigned long long) notify_id,
1434 (unsigned int) opcode);
Alex Elder117973f2012-08-31 17:29:55 -05001435 rc = rbd_dev_refresh(rbd_dev, &hver);
Sage Weil13143d22011-05-12 16:08:30 -07001436 if (rc)
Alex Elder06ecc6c2012-11-01 10:17:15 -05001437 rbd_warn(rbd_dev, "got notification but failed to "
1438 " update snaps: %d\n", rc);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001439
Alex Elder7f0a24d2012-07-25 09:32:40 -05001440 rbd_req_sync_notify_ack(rbd_dev, hver, notify_id);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001441}
1442
1443/*
1444 * Request sync osd watch
1445 */
Alex Elder0e6f3222012-07-25 09:32:40 -05001446static int rbd_req_sync_watch(struct rbd_device *rbd_dev)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001447{
1448 struct ceph_osd_req_op *ops;
Alex Elder0ce1a792012-07-03 16:01:18 -05001449 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elder57cfc102012-06-26 12:57:03 -07001450 int ret;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001451
Alex Elder57cfc102012-06-26 12:57:03 -07001452 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_WATCH, 0);
1453 if (!ops)
1454 return -ENOMEM;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001455
1456 ret = ceph_osdc_create_event(osdc, rbd_watch_cb, 0,
Alex Elder0ce1a792012-07-03 16:01:18 -05001457 (void *)rbd_dev, &rbd_dev->watch_event);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001458 if (ret < 0)
1459 goto fail;
1460
Alex Elder0e6f3222012-07-25 09:32:40 -05001461 ops[0].watch.ver = cpu_to_le64(rbd_dev->header.obj_version);
Alex Elder0ce1a792012-07-03 16:01:18 -05001462 ops[0].watch.cookie = cpu_to_le64(rbd_dev->watch_event->cookie);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001463 ops[0].watch.flag = 1;
1464
Alex Elder0ce1a792012-07-03 16:01:18 -05001465 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001466 CEPH_NOSNAP,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001467 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1468 ops,
Alex Elder0e6f3222012-07-25 09:32:40 -05001469 rbd_dev->header_name,
1470 0, 0, NULL,
Alex Elder0ce1a792012-07-03 16:01:18 -05001471 &rbd_dev->watch_request, NULL);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001472
1473 if (ret < 0)
1474 goto fail_event;
1475
1476 rbd_destroy_ops(ops);
1477 return 0;
1478
1479fail_event:
Alex Elder0ce1a792012-07-03 16:01:18 -05001480 ceph_osdc_cancel_event(rbd_dev->watch_event);
1481 rbd_dev->watch_event = NULL;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001482fail:
1483 rbd_destroy_ops(ops);
1484 return ret;
1485}
1486
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001487/*
1488 * Request sync osd unwatch
1489 */
Alex Elder070c6332012-07-25 09:32:41 -05001490static int rbd_req_sync_unwatch(struct rbd_device *rbd_dev)
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001491{
1492 struct ceph_osd_req_op *ops;
Alex Elder57cfc102012-06-26 12:57:03 -07001493 int ret;
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001494
Alex Elder57cfc102012-06-26 12:57:03 -07001495 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_WATCH, 0);
1496 if (!ops)
1497 return -ENOMEM;
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001498
1499 ops[0].watch.ver = 0;
Alex Elder0ce1a792012-07-03 16:01:18 -05001500 ops[0].watch.cookie = cpu_to_le64(rbd_dev->watch_event->cookie);
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001501 ops[0].watch.flag = 0;
1502
Alex Elder0ce1a792012-07-03 16:01:18 -05001503 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001504 CEPH_NOSNAP,
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001505 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1506 ops,
Alex Elder070c6332012-07-25 09:32:41 -05001507 rbd_dev->header_name,
1508 0, 0, NULL, NULL, NULL);
1509
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001510
1511 rbd_destroy_ops(ops);
Alex Elder0ce1a792012-07-03 16:01:18 -05001512 ceph_osdc_cancel_event(rbd_dev->watch_event);
1513 rbd_dev->watch_event = NULL;
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001514 return ret;
1515}
1516
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001517/*
Alex Elder3cb4a682012-06-26 12:57:03 -07001518 * Synchronous osd object method call
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001519 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001520static int rbd_req_sync_exec(struct rbd_device *rbd_dev,
Alex Elderaded07e2012-07-03 16:01:18 -05001521 const char *object_name,
1522 const char *class_name,
1523 const char *method_name,
Alex Elder3cb4a682012-06-26 12:57:03 -07001524 const char *outbound,
1525 size_t outbound_size,
Alex Elderf8d4de62012-07-03 16:01:19 -05001526 char *inbound,
1527 size_t inbound_size,
Alex Elder3cb4a682012-06-26 12:57:03 -07001528 int flags,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001529 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001530{
1531 struct ceph_osd_req_op *ops;
Alex Elderaded07e2012-07-03 16:01:18 -05001532 int class_name_len = strlen(class_name);
1533 int method_name_len = strlen(method_name);
Alex Elder3cb4a682012-06-26 12:57:03 -07001534 int payload_size;
Alex Elder57cfc102012-06-26 12:57:03 -07001535 int ret;
1536
Alex Elder3cb4a682012-06-26 12:57:03 -07001537 /*
1538 * Any input parameters required by the method we're calling
1539 * will be sent along with the class and method names as
1540 * part of the message payload. That data and its size are
1541 * supplied via the indata and indata_len fields (named from
1542 * the perspective of the server side) in the OSD request
1543 * operation.
1544 */
1545 payload_size = class_name_len + method_name_len + outbound_size;
1546 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_CALL, payload_size);
Alex Elder57cfc102012-06-26 12:57:03 -07001547 if (!ops)
1548 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001549
Alex Elderaded07e2012-07-03 16:01:18 -05001550 ops[0].cls.class_name = class_name;
1551 ops[0].cls.class_len = (__u8) class_name_len;
1552 ops[0].cls.method_name = method_name;
1553 ops[0].cls.method_len = (__u8) method_name_len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001554 ops[0].cls.argc = 0;
Alex Elder3cb4a682012-06-26 12:57:03 -07001555 ops[0].cls.indata = outbound;
1556 ops[0].cls.indata_len = outbound_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001557
Alex Elder0ce1a792012-07-03 16:01:18 -05001558 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001559 CEPH_NOSNAP,
Alex Elder3cb4a682012-06-26 12:57:03 -07001560 flags, ops,
Alex Elderf8d4de62012-07-03 16:01:19 -05001561 object_name, 0, inbound_size, inbound,
1562 NULL, ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001563
1564 rbd_destroy_ops(ops);
1565
1566 dout("cls_exec returned %d\n", ret);
1567 return ret;
1568}
1569
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001570static struct rbd_req_coll *rbd_alloc_coll(int num_reqs)
1571{
1572 struct rbd_req_coll *coll =
1573 kzalloc(sizeof(struct rbd_req_coll) +
1574 sizeof(struct rbd_req_status) * num_reqs,
1575 GFP_ATOMIC);
1576
1577 if (!coll)
1578 return NULL;
1579 coll->total = num_reqs;
1580 kref_init(&coll->kref);
1581 return coll;
1582}
1583
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001584/*
1585 * block device queue callback
1586 */
1587static void rbd_rq_fn(struct request_queue *q)
1588{
1589 struct rbd_device *rbd_dev = q->queuedata;
1590 struct request *rq;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001591
Alex Elder00f1f362012-02-07 12:03:36 -06001592 while ((rq = blk_fetch_request(q))) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001593 struct bio *bio;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001594 bool do_write;
Alex Elderbd919d42012-07-13 20:35:11 -05001595 unsigned int size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001596 u64 ofs;
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001597 int num_segs, cur_seg = 0;
1598 struct rbd_req_coll *coll;
Josh Durgind1d25642011-12-05 14:03:05 -08001599 struct ceph_snap_context *snapc;
Alex Elderf7760da2012-10-20 22:17:27 -05001600 unsigned int bio_offset;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001601
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001602 dout("fetched request\n");
1603
1604 /* filter out block requests we don't understand */
1605 if ((rq->cmd_type != REQ_TYPE_FS)) {
1606 __blk_end_request_all(rq, 0);
Alex Elder00f1f362012-02-07 12:03:36 -06001607 continue;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001608 }
1609
1610 /* deduce our operation (read, write) */
1611 do_write = (rq_data_dir(rq) == WRITE);
Alex Elderf84344f2012-08-31 17:29:51 -05001612 if (do_write && rbd_dev->mapping.read_only) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001613 __blk_end_request_all(rq, -EROFS);
Alex Elder00f1f362012-02-07 12:03:36 -06001614 continue;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001615 }
1616
1617 spin_unlock_irq(q->queue_lock);
1618
Josh Durgind1d25642011-12-05 14:03:05 -08001619 down_read(&rbd_dev->header_rwsem);
Josh Durgine88a36e2011-11-21 18:14:25 -08001620
Alex Elderdaba5fd2012-10-26 17:25:23 -05001621 if (!rbd_dev->exists) {
Alex Elder0d7dbfc2012-10-25 23:34:41 -05001622 rbd_assert(rbd_dev->spec->snap_id != CEPH_NOSNAP);
Josh Durgine88a36e2011-11-21 18:14:25 -08001623 up_read(&rbd_dev->header_rwsem);
Josh Durgind1d25642011-12-05 14:03:05 -08001624 dout("request for non-existent snapshot");
1625 spin_lock_irq(q->queue_lock);
1626 __blk_end_request_all(rq, -ENXIO);
1627 continue;
Josh Durgine88a36e2011-11-21 18:14:25 -08001628 }
1629
Josh Durgind1d25642011-12-05 14:03:05 -08001630 snapc = ceph_get_snap_context(rbd_dev->header.snapc);
1631
1632 up_read(&rbd_dev->header_rwsem);
1633
Alex Elderf7760da2012-10-20 22:17:27 -05001634 size = blk_rq_bytes(rq);
1635 ofs = blk_rq_pos(rq) * SECTOR_SIZE;
1636 bio = rq->bio;
1637
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001638 dout("%s 0x%x bytes at 0x%llx\n",
1639 do_write ? "write" : "read",
Alex Elderbd919d42012-07-13 20:35:11 -05001640 size, (unsigned long long) blk_rq_pos(rq) * SECTOR_SIZE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001641
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001642 num_segs = rbd_get_num_segments(&rbd_dev->header, ofs, size);
Alex Elderdf111be2012-08-09 10:33:26 -07001643 if (num_segs <= 0) {
1644 spin_lock_irq(q->queue_lock);
1645 __blk_end_request_all(rq, num_segs);
1646 ceph_put_snap_context(snapc);
1647 continue;
1648 }
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001649 coll = rbd_alloc_coll(num_segs);
1650 if (!coll) {
1651 spin_lock_irq(q->queue_lock);
1652 __blk_end_request_all(rq, -ENOMEM);
Josh Durgind1d25642011-12-05 14:03:05 -08001653 ceph_put_snap_context(snapc);
Alex Elder00f1f362012-02-07 12:03:36 -06001654 continue;
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001655 }
1656
Alex Elderf7760da2012-10-20 22:17:27 -05001657 bio_offset = 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001658 do {
Alex Elderf7760da2012-10-20 22:17:27 -05001659 u64 limit = rbd_segment_length(rbd_dev, ofs, size);
1660 unsigned int chain_size;
1661 struct bio *bio_chain;
1662
1663 BUG_ON(limit > (u64) UINT_MAX);
1664 chain_size = (unsigned int) limit;
Alex Elderbd919d42012-07-13 20:35:11 -05001665 dout("rq->bio->bi_vcnt=%hu\n", rq->bio->bi_vcnt);
Alex Elderf7760da2012-10-20 22:17:27 -05001666
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001667 kref_get(&coll->kref);
Alex Elderf7760da2012-10-20 22:17:27 -05001668
1669 /* Pass a cloned bio chain via an osd request */
1670
1671 bio_chain = bio_chain_clone_range(&bio,
1672 &bio_offset, chain_size,
1673 GFP_ATOMIC);
1674 if (bio_chain)
Alex Elder46342462012-10-10 18:59:29 -07001675 (void) rbd_do_op(rq, rbd_dev, snapc,
Alex Elderf7760da2012-10-20 22:17:27 -05001676 ofs, chain_size,
1677 bio_chain, coll, cur_seg);
Alex Elder46342462012-10-10 18:59:29 -07001678 else
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001679 rbd_coll_end_req_index(rq, coll, cur_seg,
Alex Elderf7760da2012-10-20 22:17:27 -05001680 -ENOMEM, chain_size);
1681 size -= chain_size;
1682 ofs += chain_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001683
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001684 cur_seg++;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001685 } while (size > 0);
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001686 kref_put(&coll->kref, rbd_coll_release);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001687
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001688 spin_lock_irq(q->queue_lock);
Josh Durgind1d25642011-12-05 14:03:05 -08001689
1690 ceph_put_snap_context(snapc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001691 }
1692}
1693
1694/*
1695 * a queue callback. Makes sure that we don't create a bio that spans across
1696 * multiple osd objects. One exception would be with a single page bios,
Alex Elderf7760da2012-10-20 22:17:27 -05001697 * which we handle later at bio_chain_clone_range()
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001698 */
1699static int rbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bmd,
1700 struct bio_vec *bvec)
1701{
1702 struct rbd_device *rbd_dev = q->queuedata;
Alex Eldere5cfeed2012-10-20 22:17:27 -05001703 sector_t sector_offset;
1704 sector_t sectors_per_obj;
1705 sector_t obj_sector_offset;
1706 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001707
Alex Eldere5cfeed2012-10-20 22:17:27 -05001708 /*
1709 * Find how far into its rbd object the partition-relative
1710 * bio start sector is to offset relative to the enclosing
1711 * device.
1712 */
1713 sector_offset = get_start_sect(bmd->bi_bdev) + bmd->bi_sector;
1714 sectors_per_obj = 1 << (rbd_dev->header.obj_order - SECTOR_SHIFT);
1715 obj_sector_offset = sector_offset & (sectors_per_obj - 1);
Alex Elder593a9e72012-02-07 12:03:37 -06001716
Alex Eldere5cfeed2012-10-20 22:17:27 -05001717 /*
1718 * Compute the number of bytes from that offset to the end
1719 * of the object. Account for what's already used by the bio.
1720 */
1721 ret = (int) (sectors_per_obj - obj_sector_offset) << SECTOR_SHIFT;
1722 if (ret > bmd->bi_size)
1723 ret -= bmd->bi_size;
1724 else
1725 ret = 0;
1726
1727 /*
1728 * Don't send back more than was asked for. And if the bio
1729 * was empty, let the whole thing through because: "Note
1730 * that a block device *must* allow a single page to be
1731 * added to an empty bio."
1732 */
1733 rbd_assert(bvec->bv_len <= PAGE_SIZE);
1734 if (ret > (int) bvec->bv_len || !bmd->bi_size)
1735 ret = (int) bvec->bv_len;
1736
1737 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001738}
1739
1740static void rbd_free_disk(struct rbd_device *rbd_dev)
1741{
1742 struct gendisk *disk = rbd_dev->disk;
1743
1744 if (!disk)
1745 return;
1746
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001747 if (disk->flags & GENHD_FL_UP)
1748 del_gendisk(disk);
1749 if (disk->queue)
1750 blk_cleanup_queue(disk->queue);
1751 put_disk(disk);
1752}
1753
1754/*
Alex Elder4156d992012-08-02 11:29:46 -05001755 * Read the complete header for the given rbd device.
1756 *
1757 * Returns a pointer to a dynamically-allocated buffer containing
1758 * the complete and validated header. Caller can pass the address
1759 * of a variable that will be filled in with the version of the
1760 * header object at the time it was read.
1761 *
1762 * Returns a pointer-coded errno if a failure occurs.
1763 */
1764static struct rbd_image_header_ondisk *
1765rbd_dev_v1_header_read(struct rbd_device *rbd_dev, u64 *version)
1766{
1767 struct rbd_image_header_ondisk *ondisk = NULL;
1768 u32 snap_count = 0;
1769 u64 names_size = 0;
1770 u32 want_count;
1771 int ret;
1772
1773 /*
1774 * The complete header will include an array of its 64-bit
1775 * snapshot ids, followed by the names of those snapshots as
1776 * a contiguous block of NUL-terminated strings. Note that
1777 * the number of snapshots could change by the time we read
1778 * it in, in which case we re-read it.
1779 */
1780 do {
1781 size_t size;
1782
1783 kfree(ondisk);
1784
1785 size = sizeof (*ondisk);
1786 size += snap_count * sizeof (struct rbd_image_snap_ondisk);
1787 size += names_size;
1788 ondisk = kmalloc(size, GFP_KERNEL);
1789 if (!ondisk)
1790 return ERR_PTR(-ENOMEM);
1791
1792 ret = rbd_req_sync_read(rbd_dev, CEPH_NOSNAP,
1793 rbd_dev->header_name,
1794 0, size,
1795 (char *) ondisk, version);
1796
1797 if (ret < 0)
1798 goto out_err;
1799 if (WARN_ON((size_t) ret < size)) {
1800 ret = -ENXIO;
Alex Elder06ecc6c2012-11-01 10:17:15 -05001801 rbd_warn(rbd_dev, "short header read (want %zd got %d)",
1802 size, ret);
Alex Elder4156d992012-08-02 11:29:46 -05001803 goto out_err;
1804 }
1805 if (!rbd_dev_ondisk_valid(ondisk)) {
1806 ret = -ENXIO;
Alex Elder06ecc6c2012-11-01 10:17:15 -05001807 rbd_warn(rbd_dev, "invalid header");
Alex Elder4156d992012-08-02 11:29:46 -05001808 goto out_err;
1809 }
1810
1811 names_size = le64_to_cpu(ondisk->snap_names_len);
1812 want_count = snap_count;
1813 snap_count = le32_to_cpu(ondisk->snap_count);
1814 } while (snap_count != want_count);
1815
1816 return ondisk;
1817
1818out_err:
1819 kfree(ondisk);
1820
1821 return ERR_PTR(ret);
1822}
1823
1824/*
1825 * reload the ondisk the header
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001826 */
1827static int rbd_read_header(struct rbd_device *rbd_dev,
1828 struct rbd_image_header *header)
1829{
Alex Elder4156d992012-08-02 11:29:46 -05001830 struct rbd_image_header_ondisk *ondisk;
1831 u64 ver = 0;
1832 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001833
Alex Elder4156d992012-08-02 11:29:46 -05001834 ondisk = rbd_dev_v1_header_read(rbd_dev, &ver);
1835 if (IS_ERR(ondisk))
1836 return PTR_ERR(ondisk);
1837 ret = rbd_header_from_disk(header, ondisk);
1838 if (ret >= 0)
1839 header->obj_version = ver;
1840 kfree(ondisk);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001841
Alex Elder4156d992012-08-02 11:29:46 -05001842 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001843}
1844
Alex Elder41f38c22012-10-25 23:34:40 -05001845static void rbd_remove_all_snaps(struct rbd_device *rbd_dev)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001846{
1847 struct rbd_snap *snap;
Alex Eldera0593292012-07-19 09:09:27 -05001848 struct rbd_snap *next;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001849
Alex Eldera0593292012-07-19 09:09:27 -05001850 list_for_each_entry_safe(snap, next, &rbd_dev->snaps, node)
Alex Elder41f38c22012-10-25 23:34:40 -05001851 rbd_remove_snap_dev(snap);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001852}
1853
Alex Elder94785542012-10-09 13:50:17 -07001854static void rbd_update_mapping_size(struct rbd_device *rbd_dev)
1855{
1856 sector_t size;
1857
Alex Elder0d7dbfc2012-10-25 23:34:41 -05001858 if (rbd_dev->spec->snap_id != CEPH_NOSNAP)
Alex Elder94785542012-10-09 13:50:17 -07001859 return;
1860
1861 size = (sector_t) rbd_dev->header.image_size / SECTOR_SIZE;
1862 dout("setting size to %llu sectors", (unsigned long long) size);
1863 rbd_dev->mapping.size = (u64) size;
1864 set_capacity(rbd_dev->disk, size);
1865}
1866
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001867/*
1868 * only read the first part of the ondisk header, without the snaps info
1869 */
Alex Elder117973f2012-08-31 17:29:55 -05001870static int rbd_dev_v1_refresh(struct rbd_device *rbd_dev, u64 *hver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001871{
1872 int ret;
1873 struct rbd_image_header h;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001874
1875 ret = rbd_read_header(rbd_dev, &h);
1876 if (ret < 0)
1877 return ret;
1878
Josh Durgina51aa0c2011-12-05 10:35:04 -08001879 down_write(&rbd_dev->header_rwsem);
1880
Alex Elder94785542012-10-09 13:50:17 -07001881 /* Update image size, and check for resize of mapped image */
1882 rbd_dev->header.image_size = h.image_size;
1883 rbd_update_mapping_size(rbd_dev);
Sage Weil9db4b3e2011-04-19 22:49:06 -07001884
Alex Elder849b4262012-07-09 21:04:24 -05001885 /* rbd_dev->header.object_prefix shouldn't change */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001886 kfree(rbd_dev->header.snap_sizes);
Alex Elder849b4262012-07-09 21:04:24 -05001887 kfree(rbd_dev->header.snap_names);
Josh Durgind1d25642011-12-05 14:03:05 -08001888 /* osd requests may still refer to snapc */
1889 ceph_put_snap_context(rbd_dev->header.snapc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001890
Alex Elderb8136232012-07-25 09:32:41 -05001891 if (hver)
1892 *hver = h.obj_version;
Josh Durgina71b8912011-12-05 18:10:44 -08001893 rbd_dev->header.obj_version = h.obj_version;
Josh Durgin93a24e02011-12-05 10:41:28 -08001894 rbd_dev->header.image_size = h.image_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001895 rbd_dev->header.snapc = h.snapc;
1896 rbd_dev->header.snap_names = h.snap_names;
1897 rbd_dev->header.snap_sizes = h.snap_sizes;
Alex Elder849b4262012-07-09 21:04:24 -05001898 /* Free the extra copy of the object prefix */
1899 WARN_ON(strcmp(rbd_dev->header.object_prefix, h.object_prefix));
1900 kfree(h.object_prefix);
1901
Alex Elder304f6802012-08-31 17:29:52 -05001902 ret = rbd_dev_snaps_update(rbd_dev);
1903 if (!ret)
1904 ret = rbd_dev_snaps_register(rbd_dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001905
Josh Durginc6666012011-11-21 17:11:12 -08001906 up_write(&rbd_dev->header_rwsem);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001907
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001908 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001909}
1910
Alex Elder117973f2012-08-31 17:29:55 -05001911static int rbd_dev_refresh(struct rbd_device *rbd_dev, u64 *hver)
Alex Elder1fe5e992012-07-25 09:32:41 -05001912{
1913 int ret;
1914
Alex Elder117973f2012-08-31 17:29:55 -05001915 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
Alex Elder1fe5e992012-07-25 09:32:41 -05001916 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Alex Elder117973f2012-08-31 17:29:55 -05001917 if (rbd_dev->image_format == 1)
1918 ret = rbd_dev_v1_refresh(rbd_dev, hver);
1919 else
1920 ret = rbd_dev_v2_refresh(rbd_dev, hver);
Alex Elder1fe5e992012-07-25 09:32:41 -05001921 mutex_unlock(&ctl_mutex);
1922
1923 return ret;
1924}
1925
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001926static int rbd_init_disk(struct rbd_device *rbd_dev)
1927{
1928 struct gendisk *disk;
1929 struct request_queue *q;
Alex Elder593a9e72012-02-07 12:03:37 -06001930 u64 segment_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001931
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001932 /* create gendisk info */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001933 disk = alloc_disk(RBD_MINORS_PER_MAJOR);
1934 if (!disk)
Alex Elder1fcdb8a2012-08-29 17:11:06 -05001935 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001936
Alex Elderf0f8cef2012-01-29 13:57:44 -06001937 snprintf(disk->disk_name, sizeof(disk->disk_name), RBD_DRV_NAME "%d",
Alex Elderde71a292012-07-03 16:01:19 -05001938 rbd_dev->dev_id);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001939 disk->major = rbd_dev->major;
1940 disk->first_minor = 0;
1941 disk->fops = &rbd_bd_ops;
1942 disk->private_data = rbd_dev;
1943
1944 /* init rq */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001945 q = blk_init_queue(rbd_rq_fn, &rbd_dev->lock);
1946 if (!q)
1947 goto out_disk;
Josh Durgin029bcbd2011-07-22 11:35:23 -07001948
Alex Elder593a9e72012-02-07 12:03:37 -06001949 /* We use the default size, but let's be explicit about it. */
1950 blk_queue_physical_block_size(q, SECTOR_SIZE);
1951
Josh Durgin029bcbd2011-07-22 11:35:23 -07001952 /* set io sizes to object size */
Alex Elder593a9e72012-02-07 12:03:37 -06001953 segment_size = rbd_obj_bytes(&rbd_dev->header);
1954 blk_queue_max_hw_sectors(q, segment_size / SECTOR_SIZE);
1955 blk_queue_max_segment_size(q, segment_size);
1956 blk_queue_io_min(q, segment_size);
1957 blk_queue_io_opt(q, segment_size);
Josh Durgin029bcbd2011-07-22 11:35:23 -07001958
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001959 blk_queue_merge_bvec(q, rbd_merge_bvec);
1960 disk->queue = q;
1961
1962 q->queuedata = rbd_dev;
1963
1964 rbd_dev->disk = disk;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001965
Alex Elder12f02942012-08-29 17:11:07 -05001966 set_capacity(rbd_dev->disk, rbd_dev->mapping.size / SECTOR_SIZE);
1967
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001968 return 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001969out_disk:
1970 put_disk(disk);
Alex Elder1fcdb8a2012-08-29 17:11:06 -05001971
1972 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001973}
1974
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001975/*
1976 sysfs
1977*/
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001978
Alex Elder593a9e72012-02-07 12:03:37 -06001979static struct rbd_device *dev_to_rbd_dev(struct device *dev)
1980{
1981 return container_of(dev, struct rbd_device, dev);
1982}
1983
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001984static ssize_t rbd_size_show(struct device *dev,
1985 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001986{
Alex Elder593a9e72012-02-07 12:03:37 -06001987 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Josh Durgina51aa0c2011-12-05 10:35:04 -08001988 sector_t size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001989
Josh Durgina51aa0c2011-12-05 10:35:04 -08001990 down_read(&rbd_dev->header_rwsem);
1991 size = get_capacity(rbd_dev->disk);
1992 up_read(&rbd_dev->header_rwsem);
1993
1994 return sprintf(buf, "%llu\n", (unsigned long long) size * SECTOR_SIZE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001995}
1996
Alex Elder34b13182012-07-13 20:35:12 -05001997/*
1998 * Note this shows the features for whatever's mapped, which is not
1999 * necessarily the base image.
2000 */
2001static ssize_t rbd_features_show(struct device *dev,
2002 struct device_attribute *attr, char *buf)
2003{
2004 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2005
2006 return sprintf(buf, "0x%016llx\n",
2007 (unsigned long long) rbd_dev->mapping.features);
2008}
2009
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002010static ssize_t rbd_major_show(struct device *dev,
2011 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002012{
Alex Elder593a9e72012-02-07 12:03:37 -06002013 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002014
2015 return sprintf(buf, "%d\n", rbd_dev->major);
2016}
2017
2018static ssize_t rbd_client_id_show(struct device *dev,
2019 struct device_attribute *attr, char *buf)
2020{
Alex Elder593a9e72012-02-07 12:03:37 -06002021 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002022
Alex Elder1dbb4392012-01-24 10:08:37 -06002023 return sprintf(buf, "client%lld\n",
2024 ceph_client_id(rbd_dev->rbd_client->client));
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002025}
2026
2027static ssize_t rbd_pool_show(struct device *dev,
2028 struct device_attribute *attr, char *buf)
2029{
Alex Elder593a9e72012-02-07 12:03:37 -06002030 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002031
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002032 return sprintf(buf, "%s\n", rbd_dev->spec->pool_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002033}
2034
Alex Elder9bb2f332012-07-12 10:46:35 -05002035static ssize_t rbd_pool_id_show(struct device *dev,
2036 struct device_attribute *attr, char *buf)
2037{
2038 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2039
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002040 return sprintf(buf, "%llu\n",
2041 (unsigned long long) rbd_dev->spec->pool_id);
Alex Elder9bb2f332012-07-12 10:46:35 -05002042}
2043
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002044static ssize_t rbd_name_show(struct device *dev,
2045 struct device_attribute *attr, char *buf)
2046{
Alex Elder593a9e72012-02-07 12:03:37 -06002047 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002048
Alex Eldera92ffdf2012-10-30 19:40:33 -05002049 if (rbd_dev->spec->image_name)
2050 return sprintf(buf, "%s\n", rbd_dev->spec->image_name);
2051
2052 return sprintf(buf, "(unknown)\n");
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002053}
2054
Alex Elder589d30e2012-07-10 20:30:11 -05002055static ssize_t rbd_image_id_show(struct device *dev,
2056 struct device_attribute *attr, char *buf)
2057{
2058 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2059
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002060 return sprintf(buf, "%s\n", rbd_dev->spec->image_id);
Alex Elder589d30e2012-07-10 20:30:11 -05002061}
2062
Alex Elder34b13182012-07-13 20:35:12 -05002063/*
2064 * Shows the name of the currently-mapped snapshot (or
2065 * RBD_SNAP_HEAD_NAME for the base image).
2066 */
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002067static ssize_t rbd_snap_show(struct device *dev,
2068 struct device_attribute *attr,
2069 char *buf)
2070{
Alex Elder593a9e72012-02-07 12:03:37 -06002071 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002072
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002073 return sprintf(buf, "%s\n", rbd_dev->spec->snap_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002074}
2075
Alex Elder86b00e02012-10-25 23:34:42 -05002076/*
2077 * For an rbd v2 image, shows the pool id, image id, and snapshot id
2078 * for the parent image. If there is no parent, simply shows
2079 * "(no parent image)".
2080 */
2081static ssize_t rbd_parent_show(struct device *dev,
2082 struct device_attribute *attr,
2083 char *buf)
2084{
2085 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2086 struct rbd_spec *spec = rbd_dev->parent_spec;
2087 int count;
2088 char *bufp = buf;
2089
2090 if (!spec)
2091 return sprintf(buf, "(no parent image)\n");
2092
2093 count = sprintf(bufp, "pool_id %llu\npool_name %s\n",
2094 (unsigned long long) spec->pool_id, spec->pool_name);
2095 if (count < 0)
2096 return count;
2097 bufp += count;
2098
2099 count = sprintf(bufp, "image_id %s\nimage_name %s\n", spec->image_id,
2100 spec->image_name ? spec->image_name : "(unknown)");
2101 if (count < 0)
2102 return count;
2103 bufp += count;
2104
2105 count = sprintf(bufp, "snap_id %llu\nsnap_name %s\n",
2106 (unsigned long long) spec->snap_id, spec->snap_name);
2107 if (count < 0)
2108 return count;
2109 bufp += count;
2110
2111 count = sprintf(bufp, "overlap %llu\n", rbd_dev->parent_overlap);
2112 if (count < 0)
2113 return count;
2114 bufp += count;
2115
2116 return (ssize_t) (bufp - buf);
2117}
2118
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002119static ssize_t rbd_image_refresh(struct device *dev,
2120 struct device_attribute *attr,
2121 const char *buf,
2122 size_t size)
2123{
Alex Elder593a9e72012-02-07 12:03:37 -06002124 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Alex Elderb8136232012-07-25 09:32:41 -05002125 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002126
Alex Elder117973f2012-08-31 17:29:55 -05002127 ret = rbd_dev_refresh(rbd_dev, NULL);
Alex Elderb8136232012-07-25 09:32:41 -05002128
2129 return ret < 0 ? ret : size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002130}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002131
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002132static DEVICE_ATTR(size, S_IRUGO, rbd_size_show, NULL);
Alex Elder34b13182012-07-13 20:35:12 -05002133static DEVICE_ATTR(features, S_IRUGO, rbd_features_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002134static DEVICE_ATTR(major, S_IRUGO, rbd_major_show, NULL);
2135static DEVICE_ATTR(client_id, S_IRUGO, rbd_client_id_show, NULL);
2136static DEVICE_ATTR(pool, S_IRUGO, rbd_pool_show, NULL);
Alex Elder9bb2f332012-07-12 10:46:35 -05002137static DEVICE_ATTR(pool_id, S_IRUGO, rbd_pool_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002138static DEVICE_ATTR(name, S_IRUGO, rbd_name_show, NULL);
Alex Elder589d30e2012-07-10 20:30:11 -05002139static DEVICE_ATTR(image_id, S_IRUGO, rbd_image_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002140static DEVICE_ATTR(refresh, S_IWUSR, NULL, rbd_image_refresh);
2141static DEVICE_ATTR(current_snap, S_IRUGO, rbd_snap_show, NULL);
Alex Elder86b00e02012-10-25 23:34:42 -05002142static DEVICE_ATTR(parent, S_IRUGO, rbd_parent_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002143
2144static struct attribute *rbd_attrs[] = {
2145 &dev_attr_size.attr,
Alex Elder34b13182012-07-13 20:35:12 -05002146 &dev_attr_features.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002147 &dev_attr_major.attr,
2148 &dev_attr_client_id.attr,
2149 &dev_attr_pool.attr,
Alex Elder9bb2f332012-07-12 10:46:35 -05002150 &dev_attr_pool_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002151 &dev_attr_name.attr,
Alex Elder589d30e2012-07-10 20:30:11 -05002152 &dev_attr_image_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002153 &dev_attr_current_snap.attr,
Alex Elder86b00e02012-10-25 23:34:42 -05002154 &dev_attr_parent.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002155 &dev_attr_refresh.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002156 NULL
2157};
2158
2159static struct attribute_group rbd_attr_group = {
2160 .attrs = rbd_attrs,
2161};
2162
2163static const struct attribute_group *rbd_attr_groups[] = {
2164 &rbd_attr_group,
2165 NULL
2166};
2167
2168static void rbd_sysfs_dev_release(struct device *dev)
2169{
2170}
2171
2172static struct device_type rbd_device_type = {
2173 .name = "rbd",
2174 .groups = rbd_attr_groups,
2175 .release = rbd_sysfs_dev_release,
2176};
2177
2178
2179/*
2180 sysfs - snapshots
2181*/
2182
2183static ssize_t rbd_snap_size_show(struct device *dev,
2184 struct device_attribute *attr,
2185 char *buf)
2186{
2187 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2188
Josh Durgin35915382011-12-05 18:25:13 -08002189 return sprintf(buf, "%llu\n", (unsigned long long)snap->size);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002190}
2191
2192static ssize_t rbd_snap_id_show(struct device *dev,
2193 struct device_attribute *attr,
2194 char *buf)
2195{
2196 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2197
Josh Durgin35915382011-12-05 18:25:13 -08002198 return sprintf(buf, "%llu\n", (unsigned long long)snap->id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002199}
2200
Alex Elder34b13182012-07-13 20:35:12 -05002201static ssize_t rbd_snap_features_show(struct device *dev,
2202 struct device_attribute *attr,
2203 char *buf)
2204{
2205 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2206
2207 return sprintf(buf, "0x%016llx\n",
2208 (unsigned long long) snap->features);
2209}
2210
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002211static DEVICE_ATTR(snap_size, S_IRUGO, rbd_snap_size_show, NULL);
2212static DEVICE_ATTR(snap_id, S_IRUGO, rbd_snap_id_show, NULL);
Alex Elder34b13182012-07-13 20:35:12 -05002213static DEVICE_ATTR(snap_features, S_IRUGO, rbd_snap_features_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002214
2215static struct attribute *rbd_snap_attrs[] = {
2216 &dev_attr_snap_size.attr,
2217 &dev_attr_snap_id.attr,
Alex Elder34b13182012-07-13 20:35:12 -05002218 &dev_attr_snap_features.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002219 NULL,
2220};
2221
2222static struct attribute_group rbd_snap_attr_group = {
2223 .attrs = rbd_snap_attrs,
2224};
2225
2226static void rbd_snap_dev_release(struct device *dev)
2227{
2228 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2229 kfree(snap->name);
2230 kfree(snap);
2231}
2232
2233static const struct attribute_group *rbd_snap_attr_groups[] = {
2234 &rbd_snap_attr_group,
2235 NULL
2236};
2237
2238static struct device_type rbd_snap_device_type = {
2239 .groups = rbd_snap_attr_groups,
2240 .release = rbd_snap_dev_release,
2241};
2242
Alex Elder8b8fb992012-10-26 17:25:24 -05002243static struct rbd_spec *rbd_spec_get(struct rbd_spec *spec)
2244{
2245 kref_get(&spec->kref);
2246
2247 return spec;
2248}
2249
2250static void rbd_spec_free(struct kref *kref);
2251static void rbd_spec_put(struct rbd_spec *spec)
2252{
2253 if (spec)
2254 kref_put(&spec->kref, rbd_spec_free);
2255}
2256
2257static struct rbd_spec *rbd_spec_alloc(void)
2258{
2259 struct rbd_spec *spec;
2260
2261 spec = kzalloc(sizeof (*spec), GFP_KERNEL);
2262 if (!spec)
2263 return NULL;
2264 kref_init(&spec->kref);
2265
2266 rbd_spec_put(rbd_spec_get(spec)); /* TEMPORARY */
2267
2268 return spec;
2269}
2270
2271static void rbd_spec_free(struct kref *kref)
2272{
2273 struct rbd_spec *spec = container_of(kref, struct rbd_spec, kref);
2274
2275 kfree(spec->pool_name);
2276 kfree(spec->image_id);
2277 kfree(spec->image_name);
2278 kfree(spec->snap_name);
2279 kfree(spec);
2280}
2281
Alex Elderc53d5892012-10-25 23:34:42 -05002282struct rbd_device *rbd_dev_create(struct rbd_client *rbdc,
2283 struct rbd_spec *spec)
2284{
2285 struct rbd_device *rbd_dev;
2286
2287 rbd_dev = kzalloc(sizeof (*rbd_dev), GFP_KERNEL);
2288 if (!rbd_dev)
2289 return NULL;
2290
2291 spin_lock_init(&rbd_dev->lock);
2292 INIT_LIST_HEAD(&rbd_dev->node);
2293 INIT_LIST_HEAD(&rbd_dev->snaps);
2294 init_rwsem(&rbd_dev->header_rwsem);
2295
2296 rbd_dev->spec = spec;
2297 rbd_dev->rbd_client = rbdc;
2298
2299 return rbd_dev;
2300}
2301
2302static void rbd_dev_destroy(struct rbd_device *rbd_dev)
2303{
Alex Elder86b00e02012-10-25 23:34:42 -05002304 rbd_spec_put(rbd_dev->parent_spec);
Alex Elderc53d5892012-10-25 23:34:42 -05002305 kfree(rbd_dev->header_name);
2306 rbd_put_client(rbd_dev->rbd_client);
2307 rbd_spec_put(rbd_dev->spec);
2308 kfree(rbd_dev);
2309}
2310
Alex Elder304f6802012-08-31 17:29:52 -05002311static bool rbd_snap_registered(struct rbd_snap *snap)
2312{
2313 bool ret = snap->dev.type == &rbd_snap_device_type;
2314 bool reg = device_is_registered(&snap->dev);
2315
2316 rbd_assert(!ret ^ reg);
2317
2318 return ret;
2319}
2320
Alex Elder41f38c22012-10-25 23:34:40 -05002321static void rbd_remove_snap_dev(struct rbd_snap *snap)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002322{
2323 list_del(&snap->node);
Alex Elder304f6802012-08-31 17:29:52 -05002324 if (device_is_registered(&snap->dev))
2325 device_unregister(&snap->dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002326}
2327
Alex Elder14e70852012-07-19 09:09:27 -05002328static int rbd_register_snap_dev(struct rbd_snap *snap,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002329 struct device *parent)
2330{
2331 struct device *dev = &snap->dev;
2332 int ret;
2333
2334 dev->type = &rbd_snap_device_type;
2335 dev->parent = parent;
2336 dev->release = rbd_snap_dev_release;
Alex Elderd4b125e2012-07-03 16:01:19 -05002337 dev_set_name(dev, "%s%s", RBD_SNAP_DEV_NAME_PREFIX, snap->name);
Alex Elder304f6802012-08-31 17:29:52 -05002338 dout("%s: registering device for snapshot %s\n", __func__, snap->name);
2339
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002340 ret = device_register(dev);
2341
2342 return ret;
2343}
2344
Alex Elder4e891e02012-07-10 20:30:10 -05002345static struct rbd_snap *__rbd_add_snap_dev(struct rbd_device *rbd_dev,
Alex Elderc8d18422012-07-10 20:30:11 -05002346 const char *snap_name,
Alex Elder34b13182012-07-13 20:35:12 -05002347 u64 snap_id, u64 snap_size,
2348 u64 snap_features)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002349{
Alex Elder4e891e02012-07-10 20:30:10 -05002350 struct rbd_snap *snap;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002351 int ret;
Alex Elder4e891e02012-07-10 20:30:10 -05002352
2353 snap = kzalloc(sizeof (*snap), GFP_KERNEL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002354 if (!snap)
Alex Elder4e891e02012-07-10 20:30:10 -05002355 return ERR_PTR(-ENOMEM);
2356
2357 ret = -ENOMEM;
Alex Elderc8d18422012-07-10 20:30:11 -05002358 snap->name = kstrdup(snap_name, GFP_KERNEL);
Alex Elder4e891e02012-07-10 20:30:10 -05002359 if (!snap->name)
2360 goto err;
2361
Alex Elderc8d18422012-07-10 20:30:11 -05002362 snap->id = snap_id;
2363 snap->size = snap_size;
Alex Elder34b13182012-07-13 20:35:12 -05002364 snap->features = snap_features;
Alex Elder4e891e02012-07-10 20:30:10 -05002365
2366 return snap;
2367
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002368err:
2369 kfree(snap->name);
2370 kfree(snap);
Alex Elder4e891e02012-07-10 20:30:10 -05002371
2372 return ERR_PTR(ret);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002373}
2374
Alex Eldercd892122012-07-03 16:01:19 -05002375static char *rbd_dev_v1_snap_info(struct rbd_device *rbd_dev, u32 which,
2376 u64 *snap_size, u64 *snap_features)
2377{
2378 char *snap_name;
2379
2380 rbd_assert(which < rbd_dev->header.snapc->num_snaps);
2381
2382 *snap_size = rbd_dev->header.snap_sizes[which];
2383 *snap_features = 0; /* No features for v1 */
2384
2385 /* Skip over names until we find the one we are looking for */
2386
2387 snap_name = rbd_dev->header.snap_names;
2388 while (which--)
2389 snap_name += strlen(snap_name) + 1;
2390
2391 return snap_name;
2392}
2393
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002394/*
Alex Elder9d475de2012-07-03 16:01:19 -05002395 * Get the size and object order for an image snapshot, or if
2396 * snap_id is CEPH_NOSNAP, gets this information for the base
2397 * image.
2398 */
2399static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
2400 u8 *order, u64 *snap_size)
2401{
2402 __le64 snapid = cpu_to_le64(snap_id);
2403 int ret;
2404 struct {
2405 u8 order;
2406 __le64 size;
2407 } __attribute__ ((packed)) size_buf = { 0 };
2408
2409 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2410 "rbd", "get_size",
2411 (char *) &snapid, sizeof (snapid),
2412 (char *) &size_buf, sizeof (size_buf),
2413 CEPH_OSD_FLAG_READ, NULL);
2414 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2415 if (ret < 0)
2416 return ret;
2417
2418 *order = size_buf.order;
2419 *snap_size = le64_to_cpu(size_buf.size);
2420
2421 dout(" snap_id 0x%016llx order = %u, snap_size = %llu\n",
2422 (unsigned long long) snap_id, (unsigned int) *order,
2423 (unsigned long long) *snap_size);
2424
2425 return 0;
2426}
2427
2428static int rbd_dev_v2_image_size(struct rbd_device *rbd_dev)
2429{
2430 return _rbd_dev_v2_snap_size(rbd_dev, CEPH_NOSNAP,
2431 &rbd_dev->header.obj_order,
2432 &rbd_dev->header.image_size);
2433}
2434
Alex Elder1e130192012-07-03 16:01:19 -05002435static int rbd_dev_v2_object_prefix(struct rbd_device *rbd_dev)
2436{
2437 void *reply_buf;
2438 int ret;
2439 void *p;
2440
2441 reply_buf = kzalloc(RBD_OBJ_PREFIX_LEN_MAX, GFP_KERNEL);
2442 if (!reply_buf)
2443 return -ENOMEM;
2444
2445 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2446 "rbd", "get_object_prefix",
2447 NULL, 0,
2448 reply_buf, RBD_OBJ_PREFIX_LEN_MAX,
2449 CEPH_OSD_FLAG_READ, NULL);
2450 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2451 if (ret < 0)
2452 goto out;
Alex Eldera0ea3a42012-10-10 21:19:13 -07002453 ret = 0; /* rbd_req_sync_exec() can return positive */
Alex Elder1e130192012-07-03 16:01:19 -05002454
2455 p = reply_buf;
2456 rbd_dev->header.object_prefix = ceph_extract_encoded_string(&p,
2457 p + RBD_OBJ_PREFIX_LEN_MAX,
2458 NULL, GFP_NOIO);
2459
2460 if (IS_ERR(rbd_dev->header.object_prefix)) {
2461 ret = PTR_ERR(rbd_dev->header.object_prefix);
2462 rbd_dev->header.object_prefix = NULL;
2463 } else {
2464 dout(" object_prefix = %s\n", rbd_dev->header.object_prefix);
2465 }
2466
2467out:
2468 kfree(reply_buf);
2469
2470 return ret;
2471}
2472
Alex Elderb1b54022012-07-03 16:01:19 -05002473static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
2474 u64 *snap_features)
2475{
2476 __le64 snapid = cpu_to_le64(snap_id);
2477 struct {
2478 __le64 features;
2479 __le64 incompat;
2480 } features_buf = { 0 };
Alex Elderd8891402012-10-09 13:50:17 -07002481 u64 incompat;
Alex Elderb1b54022012-07-03 16:01:19 -05002482 int ret;
2483
2484 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2485 "rbd", "get_features",
2486 (char *) &snapid, sizeof (snapid),
2487 (char *) &features_buf, sizeof (features_buf),
2488 CEPH_OSD_FLAG_READ, NULL);
2489 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2490 if (ret < 0)
2491 return ret;
Alex Elderd8891402012-10-09 13:50:17 -07002492
2493 incompat = le64_to_cpu(features_buf.incompat);
2494 if (incompat & ~RBD_FEATURES_ALL)
Alex Elderb8f5c6e2012-11-01 08:39:26 -05002495 return -ENXIO;
Alex Elderd8891402012-10-09 13:50:17 -07002496
Alex Elderb1b54022012-07-03 16:01:19 -05002497 *snap_features = le64_to_cpu(features_buf.features);
2498
2499 dout(" snap_id 0x%016llx features = 0x%016llx incompat = 0x%016llx\n",
2500 (unsigned long long) snap_id,
2501 (unsigned long long) *snap_features,
2502 (unsigned long long) le64_to_cpu(features_buf.incompat));
2503
2504 return 0;
2505}
2506
2507static int rbd_dev_v2_features(struct rbd_device *rbd_dev)
2508{
2509 return _rbd_dev_v2_snap_features(rbd_dev, CEPH_NOSNAP,
2510 &rbd_dev->header.features);
2511}
2512
Alex Elder86b00e02012-10-25 23:34:42 -05002513static int rbd_dev_v2_parent_info(struct rbd_device *rbd_dev)
2514{
2515 struct rbd_spec *parent_spec;
2516 size_t size;
2517 void *reply_buf = NULL;
2518 __le64 snapid;
2519 void *p;
2520 void *end;
2521 char *image_id;
2522 u64 overlap;
Alex Elder86b00e02012-10-25 23:34:42 -05002523 int ret;
2524
2525 parent_spec = rbd_spec_alloc();
2526 if (!parent_spec)
2527 return -ENOMEM;
2528
2529 size = sizeof (__le64) + /* pool_id */
2530 sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX + /* image_id */
2531 sizeof (__le64) + /* snap_id */
2532 sizeof (__le64); /* overlap */
2533 reply_buf = kmalloc(size, GFP_KERNEL);
2534 if (!reply_buf) {
2535 ret = -ENOMEM;
2536 goto out_err;
2537 }
2538
2539 snapid = cpu_to_le64(CEPH_NOSNAP);
2540 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2541 "rbd", "get_parent",
2542 (char *) &snapid, sizeof (snapid),
2543 (char *) reply_buf, size,
2544 CEPH_OSD_FLAG_READ, NULL);
2545 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2546 if (ret < 0)
2547 goto out_err;
2548
2549 ret = -ERANGE;
2550 p = reply_buf;
2551 end = (char *) reply_buf + size;
2552 ceph_decode_64_safe(&p, end, parent_spec->pool_id, out_err);
2553 if (parent_spec->pool_id == CEPH_NOPOOL)
2554 goto out; /* No parent? No problem. */
2555
Alex Elder979ed482012-11-01 08:39:26 -05002556 image_id = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
Alex Elder86b00e02012-10-25 23:34:42 -05002557 if (IS_ERR(image_id)) {
2558 ret = PTR_ERR(image_id);
2559 goto out_err;
2560 }
2561 parent_spec->image_id = image_id;
2562 ceph_decode_64_safe(&p, end, parent_spec->snap_id, out_err);
2563 ceph_decode_64_safe(&p, end, overlap, out_err);
2564
2565 rbd_dev->parent_overlap = overlap;
2566 rbd_dev->parent_spec = parent_spec;
2567 parent_spec = NULL; /* rbd_dev now owns this */
2568out:
2569 ret = 0;
2570out_err:
2571 kfree(reply_buf);
2572 rbd_spec_put(parent_spec);
2573
2574 return ret;
2575}
2576
Alex Elder9e15b772012-10-30 19:40:33 -05002577static char *rbd_dev_image_name(struct rbd_device *rbd_dev)
2578{
2579 size_t image_id_size;
2580 char *image_id;
2581 void *p;
2582 void *end;
2583 size_t size;
2584 void *reply_buf = NULL;
2585 size_t len = 0;
2586 char *image_name = NULL;
2587 int ret;
2588
2589 rbd_assert(!rbd_dev->spec->image_name);
2590
Alex Elder69e7a022012-11-01 08:39:26 -05002591 len = strlen(rbd_dev->spec->image_id);
2592 image_id_size = sizeof (__le32) + len;
Alex Elder9e15b772012-10-30 19:40:33 -05002593 image_id = kmalloc(image_id_size, GFP_KERNEL);
2594 if (!image_id)
2595 return NULL;
2596
2597 p = image_id;
2598 end = (char *) image_id + image_id_size;
Alex Elder69e7a022012-11-01 08:39:26 -05002599 ceph_encode_string(&p, end, rbd_dev->spec->image_id, (u32) len);
Alex Elder9e15b772012-10-30 19:40:33 -05002600
2601 size = sizeof (__le32) + RBD_IMAGE_NAME_LEN_MAX;
2602 reply_buf = kmalloc(size, GFP_KERNEL);
2603 if (!reply_buf)
2604 goto out;
2605
2606 ret = rbd_req_sync_exec(rbd_dev, RBD_DIRECTORY,
2607 "rbd", "dir_get_name",
2608 image_id, image_id_size,
2609 (char *) reply_buf, size,
2610 CEPH_OSD_FLAG_READ, NULL);
2611 if (ret < 0)
2612 goto out;
2613 p = reply_buf;
2614 end = (char *) reply_buf + size;
2615 image_name = ceph_extract_encoded_string(&p, end, &len, GFP_KERNEL);
2616 if (IS_ERR(image_name))
2617 image_name = NULL;
2618 else
2619 dout("%s: name is %s len is %zd\n", __func__, image_name, len);
2620out:
2621 kfree(reply_buf);
2622 kfree(image_id);
2623
2624 return image_name;
2625}
2626
2627/*
2628 * When a parent image gets probed, we only have the pool, image,
2629 * and snapshot ids but not the names of any of them. This call
2630 * is made later to fill in those names. It has to be done after
2631 * rbd_dev_snaps_update() has completed because some of the
2632 * information (in particular, snapshot name) is not available
2633 * until then.
2634 */
2635static int rbd_dev_probe_update_spec(struct rbd_device *rbd_dev)
2636{
2637 struct ceph_osd_client *osdc;
2638 const char *name;
2639 void *reply_buf = NULL;
2640 int ret;
2641
2642 if (rbd_dev->spec->pool_name)
2643 return 0; /* Already have the names */
2644
2645 /* Look up the pool name */
2646
2647 osdc = &rbd_dev->rbd_client->client->osdc;
2648 name = ceph_pg_pool_name_by_id(osdc->osdmap, rbd_dev->spec->pool_id);
Alex Elder935dc892012-11-01 10:17:15 -05002649 if (!name) {
2650 rbd_warn(rbd_dev, "there is no pool with id %llu",
2651 rbd_dev->spec->pool_id); /* Really a BUG() */
2652 return -EIO;
2653 }
Alex Elder9e15b772012-10-30 19:40:33 -05002654
2655 rbd_dev->spec->pool_name = kstrdup(name, GFP_KERNEL);
2656 if (!rbd_dev->spec->pool_name)
2657 return -ENOMEM;
2658
2659 /* Fetch the image name; tolerate failure here */
2660
2661 name = rbd_dev_image_name(rbd_dev);
Alex Elder69e7a022012-11-01 08:39:26 -05002662 if (name)
Alex Elder9e15b772012-10-30 19:40:33 -05002663 rbd_dev->spec->image_name = (char *) name;
Alex Elder69e7a022012-11-01 08:39:26 -05002664 else
Alex Elder06ecc6c2012-11-01 10:17:15 -05002665 rbd_warn(rbd_dev, "unable to get image name");
Alex Elder9e15b772012-10-30 19:40:33 -05002666
2667 /* Look up the snapshot name. */
2668
2669 name = rbd_snap_name(rbd_dev, rbd_dev->spec->snap_id);
2670 if (!name) {
Alex Elder935dc892012-11-01 10:17:15 -05002671 rbd_warn(rbd_dev, "no snapshot with id %llu",
2672 rbd_dev->spec->snap_id); /* Really a BUG() */
Alex Elder9e15b772012-10-30 19:40:33 -05002673 ret = -EIO;
2674 goto out_err;
2675 }
2676 rbd_dev->spec->snap_name = kstrdup(name, GFP_KERNEL);
2677 if(!rbd_dev->spec->snap_name)
2678 goto out_err;
2679
2680 return 0;
2681out_err:
2682 kfree(reply_buf);
2683 kfree(rbd_dev->spec->pool_name);
2684 rbd_dev->spec->pool_name = NULL;
2685
2686 return ret;
2687}
2688
Alex Elder6e14b1a2012-07-03 16:01:19 -05002689static int rbd_dev_v2_snap_context(struct rbd_device *rbd_dev, u64 *ver)
Alex Elder35d489f2012-07-03 16:01:19 -05002690{
2691 size_t size;
2692 int ret;
2693 void *reply_buf;
2694 void *p;
2695 void *end;
2696 u64 seq;
2697 u32 snap_count;
2698 struct ceph_snap_context *snapc;
2699 u32 i;
2700
2701 /*
2702 * We'll need room for the seq value (maximum snapshot id),
2703 * snapshot count, and array of that many snapshot ids.
2704 * For now we have a fixed upper limit on the number we're
2705 * prepared to receive.
2706 */
2707 size = sizeof (__le64) + sizeof (__le32) +
2708 RBD_MAX_SNAP_COUNT * sizeof (__le64);
2709 reply_buf = kzalloc(size, GFP_KERNEL);
2710 if (!reply_buf)
2711 return -ENOMEM;
2712
2713 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2714 "rbd", "get_snapcontext",
2715 NULL, 0,
2716 reply_buf, size,
Alex Elder6e14b1a2012-07-03 16:01:19 -05002717 CEPH_OSD_FLAG_READ, ver);
Alex Elder35d489f2012-07-03 16:01:19 -05002718 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2719 if (ret < 0)
2720 goto out;
2721
2722 ret = -ERANGE;
2723 p = reply_buf;
2724 end = (char *) reply_buf + size;
2725 ceph_decode_64_safe(&p, end, seq, out);
2726 ceph_decode_32_safe(&p, end, snap_count, out);
2727
2728 /*
2729 * Make sure the reported number of snapshot ids wouldn't go
2730 * beyond the end of our buffer. But before checking that,
2731 * make sure the computed size of the snapshot context we
2732 * allocate is representable in a size_t.
2733 */
2734 if (snap_count > (SIZE_MAX - sizeof (struct ceph_snap_context))
2735 / sizeof (u64)) {
2736 ret = -EINVAL;
2737 goto out;
2738 }
2739 if (!ceph_has_room(&p, end, snap_count * sizeof (__le64)))
2740 goto out;
2741
2742 size = sizeof (struct ceph_snap_context) +
2743 snap_count * sizeof (snapc->snaps[0]);
2744 snapc = kmalloc(size, GFP_KERNEL);
2745 if (!snapc) {
2746 ret = -ENOMEM;
2747 goto out;
2748 }
2749
2750 atomic_set(&snapc->nref, 1);
2751 snapc->seq = seq;
2752 snapc->num_snaps = snap_count;
2753 for (i = 0; i < snap_count; i++)
2754 snapc->snaps[i] = ceph_decode_64(&p);
2755
2756 rbd_dev->header.snapc = snapc;
2757
2758 dout(" snap context seq = %llu, snap_count = %u\n",
2759 (unsigned long long) seq, (unsigned int) snap_count);
2760
2761out:
2762 kfree(reply_buf);
2763
2764 return 0;
2765}
2766
Alex Elderb8b1e2d2012-07-03 16:01:19 -05002767static char *rbd_dev_v2_snap_name(struct rbd_device *rbd_dev, u32 which)
2768{
2769 size_t size;
2770 void *reply_buf;
2771 __le64 snap_id;
2772 int ret;
2773 void *p;
2774 void *end;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05002775 char *snap_name;
2776
2777 size = sizeof (__le32) + RBD_MAX_SNAP_NAME_LEN;
2778 reply_buf = kmalloc(size, GFP_KERNEL);
2779 if (!reply_buf)
2780 return ERR_PTR(-ENOMEM);
2781
2782 snap_id = cpu_to_le64(rbd_dev->header.snapc->snaps[which]);
2783 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2784 "rbd", "get_snapshot_name",
2785 (char *) &snap_id, sizeof (snap_id),
2786 reply_buf, size,
2787 CEPH_OSD_FLAG_READ, NULL);
2788 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2789 if (ret < 0)
2790 goto out;
2791
2792 p = reply_buf;
2793 end = (char *) reply_buf + size;
Alex Eldere5c35532012-10-25 23:34:41 -05002794 snap_name = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05002795 if (IS_ERR(snap_name)) {
2796 ret = PTR_ERR(snap_name);
2797 goto out;
2798 } else {
2799 dout(" snap_id 0x%016llx snap_name = %s\n",
2800 (unsigned long long) le64_to_cpu(snap_id), snap_name);
2801 }
2802 kfree(reply_buf);
2803
2804 return snap_name;
2805out:
2806 kfree(reply_buf);
2807
2808 return ERR_PTR(ret);
2809}
2810
2811static char *rbd_dev_v2_snap_info(struct rbd_device *rbd_dev, u32 which,
2812 u64 *snap_size, u64 *snap_features)
2813{
2814 __le64 snap_id;
2815 u8 order;
2816 int ret;
2817
2818 snap_id = rbd_dev->header.snapc->snaps[which];
2819 ret = _rbd_dev_v2_snap_size(rbd_dev, snap_id, &order, snap_size);
2820 if (ret)
2821 return ERR_PTR(ret);
2822 ret = _rbd_dev_v2_snap_features(rbd_dev, snap_id, snap_features);
2823 if (ret)
2824 return ERR_PTR(ret);
2825
2826 return rbd_dev_v2_snap_name(rbd_dev, which);
2827}
2828
2829static char *rbd_dev_snap_info(struct rbd_device *rbd_dev, u32 which,
2830 u64 *snap_size, u64 *snap_features)
2831{
2832 if (rbd_dev->image_format == 1)
2833 return rbd_dev_v1_snap_info(rbd_dev, which,
2834 snap_size, snap_features);
2835 if (rbd_dev->image_format == 2)
2836 return rbd_dev_v2_snap_info(rbd_dev, which,
2837 snap_size, snap_features);
2838 return ERR_PTR(-EINVAL);
2839}
2840
Alex Elder117973f2012-08-31 17:29:55 -05002841static int rbd_dev_v2_refresh(struct rbd_device *rbd_dev, u64 *hver)
2842{
2843 int ret;
2844 __u8 obj_order;
2845
2846 down_write(&rbd_dev->header_rwsem);
2847
2848 /* Grab old order first, to see if it changes */
2849
2850 obj_order = rbd_dev->header.obj_order,
2851 ret = rbd_dev_v2_image_size(rbd_dev);
2852 if (ret)
2853 goto out;
2854 if (rbd_dev->header.obj_order != obj_order) {
2855 ret = -EIO;
2856 goto out;
2857 }
2858 rbd_update_mapping_size(rbd_dev);
2859
2860 ret = rbd_dev_v2_snap_context(rbd_dev, hver);
2861 dout("rbd_dev_v2_snap_context returned %d\n", ret);
2862 if (ret)
2863 goto out;
2864 ret = rbd_dev_snaps_update(rbd_dev);
2865 dout("rbd_dev_snaps_update returned %d\n", ret);
2866 if (ret)
2867 goto out;
2868 ret = rbd_dev_snaps_register(rbd_dev);
2869 dout("rbd_dev_snaps_register returned %d\n", ret);
2870out:
2871 up_write(&rbd_dev->header_rwsem);
2872
2873 return ret;
2874}
2875
Alex Elder9d475de2012-07-03 16:01:19 -05002876/*
Alex Elder35938152012-08-02 11:29:46 -05002877 * Scan the rbd device's current snapshot list and compare it to the
2878 * newly-received snapshot context. Remove any existing snapshots
2879 * not present in the new snapshot context. Add a new snapshot for
2880 * any snaphots in the snapshot context not in the current list.
2881 * And verify there are no changes to snapshots we already know
2882 * about.
2883 *
2884 * Assumes the snapshots in the snapshot context are sorted by
2885 * snapshot id, highest id first. (Snapshots in the rbd_dev's list
2886 * are also maintained in that order.)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002887 */
Alex Elder304f6802012-08-31 17:29:52 -05002888static int rbd_dev_snaps_update(struct rbd_device *rbd_dev)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002889{
Alex Elder35938152012-08-02 11:29:46 -05002890 struct ceph_snap_context *snapc = rbd_dev->header.snapc;
2891 const u32 snap_count = snapc->num_snaps;
Alex Elder35938152012-08-02 11:29:46 -05002892 struct list_head *head = &rbd_dev->snaps;
2893 struct list_head *links = head->next;
2894 u32 index = 0;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002895
Alex Elder9fcbb802012-08-23 23:48:49 -05002896 dout("%s: snap count is %u\n", __func__, (unsigned int) snap_count);
Alex Elder35938152012-08-02 11:29:46 -05002897 while (index < snap_count || links != head) {
2898 u64 snap_id;
2899 struct rbd_snap *snap;
Alex Eldercd892122012-07-03 16:01:19 -05002900 char *snap_name;
2901 u64 snap_size = 0;
2902 u64 snap_features = 0;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002903
Alex Elder35938152012-08-02 11:29:46 -05002904 snap_id = index < snap_count ? snapc->snaps[index]
2905 : CEPH_NOSNAP;
2906 snap = links != head ? list_entry(links, struct rbd_snap, node)
2907 : NULL;
Alex Elderaafb2302012-09-06 16:00:54 -05002908 rbd_assert(!snap || snap->id != CEPH_NOSNAP);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002909
Alex Elder35938152012-08-02 11:29:46 -05002910 if (snap_id == CEPH_NOSNAP || (snap && snap->id > snap_id)) {
2911 struct list_head *next = links->next;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002912
Alex Elder35938152012-08-02 11:29:46 -05002913 /* Existing snapshot not in the new snap context */
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002914
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002915 if (rbd_dev->spec->snap_id == snap->id)
Alex Elderdaba5fd2012-10-26 17:25:23 -05002916 rbd_dev->exists = false;
Alex Elder41f38c22012-10-25 23:34:40 -05002917 rbd_remove_snap_dev(snap);
Alex Elder9fcbb802012-08-23 23:48:49 -05002918 dout("%ssnap id %llu has been removed\n",
Alex Elder0d7dbfc2012-10-25 23:34:41 -05002919 rbd_dev->spec->snap_id == snap->id ?
2920 "mapped " : "",
Alex Elder9fcbb802012-08-23 23:48:49 -05002921 (unsigned long long) snap->id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002922
Alex Elder35938152012-08-02 11:29:46 -05002923 /* Done with this list entry; advance */
2924
2925 links = next;
2926 continue;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002927 }
Alex Elder35938152012-08-02 11:29:46 -05002928
Alex Elderb8b1e2d2012-07-03 16:01:19 -05002929 snap_name = rbd_dev_snap_info(rbd_dev, index,
2930 &snap_size, &snap_features);
Alex Eldercd892122012-07-03 16:01:19 -05002931 if (IS_ERR(snap_name))
2932 return PTR_ERR(snap_name);
2933
Alex Elder9fcbb802012-08-23 23:48:49 -05002934 dout("entry %u: snap_id = %llu\n", (unsigned int) snap_count,
2935 (unsigned long long) snap_id);
Alex Elder35938152012-08-02 11:29:46 -05002936 if (!snap || (snap_id != CEPH_NOSNAP && snap->id < snap_id)) {
2937 struct rbd_snap *new_snap;
2938
2939 /* We haven't seen this snapshot before */
2940
Alex Elderc8d18422012-07-10 20:30:11 -05002941 new_snap = __rbd_add_snap_dev(rbd_dev, snap_name,
Alex Eldercd892122012-07-03 16:01:19 -05002942 snap_id, snap_size, snap_features);
Alex Elder9fcbb802012-08-23 23:48:49 -05002943 if (IS_ERR(new_snap)) {
2944 int err = PTR_ERR(new_snap);
2945
2946 dout(" failed to add dev, error %d\n", err);
2947
2948 return err;
2949 }
Alex Elder35938152012-08-02 11:29:46 -05002950
2951 /* New goes before existing, or at end of list */
2952
Alex Elder9fcbb802012-08-23 23:48:49 -05002953 dout(" added dev%s\n", snap ? "" : " at end\n");
Alex Elder35938152012-08-02 11:29:46 -05002954 if (snap)
2955 list_add_tail(&new_snap->node, &snap->node);
2956 else
Alex Elder523f3252012-08-30 00:16:37 -05002957 list_add_tail(&new_snap->node, head);
Alex Elder35938152012-08-02 11:29:46 -05002958 } else {
2959 /* Already have this one */
2960
Alex Elder9fcbb802012-08-23 23:48:49 -05002961 dout(" already present\n");
2962
Alex Eldercd892122012-07-03 16:01:19 -05002963 rbd_assert(snap->size == snap_size);
Alex Elderaafb2302012-09-06 16:00:54 -05002964 rbd_assert(!strcmp(snap->name, snap_name));
Alex Eldercd892122012-07-03 16:01:19 -05002965 rbd_assert(snap->features == snap_features);
Alex Elder35938152012-08-02 11:29:46 -05002966
2967 /* Done with this list entry; advance */
2968
2969 links = links->next;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002970 }
Alex Elder35938152012-08-02 11:29:46 -05002971
2972 /* Advance to the next entry in the snapshot context */
2973
2974 index++;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002975 }
Alex Elder9fcbb802012-08-23 23:48:49 -05002976 dout("%s: done\n", __func__);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002977
2978 return 0;
2979}
2980
Alex Elder304f6802012-08-31 17:29:52 -05002981/*
2982 * Scan the list of snapshots and register the devices for any that
2983 * have not already been registered.
2984 */
2985static int rbd_dev_snaps_register(struct rbd_device *rbd_dev)
2986{
2987 struct rbd_snap *snap;
2988 int ret = 0;
2989
2990 dout("%s called\n", __func__);
Alex Elder86ff77b2012-08-31 17:29:53 -05002991 if (WARN_ON(!device_is_registered(&rbd_dev->dev)))
2992 return -EIO;
Alex Elder304f6802012-08-31 17:29:52 -05002993
2994 list_for_each_entry(snap, &rbd_dev->snaps, node) {
2995 if (!rbd_snap_registered(snap)) {
2996 ret = rbd_register_snap_dev(snap, &rbd_dev->dev);
2997 if (ret < 0)
2998 break;
2999 }
3000 }
3001 dout("%s: returning %d\n", __func__, ret);
3002
3003 return ret;
3004}
3005
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003006static int rbd_bus_add_dev(struct rbd_device *rbd_dev)
3007{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003008 struct device *dev;
Alex Eldercd789ab2012-08-30 00:16:38 -05003009 int ret;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003010
3011 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003012
Alex Eldercd789ab2012-08-30 00:16:38 -05003013 dev = &rbd_dev->dev;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003014 dev->bus = &rbd_bus_type;
3015 dev->type = &rbd_device_type;
3016 dev->parent = &rbd_root_dev;
3017 dev->release = rbd_dev_release;
Alex Elderde71a292012-07-03 16:01:19 -05003018 dev_set_name(dev, "%d", rbd_dev->dev_id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003019 ret = device_register(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003020
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003021 mutex_unlock(&ctl_mutex);
Alex Eldercd789ab2012-08-30 00:16:38 -05003022
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003023 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003024}
3025
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003026static void rbd_bus_del_dev(struct rbd_device *rbd_dev)
3027{
3028 device_unregister(&rbd_dev->dev);
3029}
3030
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003031static int rbd_init_watch_dev(struct rbd_device *rbd_dev)
3032{
3033 int ret, rc;
3034
3035 do {
Alex Elder0e6f3222012-07-25 09:32:40 -05003036 ret = rbd_req_sync_watch(rbd_dev);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003037 if (ret == -ERANGE) {
Alex Elder117973f2012-08-31 17:29:55 -05003038 rc = rbd_dev_refresh(rbd_dev, NULL);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003039 if (rc < 0)
3040 return rc;
3041 }
3042 } while (ret == -ERANGE);
3043
3044 return ret;
3045}
3046
Alex Eldere2839302012-08-29 17:11:06 -05003047static atomic64_t rbd_dev_id_max = ATOMIC64_INIT(0);
Alex Elder1ddbe942012-01-29 13:57:44 -06003048
3049/*
Alex Elder499afd52012-02-02 08:13:29 -06003050 * Get a unique rbd identifier for the given new rbd_dev, and add
3051 * the rbd_dev to the global list. The minimum rbd id is 1.
Alex Elder1ddbe942012-01-29 13:57:44 -06003052 */
Alex Eldere2839302012-08-29 17:11:06 -05003053static void rbd_dev_id_get(struct rbd_device *rbd_dev)
Alex Elderb7f23c32012-01-29 13:57:43 -06003054{
Alex Eldere2839302012-08-29 17:11:06 -05003055 rbd_dev->dev_id = atomic64_inc_return(&rbd_dev_id_max);
Alex Elder499afd52012-02-02 08:13:29 -06003056
3057 spin_lock(&rbd_dev_list_lock);
3058 list_add_tail(&rbd_dev->node, &rbd_dev_list);
3059 spin_unlock(&rbd_dev_list_lock);
Alex Eldere2839302012-08-29 17:11:06 -05003060 dout("rbd_dev %p given dev id %llu\n", rbd_dev,
3061 (unsigned long long) rbd_dev->dev_id);
Alex Elder1ddbe942012-01-29 13:57:44 -06003062}
Alex Elderb7f23c32012-01-29 13:57:43 -06003063
Alex Elder1ddbe942012-01-29 13:57:44 -06003064/*
Alex Elder499afd52012-02-02 08:13:29 -06003065 * Remove an rbd_dev from the global list, and record that its
3066 * identifier is no longer in use.
Alex Elder1ddbe942012-01-29 13:57:44 -06003067 */
Alex Eldere2839302012-08-29 17:11:06 -05003068static void rbd_dev_id_put(struct rbd_device *rbd_dev)
Alex Elder1ddbe942012-01-29 13:57:44 -06003069{
Alex Elderd184f6b2012-01-29 13:57:44 -06003070 struct list_head *tmp;
Alex Elderde71a292012-07-03 16:01:19 -05003071 int rbd_id = rbd_dev->dev_id;
Alex Elderd184f6b2012-01-29 13:57:44 -06003072 int max_id;
3073
Alex Elderaafb2302012-09-06 16:00:54 -05003074 rbd_assert(rbd_id > 0);
Alex Elder499afd52012-02-02 08:13:29 -06003075
Alex Eldere2839302012-08-29 17:11:06 -05003076 dout("rbd_dev %p released dev id %llu\n", rbd_dev,
3077 (unsigned long long) rbd_dev->dev_id);
Alex Elder499afd52012-02-02 08:13:29 -06003078 spin_lock(&rbd_dev_list_lock);
3079 list_del_init(&rbd_dev->node);
Alex Elderd184f6b2012-01-29 13:57:44 -06003080
3081 /*
3082 * If the id being "put" is not the current maximum, there
3083 * is nothing special we need to do.
3084 */
Alex Eldere2839302012-08-29 17:11:06 -05003085 if (rbd_id != atomic64_read(&rbd_dev_id_max)) {
Alex Elderd184f6b2012-01-29 13:57:44 -06003086 spin_unlock(&rbd_dev_list_lock);
3087 return;
3088 }
3089
3090 /*
3091 * We need to update the current maximum id. Search the
3092 * list to find out what it is. We're more likely to find
3093 * the maximum at the end, so search the list backward.
3094 */
3095 max_id = 0;
3096 list_for_each_prev(tmp, &rbd_dev_list) {
3097 struct rbd_device *rbd_dev;
3098
3099 rbd_dev = list_entry(tmp, struct rbd_device, node);
Alex Elderb213e0b2012-10-10 21:19:13 -07003100 if (rbd_dev->dev_id > max_id)
3101 max_id = rbd_dev->dev_id;
Alex Elderd184f6b2012-01-29 13:57:44 -06003102 }
Alex Elder499afd52012-02-02 08:13:29 -06003103 spin_unlock(&rbd_dev_list_lock);
Alex Elderb7f23c32012-01-29 13:57:43 -06003104
Alex Elder1ddbe942012-01-29 13:57:44 -06003105 /*
Alex Eldere2839302012-08-29 17:11:06 -05003106 * The max id could have been updated by rbd_dev_id_get(), in
Alex Elderd184f6b2012-01-29 13:57:44 -06003107 * which case it now accurately reflects the new maximum.
3108 * Be careful not to overwrite the maximum value in that
3109 * case.
Alex Elder1ddbe942012-01-29 13:57:44 -06003110 */
Alex Eldere2839302012-08-29 17:11:06 -05003111 atomic64_cmpxchg(&rbd_dev_id_max, rbd_id, max_id);
3112 dout(" max dev id has been reset\n");
Alex Elderb7f23c32012-01-29 13:57:43 -06003113}
3114
Alex Eldera725f65e2012-02-02 08:13:30 -06003115/*
Alex Eldere28fff262012-02-02 08:13:30 -06003116 * Skips over white space at *buf, and updates *buf to point to the
3117 * first found non-space character (if any). Returns the length of
Alex Elder593a9e72012-02-07 12:03:37 -06003118 * the token (string of non-white space characters) found. Note
3119 * that *buf must be terminated with '\0'.
Alex Eldere28fff262012-02-02 08:13:30 -06003120 */
3121static inline size_t next_token(const char **buf)
3122{
3123 /*
3124 * These are the characters that produce nonzero for
3125 * isspace() in the "C" and "POSIX" locales.
3126 */
3127 const char *spaces = " \f\n\r\t\v";
3128
3129 *buf += strspn(*buf, spaces); /* Find start of token */
3130
3131 return strcspn(*buf, spaces); /* Return token length */
3132}
3133
3134/*
3135 * Finds the next token in *buf, and if the provided token buffer is
3136 * big enough, copies the found token into it. The result, if
Alex Elder593a9e72012-02-07 12:03:37 -06003137 * copied, is guaranteed to be terminated with '\0'. Note that *buf
3138 * must be terminated with '\0' on entry.
Alex Eldere28fff262012-02-02 08:13:30 -06003139 *
3140 * Returns the length of the token found (not including the '\0').
3141 * Return value will be 0 if no token is found, and it will be >=
3142 * token_size if the token would not fit.
3143 *
Alex Elder593a9e72012-02-07 12:03:37 -06003144 * The *buf pointer will be updated to point beyond the end of the
Alex Eldere28fff262012-02-02 08:13:30 -06003145 * found token. Note that this occurs even if the token buffer is
3146 * too small to hold it.
3147 */
3148static inline size_t copy_token(const char **buf,
3149 char *token,
3150 size_t token_size)
3151{
3152 size_t len;
3153
3154 len = next_token(buf);
3155 if (len < token_size) {
3156 memcpy(token, *buf, len);
3157 *(token + len) = '\0';
3158 }
3159 *buf += len;
3160
3161 return len;
3162}
3163
3164/*
Alex Elderea3352f2012-07-09 21:04:23 -05003165 * Finds the next token in *buf, dynamically allocates a buffer big
3166 * enough to hold a copy of it, and copies the token into the new
3167 * buffer. The copy is guaranteed to be terminated with '\0'. Note
3168 * that a duplicate buffer is created even for a zero-length token.
3169 *
3170 * Returns a pointer to the newly-allocated duplicate, or a null
3171 * pointer if memory for the duplicate was not available. If
3172 * the lenp argument is a non-null pointer, the length of the token
3173 * (not including the '\0') is returned in *lenp.
3174 *
3175 * If successful, the *buf pointer will be updated to point beyond
3176 * the end of the found token.
3177 *
3178 * Note: uses GFP_KERNEL for allocation.
3179 */
3180static inline char *dup_token(const char **buf, size_t *lenp)
3181{
3182 char *dup;
3183 size_t len;
3184
3185 len = next_token(buf);
Alex Elder4caf35f2012-11-01 08:39:27 -05003186 dup = kmemdup(*buf, len + 1, GFP_KERNEL);
Alex Elderea3352f2012-07-09 21:04:23 -05003187 if (!dup)
3188 return NULL;
Alex Elderea3352f2012-07-09 21:04:23 -05003189 *(dup + len) = '\0';
3190 *buf += len;
3191
3192 if (lenp)
3193 *lenp = len;
3194
3195 return dup;
3196}
3197
3198/*
Alex Elder859c31d2012-10-25 23:34:42 -05003199 * Parse the options provided for an "rbd add" (i.e., rbd image
3200 * mapping) request. These arrive via a write to /sys/bus/rbd/add,
3201 * and the data written is passed here via a NUL-terminated buffer.
3202 * Returns 0 if successful or an error code otherwise.
Alex Elderd22f76e2012-07-12 10:46:35 -05003203 *
Alex Elder859c31d2012-10-25 23:34:42 -05003204 * The information extracted from these options is recorded in
3205 * the other parameters which return dynamically-allocated
3206 * structures:
3207 * ceph_opts
3208 * The address of a pointer that will refer to a ceph options
3209 * structure. Caller must release the returned pointer using
3210 * ceph_destroy_options() when it is no longer needed.
3211 * rbd_opts
3212 * Address of an rbd options pointer. Fully initialized by
3213 * this function; caller must release with kfree().
3214 * spec
3215 * Address of an rbd image specification pointer. Fully
3216 * initialized by this function based on parsed options.
3217 * Caller must release with rbd_spec_put().
3218 *
3219 * The options passed take this form:
3220 * <mon_addrs> <options> <pool_name> <image_name> [<snap_id>]
3221 * where:
3222 * <mon_addrs>
3223 * A comma-separated list of one or more monitor addresses.
3224 * A monitor address is an ip address, optionally followed
3225 * by a port number (separated by a colon).
3226 * I.e.: ip1[:port1][,ip2[:port2]...]
3227 * <options>
3228 * A comma-separated list of ceph and/or rbd options.
3229 * <pool_name>
3230 * The name of the rados pool containing the rbd image.
3231 * <image_name>
3232 * The name of the image in that pool to map.
3233 * <snap_id>
3234 * An optional snapshot id. If provided, the mapping will
3235 * present data from the image at the time that snapshot was
3236 * created. The image head is used if no snapshot id is
3237 * provided. Snapshot mappings are always read-only.
Alex Eldera725f65e2012-02-02 08:13:30 -06003238 */
Alex Elder859c31d2012-10-25 23:34:42 -05003239static int rbd_add_parse_args(const char *buf,
Alex Elderdc79b112012-10-25 23:34:41 -05003240 struct ceph_options **ceph_opts,
Alex Elder859c31d2012-10-25 23:34:42 -05003241 struct rbd_options **opts,
3242 struct rbd_spec **rbd_spec)
Alex Eldera725f65e2012-02-02 08:13:30 -06003243{
Alex Elderd22f76e2012-07-12 10:46:35 -05003244 size_t len;
Alex Elder859c31d2012-10-25 23:34:42 -05003245 char *options;
Alex Elder0ddebc02012-10-25 23:34:41 -05003246 const char *mon_addrs;
3247 size_t mon_addrs_size;
Alex Elder859c31d2012-10-25 23:34:42 -05003248 struct rbd_spec *spec = NULL;
Alex Elder4e9afeb2012-10-25 23:34:41 -05003249 struct rbd_options *rbd_opts = NULL;
Alex Elder859c31d2012-10-25 23:34:42 -05003250 struct ceph_options *copts;
Alex Elderdc79b112012-10-25 23:34:41 -05003251 int ret;
Alex Eldere28fff262012-02-02 08:13:30 -06003252
3253 /* The first four tokens are required */
3254
Alex Elder7ef32142012-02-02 08:13:30 -06003255 len = next_token(&buf);
Alex Elder4fb5d672012-11-01 10:17:15 -05003256 if (!len) {
3257 rbd_warn(NULL, "no monitor address(es) provided");
3258 return -EINVAL;
3259 }
Alex Elder0ddebc02012-10-25 23:34:41 -05003260 mon_addrs = buf;
Alex Elderf28e5652012-10-25 23:34:41 -05003261 mon_addrs_size = len + 1;
Alex Elder7ef32142012-02-02 08:13:30 -06003262 buf += len;
Alex Eldera725f65e2012-02-02 08:13:30 -06003263
Alex Elderdc79b112012-10-25 23:34:41 -05003264 ret = -EINVAL;
Alex Elderf28e5652012-10-25 23:34:41 -05003265 options = dup_token(&buf, NULL);
3266 if (!options)
Alex Elderdc79b112012-10-25 23:34:41 -05003267 return -ENOMEM;
Alex Elder4fb5d672012-11-01 10:17:15 -05003268 if (!*options) {
3269 rbd_warn(NULL, "no options provided");
3270 goto out_err;
3271 }
Alex Eldera725f65e2012-02-02 08:13:30 -06003272
Alex Elder859c31d2012-10-25 23:34:42 -05003273 spec = rbd_spec_alloc();
3274 if (!spec)
Alex Elderf28e5652012-10-25 23:34:41 -05003275 goto out_mem;
Alex Elder859c31d2012-10-25 23:34:42 -05003276
3277 spec->pool_name = dup_token(&buf, NULL);
3278 if (!spec->pool_name)
3279 goto out_mem;
Alex Elder4fb5d672012-11-01 10:17:15 -05003280 if (!*spec->pool_name) {
3281 rbd_warn(NULL, "no pool name provided");
3282 goto out_err;
3283 }
Alex Eldere28fff262012-02-02 08:13:30 -06003284
Alex Elder69e7a022012-11-01 08:39:26 -05003285 spec->image_name = dup_token(&buf, NULL);
Alex Elder859c31d2012-10-25 23:34:42 -05003286 if (!spec->image_name)
Alex Elderf28e5652012-10-25 23:34:41 -05003287 goto out_mem;
Alex Elder4fb5d672012-11-01 10:17:15 -05003288 if (!*spec->image_name) {
3289 rbd_warn(NULL, "no image name provided");
3290 goto out_err;
3291 }
Alex Eldere28fff262012-02-02 08:13:30 -06003292
Alex Elderf28e5652012-10-25 23:34:41 -05003293 /*
3294 * Snapshot name is optional; default is to use "-"
3295 * (indicating the head/no snapshot).
3296 */
Alex Elder3feeb8942012-08-31 17:29:52 -05003297 len = next_token(&buf);
Alex Elder820a5f32012-07-09 21:04:24 -05003298 if (!len) {
Alex Elder3feeb8942012-08-31 17:29:52 -05003299 buf = RBD_SNAP_HEAD_NAME; /* No snapshot supplied */
3300 len = sizeof (RBD_SNAP_HEAD_NAME) - 1;
Alex Elderf28e5652012-10-25 23:34:41 -05003301 } else if (len > RBD_MAX_SNAP_NAME_LEN) {
Alex Elderdc79b112012-10-25 23:34:41 -05003302 ret = -ENAMETOOLONG;
Alex Elderf28e5652012-10-25 23:34:41 -05003303 goto out_err;
Alex Elder849b4262012-07-09 21:04:24 -05003304 }
Alex Elder4caf35f2012-11-01 08:39:27 -05003305 spec->snap_name = kmemdup(buf, len + 1, GFP_KERNEL);
Alex Elder859c31d2012-10-25 23:34:42 -05003306 if (!spec->snap_name)
Alex Elderf28e5652012-10-25 23:34:41 -05003307 goto out_mem;
Alex Elder859c31d2012-10-25 23:34:42 -05003308 *(spec->snap_name + len) = '\0';
Alex Eldere5c35532012-10-25 23:34:41 -05003309
Alex Elder0ddebc02012-10-25 23:34:41 -05003310 /* Initialize all rbd options to the defaults */
Alex Eldere28fff262012-02-02 08:13:30 -06003311
Alex Elder4e9afeb2012-10-25 23:34:41 -05003312 rbd_opts = kzalloc(sizeof (*rbd_opts), GFP_KERNEL);
3313 if (!rbd_opts)
3314 goto out_mem;
3315
3316 rbd_opts->read_only = RBD_READ_ONLY_DEFAULT;
Alex Elderd22f76e2012-07-12 10:46:35 -05003317
Alex Elder859c31d2012-10-25 23:34:42 -05003318 copts = ceph_parse_options(options, mon_addrs,
Alex Elder0ddebc02012-10-25 23:34:41 -05003319 mon_addrs + mon_addrs_size - 1,
Alex Elder4e9afeb2012-10-25 23:34:41 -05003320 parse_rbd_opts_token, rbd_opts);
Alex Elder859c31d2012-10-25 23:34:42 -05003321 if (IS_ERR(copts)) {
3322 ret = PTR_ERR(copts);
Alex Elderdc79b112012-10-25 23:34:41 -05003323 goto out_err;
3324 }
Alex Elder859c31d2012-10-25 23:34:42 -05003325 kfree(options);
3326
3327 *ceph_opts = copts;
Alex Elder4e9afeb2012-10-25 23:34:41 -05003328 *opts = rbd_opts;
Alex Elder859c31d2012-10-25 23:34:42 -05003329 *rbd_spec = spec;
Alex Elder0ddebc02012-10-25 23:34:41 -05003330
Alex Elderdc79b112012-10-25 23:34:41 -05003331 return 0;
Alex Elderf28e5652012-10-25 23:34:41 -05003332out_mem:
Alex Elderdc79b112012-10-25 23:34:41 -05003333 ret = -ENOMEM;
Alex Elderd22f76e2012-07-12 10:46:35 -05003334out_err:
Alex Elder859c31d2012-10-25 23:34:42 -05003335 kfree(rbd_opts);
3336 rbd_spec_put(spec);
Alex Elderf28e5652012-10-25 23:34:41 -05003337 kfree(options);
Alex Elderd22f76e2012-07-12 10:46:35 -05003338
Alex Elderdc79b112012-10-25 23:34:41 -05003339 return ret;
Alex Eldera725f65e2012-02-02 08:13:30 -06003340}
3341
Alex Elder589d30e2012-07-10 20:30:11 -05003342/*
3343 * An rbd format 2 image has a unique identifier, distinct from the
3344 * name given to it by the user. Internally, that identifier is
3345 * what's used to specify the names of objects related to the image.
3346 *
3347 * A special "rbd id" object is used to map an rbd image name to its
3348 * id. If that object doesn't exist, then there is no v2 rbd image
3349 * with the supplied name.
3350 *
3351 * This function will record the given rbd_dev's image_id field if
3352 * it can be determined, and in that case will return 0. If any
3353 * errors occur a negative errno will be returned and the rbd_dev's
3354 * image_id field will be unchanged (and should be NULL).
3355 */
3356static int rbd_dev_image_id(struct rbd_device *rbd_dev)
3357{
3358 int ret;
3359 size_t size;
3360 char *object_name;
3361 void *response;
3362 void *p;
3363
3364 /*
Alex Elder2c0d0a12012-10-30 19:40:33 -05003365 * When probing a parent image, the image id is already
3366 * known (and the image name likely is not). There's no
3367 * need to fetch the image id again in this case.
3368 */
3369 if (rbd_dev->spec->image_id)
3370 return 0;
3371
3372 /*
Alex Elder589d30e2012-07-10 20:30:11 -05003373 * First, see if the format 2 image id file exists, and if
3374 * so, get the image's persistent id from it.
3375 */
Alex Elder69e7a022012-11-01 08:39:26 -05003376 size = sizeof (RBD_ID_PREFIX) + strlen(rbd_dev->spec->image_name);
Alex Elder589d30e2012-07-10 20:30:11 -05003377 object_name = kmalloc(size, GFP_NOIO);
3378 if (!object_name)
3379 return -ENOMEM;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003380 sprintf(object_name, "%s%s", RBD_ID_PREFIX, rbd_dev->spec->image_name);
Alex Elder589d30e2012-07-10 20:30:11 -05003381 dout("rbd id object name is %s\n", object_name);
3382
3383 /* Response will be an encoded string, which includes a length */
3384
3385 size = sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX;
3386 response = kzalloc(size, GFP_NOIO);
3387 if (!response) {
3388 ret = -ENOMEM;
3389 goto out;
3390 }
3391
3392 ret = rbd_req_sync_exec(rbd_dev, object_name,
3393 "rbd", "get_id",
3394 NULL, 0,
3395 response, RBD_IMAGE_ID_LEN_MAX,
3396 CEPH_OSD_FLAG_READ, NULL);
3397 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
3398 if (ret < 0)
3399 goto out;
Alex Eldera0ea3a42012-10-10 21:19:13 -07003400 ret = 0; /* rbd_req_sync_exec() can return positive */
Alex Elder589d30e2012-07-10 20:30:11 -05003401
3402 p = response;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003403 rbd_dev->spec->image_id = ceph_extract_encoded_string(&p,
Alex Elder589d30e2012-07-10 20:30:11 -05003404 p + RBD_IMAGE_ID_LEN_MAX,
Alex Elder979ed482012-11-01 08:39:26 -05003405 NULL, GFP_NOIO);
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003406 if (IS_ERR(rbd_dev->spec->image_id)) {
3407 ret = PTR_ERR(rbd_dev->spec->image_id);
3408 rbd_dev->spec->image_id = NULL;
Alex Elder589d30e2012-07-10 20:30:11 -05003409 } else {
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003410 dout("image_id is %s\n", rbd_dev->spec->image_id);
Alex Elder589d30e2012-07-10 20:30:11 -05003411 }
3412out:
3413 kfree(response);
3414 kfree(object_name);
3415
3416 return ret;
3417}
3418
Alex Eldera30b71b2012-07-10 20:30:11 -05003419static int rbd_dev_v1_probe(struct rbd_device *rbd_dev)
3420{
3421 int ret;
3422 size_t size;
3423
3424 /* Version 1 images have no id; empty string is used */
3425
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003426 rbd_dev->spec->image_id = kstrdup("", GFP_KERNEL);
3427 if (!rbd_dev->spec->image_id)
Alex Eldera30b71b2012-07-10 20:30:11 -05003428 return -ENOMEM;
Alex Eldera30b71b2012-07-10 20:30:11 -05003429
3430 /* Record the header object name for this rbd image. */
3431
Alex Elder69e7a022012-11-01 08:39:26 -05003432 size = strlen(rbd_dev->spec->image_name) + sizeof (RBD_SUFFIX);
Alex Eldera30b71b2012-07-10 20:30:11 -05003433 rbd_dev->header_name = kmalloc(size, GFP_KERNEL);
3434 if (!rbd_dev->header_name) {
3435 ret = -ENOMEM;
3436 goto out_err;
3437 }
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003438 sprintf(rbd_dev->header_name, "%s%s",
3439 rbd_dev->spec->image_name, RBD_SUFFIX);
Alex Eldera30b71b2012-07-10 20:30:11 -05003440
3441 /* Populate rbd image metadata */
3442
3443 ret = rbd_read_header(rbd_dev, &rbd_dev->header);
3444 if (ret < 0)
3445 goto out_err;
Alex Elder86b00e02012-10-25 23:34:42 -05003446
3447 /* Version 1 images have no parent (no layering) */
3448
3449 rbd_dev->parent_spec = NULL;
3450 rbd_dev->parent_overlap = 0;
3451
Alex Eldera30b71b2012-07-10 20:30:11 -05003452 rbd_dev->image_format = 1;
3453
3454 dout("discovered version 1 image, header name is %s\n",
3455 rbd_dev->header_name);
3456
3457 return 0;
3458
3459out_err:
3460 kfree(rbd_dev->header_name);
3461 rbd_dev->header_name = NULL;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003462 kfree(rbd_dev->spec->image_id);
3463 rbd_dev->spec->image_id = NULL;
Alex Eldera30b71b2012-07-10 20:30:11 -05003464
3465 return ret;
3466}
3467
3468static int rbd_dev_v2_probe(struct rbd_device *rbd_dev)
3469{
3470 size_t size;
Alex Elder9d475de2012-07-03 16:01:19 -05003471 int ret;
Alex Elder6e14b1a2012-07-03 16:01:19 -05003472 u64 ver = 0;
Alex Eldera30b71b2012-07-10 20:30:11 -05003473
3474 /*
3475 * Image id was filled in by the caller. Record the header
3476 * object name for this rbd image.
3477 */
Alex Elder979ed482012-11-01 08:39:26 -05003478 size = sizeof (RBD_HEADER_PREFIX) + strlen(rbd_dev->spec->image_id);
Alex Eldera30b71b2012-07-10 20:30:11 -05003479 rbd_dev->header_name = kmalloc(size, GFP_KERNEL);
3480 if (!rbd_dev->header_name)
3481 return -ENOMEM;
3482 sprintf(rbd_dev->header_name, "%s%s",
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003483 RBD_HEADER_PREFIX, rbd_dev->spec->image_id);
Alex Elder9d475de2012-07-03 16:01:19 -05003484
3485 /* Get the size and object order for the image */
3486
3487 ret = rbd_dev_v2_image_size(rbd_dev);
3488 if (ret < 0)
3489 goto out_err;
Alex Elder1e130192012-07-03 16:01:19 -05003490
3491 /* Get the object prefix (a.k.a. block_name) for the image */
3492
3493 ret = rbd_dev_v2_object_prefix(rbd_dev);
3494 if (ret < 0)
3495 goto out_err;
Alex Elderb1b54022012-07-03 16:01:19 -05003496
Alex Elderd8891402012-10-09 13:50:17 -07003497 /* Get the and check features for the image */
Alex Elderb1b54022012-07-03 16:01:19 -05003498
3499 ret = rbd_dev_v2_features(rbd_dev);
3500 if (ret < 0)
3501 goto out_err;
Alex Elder35d489f2012-07-03 16:01:19 -05003502
Alex Elder86b00e02012-10-25 23:34:42 -05003503 /* If the image supports layering, get the parent info */
3504
3505 if (rbd_dev->header.features & RBD_FEATURE_LAYERING) {
3506 ret = rbd_dev_v2_parent_info(rbd_dev);
3507 if (ret < 0)
3508 goto out_err;
3509 }
3510
Alex Elder6e14b1a2012-07-03 16:01:19 -05003511 /* crypto and compression type aren't (yet) supported for v2 images */
Alex Elder35d489f2012-07-03 16:01:19 -05003512
Alex Elder6e14b1a2012-07-03 16:01:19 -05003513 rbd_dev->header.crypt_type = 0;
3514 rbd_dev->header.comp_type = 0;
3515
3516 /* Get the snapshot context, plus the header version */
3517
3518 ret = rbd_dev_v2_snap_context(rbd_dev, &ver);
Alex Elder35d489f2012-07-03 16:01:19 -05003519 if (ret)
3520 goto out_err;
Alex Elder6e14b1a2012-07-03 16:01:19 -05003521 rbd_dev->header.obj_version = ver;
3522
Alex Eldera30b71b2012-07-10 20:30:11 -05003523 rbd_dev->image_format = 2;
3524
3525 dout("discovered version 2 image, header name is %s\n",
3526 rbd_dev->header_name);
3527
Alex Elder35152972012-08-31 17:29:55 -05003528 return 0;
Alex Elder9d475de2012-07-03 16:01:19 -05003529out_err:
Alex Elder86b00e02012-10-25 23:34:42 -05003530 rbd_dev->parent_overlap = 0;
3531 rbd_spec_put(rbd_dev->parent_spec);
3532 rbd_dev->parent_spec = NULL;
Alex Elder9d475de2012-07-03 16:01:19 -05003533 kfree(rbd_dev->header_name);
3534 rbd_dev->header_name = NULL;
Alex Elder1e130192012-07-03 16:01:19 -05003535 kfree(rbd_dev->header.object_prefix);
3536 rbd_dev->header.object_prefix = NULL;
Alex Elder9d475de2012-07-03 16:01:19 -05003537
3538 return ret;
Alex Eldera30b71b2012-07-10 20:30:11 -05003539}
3540
Alex Elder83a06262012-10-30 15:47:17 -05003541static int rbd_dev_probe_finish(struct rbd_device *rbd_dev)
3542{
3543 int ret;
3544
3545 /* no need to lock here, as rbd_dev is not registered yet */
3546 ret = rbd_dev_snaps_update(rbd_dev);
3547 if (ret)
3548 return ret;
3549
Alex Elder9e15b772012-10-30 19:40:33 -05003550 ret = rbd_dev_probe_update_spec(rbd_dev);
3551 if (ret)
3552 goto err_out_snaps;
3553
Alex Elder83a06262012-10-30 15:47:17 -05003554 ret = rbd_dev_set_mapping(rbd_dev);
3555 if (ret)
3556 goto err_out_snaps;
3557
3558 /* generate unique id: find highest unique id, add one */
3559 rbd_dev_id_get(rbd_dev);
3560
3561 /* Fill in the device name, now that we have its id. */
3562 BUILD_BUG_ON(DEV_NAME_LEN
3563 < sizeof (RBD_DRV_NAME) + MAX_INT_FORMAT_WIDTH);
3564 sprintf(rbd_dev->name, "%s%d", RBD_DRV_NAME, rbd_dev->dev_id);
3565
3566 /* Get our block major device number. */
3567
3568 ret = register_blkdev(0, rbd_dev->name);
3569 if (ret < 0)
3570 goto err_out_id;
3571 rbd_dev->major = ret;
3572
3573 /* Set up the blkdev mapping. */
3574
3575 ret = rbd_init_disk(rbd_dev);
3576 if (ret)
3577 goto err_out_blkdev;
3578
3579 ret = rbd_bus_add_dev(rbd_dev);
3580 if (ret)
3581 goto err_out_disk;
3582
3583 /*
3584 * At this point cleanup in the event of an error is the job
3585 * of the sysfs code (initiated by rbd_bus_del_dev()).
3586 */
3587 down_write(&rbd_dev->header_rwsem);
3588 ret = rbd_dev_snaps_register(rbd_dev);
3589 up_write(&rbd_dev->header_rwsem);
3590 if (ret)
3591 goto err_out_bus;
3592
3593 ret = rbd_init_watch_dev(rbd_dev);
3594 if (ret)
3595 goto err_out_bus;
3596
3597 /* Everything's ready. Announce the disk to the world. */
3598
3599 add_disk(rbd_dev->disk);
3600
3601 pr_info("%s: added with size 0x%llx\n", rbd_dev->disk->disk_name,
3602 (unsigned long long) rbd_dev->mapping.size);
3603
3604 return ret;
3605err_out_bus:
3606 /* this will also clean up rest of rbd_dev stuff */
3607
3608 rbd_bus_del_dev(rbd_dev);
3609
3610 return ret;
3611err_out_disk:
3612 rbd_free_disk(rbd_dev);
3613err_out_blkdev:
3614 unregister_blkdev(rbd_dev->major, rbd_dev->name);
3615err_out_id:
3616 rbd_dev_id_put(rbd_dev);
3617err_out_snaps:
3618 rbd_remove_all_snaps(rbd_dev);
3619
3620 return ret;
3621}
3622
Alex Eldera30b71b2012-07-10 20:30:11 -05003623/*
3624 * Probe for the existence of the header object for the given rbd
3625 * device. For format 2 images this includes determining the image
3626 * id.
3627 */
3628static int rbd_dev_probe(struct rbd_device *rbd_dev)
3629{
3630 int ret;
3631
3632 /*
3633 * Get the id from the image id object. If it's not a
3634 * format 2 image, we'll get ENOENT back, and we'll assume
3635 * it's a format 1 image.
3636 */
3637 ret = rbd_dev_image_id(rbd_dev);
3638 if (ret)
3639 ret = rbd_dev_v1_probe(rbd_dev);
3640 else
3641 ret = rbd_dev_v2_probe(rbd_dev);
Alex Elder83a06262012-10-30 15:47:17 -05003642 if (ret) {
Alex Eldera30b71b2012-07-10 20:30:11 -05003643 dout("probe failed, returning %d\n", ret);
3644
Alex Elder83a06262012-10-30 15:47:17 -05003645 return ret;
3646 }
3647
3648 ret = rbd_dev_probe_finish(rbd_dev);
3649 if (ret)
3650 rbd_header_free(&rbd_dev->header);
3651
Alex Eldera30b71b2012-07-10 20:30:11 -05003652 return ret;
3653}
3654
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003655static ssize_t rbd_add(struct bus_type *bus,
3656 const char *buf,
3657 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003658{
Alex Eldercb8627c2012-07-09 21:04:23 -05003659 struct rbd_device *rbd_dev = NULL;
Alex Elderdc79b112012-10-25 23:34:41 -05003660 struct ceph_options *ceph_opts = NULL;
Alex Elder4e9afeb2012-10-25 23:34:41 -05003661 struct rbd_options *rbd_opts = NULL;
Alex Elder859c31d2012-10-25 23:34:42 -05003662 struct rbd_spec *spec = NULL;
Alex Elder9d3997f2012-10-25 23:34:42 -05003663 struct rbd_client *rbdc;
Alex Elder27cc2592012-02-02 08:13:30 -06003664 struct ceph_osd_client *osdc;
3665 int rc = -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003666
3667 if (!try_module_get(THIS_MODULE))
3668 return -ENODEV;
3669
Alex Eldera725f65e2012-02-02 08:13:30 -06003670 /* parse add command */
Alex Elder859c31d2012-10-25 23:34:42 -05003671 rc = rbd_add_parse_args(buf, &ceph_opts, &rbd_opts, &spec);
Alex Elderdc79b112012-10-25 23:34:41 -05003672 if (rc < 0)
Alex Elderbd4ba652012-10-25 23:34:42 -05003673 goto err_out_module;
Alex Eldera725f65e2012-02-02 08:13:30 -06003674
Alex Elder9d3997f2012-10-25 23:34:42 -05003675 rbdc = rbd_get_client(ceph_opts);
3676 if (IS_ERR(rbdc)) {
3677 rc = PTR_ERR(rbdc);
Alex Elder0ddebc02012-10-25 23:34:41 -05003678 goto err_out_args;
Alex Elder9d3997f2012-10-25 23:34:42 -05003679 }
Alex Elderc53d5892012-10-25 23:34:42 -05003680 ceph_opts = NULL; /* rbd_dev client now owns this */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003681
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003682 /* pick the pool */
Alex Elder9d3997f2012-10-25 23:34:42 -05003683 osdc = &rbdc->client->osdc;
Alex Elder859c31d2012-10-25 23:34:42 -05003684 rc = ceph_pg_poolid_by_name(osdc->osdmap, spec->pool_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003685 if (rc < 0)
3686 goto err_out_client;
Alex Elder859c31d2012-10-25 23:34:42 -05003687 spec->pool_id = (u64) rc;
3688
Alex Elderc53d5892012-10-25 23:34:42 -05003689 rbd_dev = rbd_dev_create(rbdc, spec);
Alex Elderbd4ba652012-10-25 23:34:42 -05003690 if (!rbd_dev)
3691 goto err_out_client;
Alex Elderc53d5892012-10-25 23:34:42 -05003692 rbdc = NULL; /* rbd_dev now owns this */
3693 spec = NULL; /* rbd_dev now owns this */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003694
Alex Elderbd4ba652012-10-25 23:34:42 -05003695 rbd_dev->mapping.read_only = rbd_opts->read_only;
Alex Elderc53d5892012-10-25 23:34:42 -05003696 kfree(rbd_opts);
3697 rbd_opts = NULL; /* done with this */
Alex Elderbd4ba652012-10-25 23:34:42 -05003698
Alex Eldera30b71b2012-07-10 20:30:11 -05003699 rc = rbd_dev_probe(rbd_dev);
3700 if (rc < 0)
Alex Elderc53d5892012-10-25 23:34:42 -05003701 goto err_out_rbd_dev;
Alex Elder05fd6f62012-08-29 17:11:07 -05003702
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003703 return count;
Alex Elderc53d5892012-10-25 23:34:42 -05003704err_out_rbd_dev:
3705 rbd_dev_destroy(rbd_dev);
Alex Elderbd4ba652012-10-25 23:34:42 -05003706err_out_client:
Alex Elder9d3997f2012-10-25 23:34:42 -05003707 rbd_put_client(rbdc);
Alex Elder0ddebc02012-10-25 23:34:41 -05003708err_out_args:
Alex Elder78cea762012-10-25 23:34:41 -05003709 if (ceph_opts)
3710 ceph_destroy_options(ceph_opts);
Alex Elder4e9afeb2012-10-25 23:34:41 -05003711 kfree(rbd_opts);
Alex Elder859c31d2012-10-25 23:34:42 -05003712 rbd_spec_put(spec);
Alex Elderbd4ba652012-10-25 23:34:42 -05003713err_out_module:
3714 module_put(THIS_MODULE);
Alex Elder27cc2592012-02-02 08:13:30 -06003715
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003716 dout("Error adding device %s\n", buf);
Alex Elder27cc2592012-02-02 08:13:30 -06003717
3718 return (ssize_t) rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003719}
3720
Alex Elderde71a292012-07-03 16:01:19 -05003721static struct rbd_device *__rbd_get_dev(unsigned long dev_id)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003722{
3723 struct list_head *tmp;
3724 struct rbd_device *rbd_dev;
3725
Alex Eldere124a822012-01-29 13:57:44 -06003726 spin_lock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003727 list_for_each(tmp, &rbd_dev_list) {
3728 rbd_dev = list_entry(tmp, struct rbd_device, node);
Alex Elderde71a292012-07-03 16:01:19 -05003729 if (rbd_dev->dev_id == dev_id) {
Alex Eldere124a822012-01-29 13:57:44 -06003730 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003731 return rbd_dev;
Alex Eldere124a822012-01-29 13:57:44 -06003732 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003733 }
Alex Eldere124a822012-01-29 13:57:44 -06003734 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003735 return NULL;
3736}
3737
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003738static void rbd_dev_release(struct device *dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003739{
Alex Elder593a9e72012-02-07 12:03:37 -06003740 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003741
Alex Elder1dbb4392012-01-24 10:08:37 -06003742 if (rbd_dev->watch_request) {
3743 struct ceph_client *client = rbd_dev->rbd_client->client;
3744
3745 ceph_osdc_unregister_linger_request(&client->osdc,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003746 rbd_dev->watch_request);
Alex Elder1dbb4392012-01-24 10:08:37 -06003747 }
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003748 if (rbd_dev->watch_event)
Alex Elder070c6332012-07-25 09:32:41 -05003749 rbd_req_sync_unwatch(rbd_dev);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07003750
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003751
3752 /* clean up and free blkdev */
3753 rbd_free_disk(rbd_dev);
3754 unregister_blkdev(rbd_dev->major, rbd_dev->name);
Alex Elder32eec682012-02-08 16:11:14 -06003755
Alex Elder2ac4e752012-07-10 20:30:10 -05003756 /* release allocated disk header fields */
3757 rbd_header_free(&rbd_dev->header);
3758
Alex Elder32eec682012-02-08 16:11:14 -06003759 /* done with the id, and with the rbd_dev */
Alex Eldere2839302012-08-29 17:11:06 -05003760 rbd_dev_id_put(rbd_dev);
Alex Elderc53d5892012-10-25 23:34:42 -05003761 rbd_assert(rbd_dev->rbd_client != NULL);
3762 rbd_dev_destroy(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003763
3764 /* release module ref */
3765 module_put(THIS_MODULE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003766}
3767
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003768static ssize_t rbd_remove(struct bus_type *bus,
3769 const char *buf,
3770 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003771{
3772 struct rbd_device *rbd_dev = NULL;
3773 int target_id, rc;
3774 unsigned long ul;
3775 int ret = count;
3776
3777 rc = strict_strtoul(buf, 10, &ul);
3778 if (rc)
3779 return rc;
3780
3781 /* convert to int; abort if we lost anything in the conversion */
3782 target_id = (int) ul;
3783 if (target_id != ul)
3784 return -EINVAL;
3785
3786 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
3787
3788 rbd_dev = __rbd_get_dev(target_id);
3789 if (!rbd_dev) {
3790 ret = -ENOENT;
3791 goto done;
3792 }
3793
Alex Elder42382b72012-11-16 09:29:16 -06003794 if (rbd_dev->open_count) {
3795 ret = -EBUSY;
3796 goto done;
3797 }
3798
Alex Elder41f38c22012-10-25 23:34:40 -05003799 rbd_remove_all_snaps(rbd_dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003800 rbd_bus_del_dev(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003801
3802done:
3803 mutex_unlock(&ctl_mutex);
Alex Elderaafb2302012-09-06 16:00:54 -05003804
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003805 return ret;
3806}
3807
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003808/*
3809 * create control files in sysfs
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003810 * /sys/bus/rbd/...
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003811 */
3812static int rbd_sysfs_init(void)
3813{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003814 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003815
Alex Elderfed4c142012-02-07 12:03:36 -06003816 ret = device_register(&rbd_root_dev);
Alex Elder21079782012-01-24 10:08:36 -06003817 if (ret < 0)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003818 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003819
Alex Elderfed4c142012-02-07 12:03:36 -06003820 ret = bus_register(&rbd_bus_type);
3821 if (ret < 0)
3822 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003823
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003824 return ret;
3825}
3826
3827static void rbd_sysfs_cleanup(void)
3828{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003829 bus_unregister(&rbd_bus_type);
Alex Elderfed4c142012-02-07 12:03:36 -06003830 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003831}
3832
3833int __init rbd_init(void)
3834{
3835 int rc;
3836
3837 rc = rbd_sysfs_init();
3838 if (rc)
3839 return rc;
Alex Elderf0f8cef2012-01-29 13:57:44 -06003840 pr_info("loaded " RBD_DRV_NAME_LONG "\n");
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003841 return 0;
3842}
3843
3844void __exit rbd_exit(void)
3845{
3846 rbd_sysfs_cleanup();
3847}
3848
3849module_init(rbd_init);
3850module_exit(rbd_exit);
3851
3852MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
3853MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
3854MODULE_DESCRIPTION("rados block device");
3855
3856/* following authorship retained from original osdblk.c */
3857MODULE_AUTHOR("Jeff Garzik <jeff@garzik.org>");
3858
3859MODULE_LICENSE("GPL");