projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
rbd: a little more cleanup of rbd_rq_fn()
[deliverable/linux.git] / drivers / block / rbd.c
CommitLineData
602adf40
YS		 1/*
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
dfc5606d 24 For usage instructions, please refer to:
602adf40 25
dfc5606d 26 Documentation/ABI/testing/sysfs-bus-rbd
602adf40
YS		 27
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>
59c2be1e 34#include <linux/parser.h>
602adf40
YS		 35
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
aafb230e
AE		 44#define RBD_DEBUG /* Activate rbd_assert() calls */
45
593a9e7b
AE		 46/*
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
df111be6
AE		 55/* It might be useful to have this defined elsewhere too */
56
57#define U64_MAX ((u64) (~0ULL))
58
f0f8cef5
AE		 59#define RBD_DRV_NAME "rbd"
60#define RBD_DRV_NAME_LONG "rbd (rados block device)"
602adf40
YS		 61
62#define RBD_MINORS_PER_MAJOR 256 /* max minors per blkdev */
63
d4b125e9
AE		 64#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
35d489f9 68#define RBD_MAX_SNAP_COUNT 510 /* allows max snapc to fit in 4KB */
602adf40
YS		 69#define RBD_MAX_OPT_LEN 1024
70
71#define RBD_SNAP_HEAD_NAME "-"
72
9e15b77d
AE		 73/* 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)
1e130199 75#define RBD_IMAGE_ID_LEN_MAX 64
9e15b77d 76
1e130199 77#define RBD_OBJ_PREFIX_LEN_MAX 64
589d30e0 78
d889140c
AE		 79/* 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
81a89793
AE		 87/*
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 */
602adf40 93#define DEV_NAME_LEN 32
81a89793 94#define MAX_INT_FORMAT_WIDTH ((5 * sizeof (int)) / 2 + 1)
602adf40 95
cc0538b6 96#define RBD_READ_ONLY_DEFAULT false
59c2be1e 97
602adf40
YS		 98/*
99 * block device image metadata (in-memory version)
100 */
101struct rbd_image_header {
f84344f3 102 /* These four fields never change for a given rbd image */
849b4260 103 char *object_prefix;
34b13184 104 u64 features;
602adf40
YS		 105 __u8 obj_order;
106 __u8 crypt_type;
107 __u8 comp_type;
602adf40 108
f84344f3
AE		 109 /* The remaining fields need to be updated occasionally */
110 u64 image_size;
111 struct ceph_snap_context *snapc;
602adf40
YS		 112 char *snap_names;
113 u64 *snap_sizes;
59c2be1e
YS		 114
115 u64 obj_version;
116};
117
0d7dbfce
AE		 118/*
119 * An rbd image specification.
120 *
121 * The tuple (pool_id, image_id, snap_id) is sufficient to uniquely
c66c6e0c
AE		 122 * 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).
0d7dbfce
AE		 142 */
143struct rbd_spec {
144 u64 pool_id;
145 char *pool_name;
146
147 char *image_id;
0d7dbfce 148 char *image_name;
0d7dbfce
AE		 149
150 u64 snap_id;
151 char *snap_name;
152
153 struct kref kref;
154};
155
59c2be1e 156struct rbd_options {
cc0538b6 157 bool read_only;
602adf40
YS		 158};
159
160/*
f0f8cef5 161 * an instance of the client. multiple devices may share an rbd client.
602adf40
YS		 162 */
163struct rbd_client {
164 struct ceph_client *client;
165 struct kref kref;
166 struct list_head node;
167};
168
169/*
f0f8cef5 170 * a request completion status
602adf40 171 */
1fec7093
YS		 172struct rbd_req_status {
173 int done;
8986cb37 174 s32 rc;
1fec7093
YS		 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];
602adf40
YS		 186};
187
f0f8cef5
AE		 188/*
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
dfc5606d
YS		 200struct rbd_snap {
201 struct device dev;
202 const char *name;
3591538f 203 u64 size;
dfc5606d
YS		 204 struct list_head node;
205 u64 id;
34b13184 206 u64 features;
dfc5606d
YS		 207};
208
f84344f3 209struct rbd_mapping {
99c1f08f 210 u64 size;
34b13184 211 u64 features;
f84344f3
AE		 212 bool read_only;
213};
214
602adf40
YS		 215/*
216 * a single device
217 */
218struct rbd_device {
de71a297 219 int dev_id; /* blkdev unique id */
602adf40
YS		 220
221 int major; /* blkdev assigned major */
222 struct gendisk *disk; /* blkdev's gendisk and rq */
602adf40 223
a30b71b9 224 u32 image_format; /* Either 1 or 2 */
602adf40
YS		 225 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;
daba5fdb 232 bool exists;
0d7dbfce 233 struct rbd_spec *spec;
602adf40 234
0d7dbfce 235 char *header_name;
971f839a 236
59c2be1e
YS		 237 struct ceph_osd_event *watch_event;
238 struct ceph_osd_request *watch_request;
239
86b00e0d
AE		 240 struct rbd_spec *parent_spec;
241 u64 parent_overlap;
242
c666601a
JD		 243 /* protects updating the header */
244 struct rw_semaphore header_rwsem;
f84344f3
AE		 245
246 struct rbd_mapping mapping;
602adf40
YS		 247
248 struct list_head node;
dfc5606d
YS		 249
250 /* list of snapshots */
251 struct list_head snaps;
252
253 /* sysfs related */
254 struct device dev;
42382b70 255 unsigned long open_count;
dfc5606d
YS		 256};
257
602adf40 258static DEFINE_MUTEX(ctl_mutex); /* Serialize open/close/setup/teardown */
e124a82f 259
602adf40 260static LIST_HEAD(rbd_dev_list); /* devices */
e124a82f
AE		 261static DEFINE_SPINLOCK(rbd_dev_list_lock);
262
432b8587
AE		 263static LIST_HEAD(rbd_client_list); /* clients */
264static DEFINE_SPINLOCK(rbd_client_list_lock);
602adf40 265
304f6808
AE		 266static int rbd_dev_snaps_update(struct rbd_device *rbd_dev);
267static int rbd_dev_snaps_register(struct rbd_device *rbd_dev);
268
dfc5606d 269static void rbd_dev_release(struct device *dev);
41f38c2b 270static void rbd_remove_snap_dev(struct rbd_snap *snap);
dfc5606d 271
f0f8cef5
AE		 272static 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
06ecc6cb
AE		 297static __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
aafb230e
AE		 324#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 */
dfc5606d 336
117973fb
AE		 337static int rbd_dev_refresh(struct rbd_device *rbd_dev, u64 *hver);
338static int rbd_dev_v2_refresh(struct rbd_device *rbd_dev, u64 *hver);
59c2be1e 339
602adf40
YS		 340static int rbd_open(struct block_device *bdev, fmode_t mode)
341{
f0f8cef5 342 struct rbd_device *rbd_dev = bdev->bd_disk->private_data;
602adf40 343
f84344f3 344 if ((mode & FMODE_WRITE) && rbd_dev->mapping.read_only)
602adf40
YS		 345 return -EROFS;
346
42382b70 347 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
c3e946ce 348 (void) get_device(&rbd_dev->dev);
f84344f3 349 set_device_ro(bdev, rbd_dev->mapping.read_only);
42382b70
AE		 350 rbd_dev->open_count++;
351 mutex_unlock(&ctl_mutex);
340c7a2b 352
602adf40
YS		 353 return 0;
354}
355
dfc5606d
YS		 356static int rbd_release(struct gendisk *disk, fmode_t mode)
357{
358 struct rbd_device *rbd_dev = disk->private_data;
359
42382b70
AE		 360 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
361 rbd_assert(rbd_dev->open_count > 0);
362 rbd_dev->open_count--;
c3e946ce 363 put_device(&rbd_dev->dev);
42382b70 364 mutex_unlock(&ctl_mutex);
dfc5606d
YS		 365
366 return 0;
367}
368
602adf40
YS		 369static const struct block_device_operations rbd_bd_ops = {
370 .owner = THIS_MODULE,
371 .open = rbd_open,
dfc5606d 372 .release = rbd_release,
602adf40
YS		 373};
374
375/*
376 * Initialize an rbd client instance.
43ae4701 377 * We own *ceph_opts.
602adf40 378 */
f8c38929 379static struct rbd_client *rbd_client_create(struct ceph_options *ceph_opts)
602adf40
YS		 380{
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
bc534d86
AE		 392 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
393
43ae4701 394 rbdc->client = ceph_create_client(ceph_opts, rbdc, 0, 0);
602adf40 395 if (IS_ERR(rbdc->client))
bc534d86 396 goto out_mutex;
43ae4701 397 ceph_opts = NULL; /* Now rbdc->client is responsible for ceph_opts */
602adf40
YS		 398
399 ret = ceph_open_session(rbdc->client);
400 if (ret < 0)
401 goto out_err;
402
432b8587 403 spin_lock(&rbd_client_list_lock);
602adf40 404 list_add_tail(&rbdc->node, &rbd_client_list);
432b8587 405 spin_unlock(&rbd_client_list_lock);
602adf40 406
bc534d86
AE		 407 mutex_unlock(&ctl_mutex);
408
602adf40
YS		 409 dout("rbd_client_create created %p\n", rbdc);
410 return rbdc;
411
412out_err:
413 ceph_destroy_client(rbdc->client);
bc534d86
AE		 414out_mutex:
415 mutex_unlock(&ctl_mutex);
602adf40
YS		 416 kfree(rbdc);
417out_opt:
43ae4701
AE		 418 if (ceph_opts)
419 ceph_destroy_options(ceph_opts);
28f259b7 420 return ERR_PTR(ret);
602adf40
YS		 421}
422
423/*
1f7ba331
AE		 424 * Find a ceph client with specific addr and configuration. If
425 * found, bump its reference count.
602adf40 426 */
1f7ba331 427static struct rbd_client *rbd_client_find(struct ceph_options *ceph_opts)
602adf40
YS		 428{
429 struct rbd_client *client_node;
1f7ba331 430 bool found = false;
602adf40 431
43ae4701 432 if (ceph_opts->flags & CEPH_OPT_NOSHARE)
602adf40
YS		 433 return NULL;
434
1f7ba331
AE		 435 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;
602adf40
YS		 446}
447
59c2be1e
YS		 448/*
449 * mount options
450 */
451enum {
59c2be1e
YS		 452 Opt_last_int,
453 /* int args above */
454 Opt_last_string,
455 /* string args above */
cc0538b6
AE		 456 Opt_read_only,
457 Opt_read_write,
458 /* Boolean args above */
459 Opt_last_bool,
59c2be1e
YS		 460};
461
43ae4701 462static match_table_t rbd_opts_tokens = {
59c2be1e
YS		 463 /* int args above */
464 /* string args above */
be466c1c 465 {Opt_read_only, "read_only"},
cc0538b6
AE		 466 {Opt_read_only, "ro"}, /* Alternate spelling */
467 {Opt_read_write, "read_write"},
468 {Opt_read_write, "rw"}, /* Alternate spelling */
469 /* Boolean args above */
59c2be1e
YS		 470 {-1, NULL}
471};
472
473static int parse_rbd_opts_token(char *c, void *private)
474{
43ae4701 475 struct rbd_options *rbd_opts = private;
59c2be1e
YS		 476 substring_t argstr[MAX_OPT_ARGS];
477 int token, intval, ret;
478
43ae4701 479 token = match_token(c, rbd_opts_tokens, argstr);
59c2be1e
YS		 480 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);
cc0538b6
AE		 494 } else if (token > Opt_last_string && token < Opt_last_bool) {
495 dout("got Boolean token %d\n", token);
59c2be1e
YS		 496 } else {
497 dout("got token %d\n", token);
498 }
499
500 switch (token) {
cc0538b6
AE		 501 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;
59c2be1e 507 default:
aafb230e
AE		 508 rbd_assert(false);
509 break;
59c2be1e
YS		 510 }
511 return 0;
512}
513
602adf40
YS		 514/*
515 * Get a ceph client with specific addr and configuration, if one does
516 * not exist create it.
517 */
9d3997fd 518static struct rbd_client *rbd_get_client(struct ceph_options *ceph_opts)
602adf40 519{
f8c38929 520 struct rbd_client *rbdc;
59c2be1e 521
1f7ba331 522 rbdc = rbd_client_find(ceph_opts);
9d3997fd 523 if (rbdc) /* using an existing client */
43ae4701 524 ceph_destroy_options(ceph_opts);
9d3997fd 525 else
f8c38929 526 rbdc = rbd_client_create(ceph_opts);
602adf40 527
9d3997fd 528 return rbdc;
602adf40
YS		 529}
530
531/*
532 * Destroy ceph client
d23a4b3f 533 *
432b8587 534 * Caller must hold rbd_client_list_lock.
602adf40
YS		 535 */
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);
cd9d9f5d 541 spin_lock(&rbd_client_list_lock);
602adf40 542 list_del(&rbdc->node);
cd9d9f5d 543 spin_unlock(&rbd_client_list_lock);
602adf40
YS		 544
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 */
9d3997fd 553static void rbd_put_client(struct rbd_client *rbdc)
602adf40 554{
c53d5893
AE		 555 if (rbdc)
556 kref_put(&rbdc->kref, rbd_client_release);
602adf40
YS		 557}
558
1fec7093
YS		 559/*
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}
602adf40 570
a30b71b9
AE		 571static bool rbd_image_format_valid(u32 image_format)
572{
573 return image_format == 1 || image_format == 2;
574}
575
8e94af8e
AE		 576static bool rbd_dev_ondisk_valid(struct rbd_image_header_ondisk *ondisk)
577{
103a150f
AE		 578 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
db2388b6
AE		 585 /* 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
103a150f
AE		 595 /*
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;
8e94af8e
AE		 613}
614
602adf40
YS		 615/*
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,
4156d998 620 struct rbd_image_header_ondisk *ondisk)
602adf40 621{
ccece235 622 u32 snap_count;
58c17b0e 623 size_t len;
d2bb24e5 624 size_t size;
621901d6 625 u32 i;
602adf40 626
6a52325f
AE		 627 memset(header, 0, sizeof (*header));
628
103a150f
AE		 629 snap_count = le32_to_cpu(ondisk->snap_count);
630
58c17b0e
AE		 631 len = strnlen(ondisk->object_prefix, sizeof (ondisk->object_prefix));
632 header->object_prefix = kmalloc(len + 1, GFP_KERNEL);
6a52325f 633 if (!header->object_prefix)
602adf40 634 return -ENOMEM;
58c17b0e
AE		 635 memcpy(header->object_prefix, ondisk->object_prefix, len);
636 header->object_prefix[len] = '\0';
00f1f36f 637
602adf40 638 if (snap_count) {
f785cc1d
AE		 639 u64 snap_names_len = le64_to_cpu(ondisk->snap_names_len);
640
621901d6
AE		 641 /* Save a copy of the snapshot names */
642
f785cc1d
AE		 643 if (snap_names_len > (u64) SIZE_MAX)
644 return -EIO;
645 header->snap_names = kmalloc(snap_names_len, GFP_KERNEL);
602adf40 646 if (!header->snap_names)
6a52325f 647 goto out_err;
f785cc1d
AE		 648 /*
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);
6a52325f 656
621901d6
AE		 657 /* Record each snapshot's size */
658
d2bb24e5
AE		 659 size = snap_count * sizeof (*header->snap_sizes);
660 header->snap_sizes = kmalloc(size, GFP_KERNEL);
602adf40 661 if (!header->snap_sizes)
6a52325f 662 goto out_err;
621901d6
AE		 663 for (i = 0; i < snap_count; i++)
664 header->snap_sizes[i] =
665 le64_to_cpu(ondisk->snaps[i].image_size);
602adf40 666 } else {
ccece235 667 WARN_ON(ondisk->snap_names_len);
602adf40
YS		 668 header->snap_names = NULL;
669 header->snap_sizes = NULL;
670 }
849b4260 671
34b13184 672 header->features = 0; /* No features support in v1 images */
602adf40
YS		 673 header->obj_order = ondisk->options.order;
674 header->crypt_type = ondisk->options.crypt_type;
675 header->comp_type = ondisk->options.comp_type;
6a52325f 676
621901d6
AE		 677 /* Allocate and fill in the snapshot context */
678
f84344f3 679 header->image_size = le64_to_cpu(ondisk->image_size);
6a52325f
AE		 680 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;
602adf40
YS		 685
686 atomic_set(&header->snapc->nref, 1);
505cbb9b 687 header->snapc->seq = le64_to_cpu(ondisk->snap_seq);
602adf40 688 header->snapc->num_snaps = snap_count;
621901d6
AE		 689 for (i = 0; i < snap_count; i++)
690 header->snapc->snaps[i] =
691 le64_to_cpu(ondisk->snaps[i].id);
602adf40
YS		 692
693 return 0;
694
6a52325f 695out_err:
849b4260 696 kfree(header->snap_sizes);
ccece235 697 header->snap_sizes = NULL;
602adf40 698 kfree(header->snap_names);
ccece235 699 header->snap_names = NULL;
6a52325f
AE		 700 kfree(header->object_prefix);
701 header->object_prefix = NULL;
ccece235 702
00f1f36f 703 return -ENOMEM;
602adf40
YS		 704}
705
9e15b77d
AE		 706static 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
8836b995 720static int snap_by_name(struct rbd_device *rbd_dev, const char *snap_name)
602adf40 721{
602adf40 722
e86924a8 723 struct rbd_snap *snap;
602adf40 724
e86924a8
AE		 725 list_for_each_entry(snap, &rbd_dev->snaps, node) {
726 if (!strcmp(snap_name, snap->name)) {
0d7dbfce 727 rbd_dev->spec->snap_id = snap->id;
e86924a8 728 rbd_dev->mapping.size = snap->size;
34b13184 729 rbd_dev->mapping.features = snap->features;
602adf40 730
e86924a8 731 return 0;
00f1f36f 732 }
00f1f36f 733 }
e86924a8 734
00f1f36f 735 return -ENOENT;
602adf40
YS		 736}
737
819d52bf 738static int rbd_dev_set_mapping(struct rbd_device *rbd_dev)
602adf40 739{
78dc447d 740 int ret;
602adf40 741
0d7dbfce 742 if (!memcmp(rbd_dev->spec->snap_name, RBD_SNAP_HEAD_NAME,
cc9d734c 743 sizeof (RBD_SNAP_HEAD_NAME))) {
0d7dbfce 744 rbd_dev->spec->snap_id = CEPH_NOSNAP;
99c1f08f 745 rbd_dev->mapping.size = rbd_dev->header.image_size;
34b13184 746 rbd_dev->mapping.features = rbd_dev->header.features;
e86924a8 747 ret = 0;
602adf40 748 } else {
0d7dbfce 749 ret = snap_by_name(rbd_dev, rbd_dev->spec->snap_name);
602adf40
YS		 750 if (ret < 0)
751 goto done;
f84344f3 752 rbd_dev->mapping.read_only = true;
602adf40 753 }
daba5fdb 754 rbd_dev->exists = true;
602adf40 755done:
602adf40
YS		 756 return ret;
757}
758
759static void rbd_header_free(struct rbd_image_header *header)
760{
849b4260 761 kfree(header->object_prefix);
d78fd7ae 762 header->object_prefix = NULL;
602adf40 763 kfree(header->snap_sizes);
d78fd7ae 764 header->snap_sizes = NULL;
849b4260 765 kfree(header->snap_names);
d78fd7ae 766 header->snap_names = NULL;
d1d25646 767 ceph_put_snap_context(header->snapc);
d78fd7ae 768 header->snapc = NULL;
602adf40
YS		 769}
770
65ccfe21 771static char *rbd_segment_name(struct rbd_device *rbd_dev, u64 offset)
602adf40 772{
65ccfe21
AE		 773 char *name;
774 u64 segment;
775 int ret;
602adf40 776
2fd82b9e 777 name = kmalloc(MAX_OBJ_NAME_SIZE + 1, GFP_NOIO);
65ccfe21
AE		 778 if (!name)
779 return NULL;
780 segment = offset >> rbd_dev->header.obj_order;
2fd82b9e 781 ret = snprintf(name, MAX_OBJ_NAME_SIZE + 1, "%s.%012llx",
65ccfe21 782 rbd_dev->header.object_prefix, segment);
2fd82b9e 783 if (ret < 0 || ret > MAX_OBJ_NAME_SIZE) {
65ccfe21
AE		 784 pr_err("error formatting segment name for #%llu (%d)\n",
785 segment, ret);
786 kfree(name);
787 name = NULL;
788 }
602adf40 789
65ccfe21
AE		 790 return name;
791}
602adf40 792
65ccfe21
AE		 793static u64 rbd_segment_offset(struct rbd_device *rbd_dev, u64 offset)
794{
795 u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
602adf40 796
65ccfe21
AE		 797 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
aafb230e 807 rbd_assert(length <= U64_MAX - offset);
65ccfe21
AE		 808 if (offset + length > segment_size)
809 length = segment_size - offset;
810
811 return length;
602adf40
YS		 812}
813
1fec7093
YS		 814static int rbd_get_num_segments(struct rbd_image_header *header,
815 u64 ofs, u64 len)
816{
df111be6
AE		 817 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
1fec7093
YS		 828 return end_seg - start_seg + 1;
829}
830
029bcbd8
JD		 831/*
832 * 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
602adf40
YS		 839/*
840 * 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);
85b5aaa6 872 bvec_kunmap_irq(buf, &flags);
602adf40
YS		 873 }
874 pos += bv->bv_len;
875 }
876
877 chain = chain->bi_next;
878 }
879}
880
881/*
f7760dad
AE		 882 * Clone a portion of a bio, starting at the given byte offset
883 * and continuing for the number of bytes indicated.
602adf40 884 */
f7760dad
AE		 885static struct bio *bio_clone_range(struct bio *bio_src,
886 unsigned int offset,
887 unsigned int len,
888 gfp_t gfpmask)
602adf40 889{
f7760dad
AE		 890 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;
897
898 /* 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;
602adf40 917 }
f7760dad 918 voff = resid;
602adf40 919
f7760dad 920 /* ...and the last affected segment */
602adf40 921
f7760dad
AE		 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 */
602adf40 935
f7760dad
AE		 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;
602adf40
YS		 953 }
954
f7760dad
AE		 955 bio->bi_vcnt = vcnt;
956 bio->bi_size = len;
957 bio->bi_idx = 0;
958
959 return bio;
960}
961
962/*
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;
985
986 /* Build up a chain of clone bios up to the limit */
987
988 if (!bi || off >= bi->bi_size || !len)
989 return NULL; /* Nothing to clone */
602adf40 990
f7760dad
AE		 991 end = &chain;
992 while (len) {
993 unsigned int bi_size;
994 struct bio *bio;
995
f5400b7a
AE		 996 if (!bi) {
997 rbd_warn(NULL, "bio_chain exhausted with %u left", len);
f7760dad 998 goto out_err; /* EINVAL; ran out of bio's */
f5400b7a 999 }
f7760dad
AE		 1000 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;
602adf40 1007
f7760dad
AE		 1008 off += bi_size;
1009 if (off == bi->bi_size) {
1010 bi = bi->bi_next;
1011 off = 0;
1012 }
1013 len -= bi_size;
1014 }
1015 *bio_src = bi;
1016 *offset = off;
1017
1018 return chain;
1019out_err:
1020 bio_chain_put(chain);
602adf40 1021
602adf40
YS		 1022 return NULL;
1023}
1024
1025/*
1026 * helpers for osd request op vectors.
1027 */
57cfc106
AE		 1028static struct ceph_osd_req_op *rbd_create_rw_ops(int num_ops,
1029 int opcode, u32 payload_len)
602adf40 1030{
57cfc106
AE		 1031 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
602adf40
YS		 1039 /*
1040 * op extent offset and length will be set later on
1041 * in calc_raw_layout()
1042 */
57cfc106
AE		 1043 ops[0].payload_len = payload_len;
1044
1045 return ops;
602adf40
YS		 1046}
1047
1048static void rbd_destroy_ops(struct ceph_osd_req_op *ops)
1049{
1050 kfree(ops);
1051}
1052
1fec7093
YS		 1053static void rbd_coll_end_req_index(struct request *rq,
1054 struct rbd_req_coll *coll,
1055 int index,
8986cb37 1056 s32 ret, u64 len)
1fec7093
YS		 1057{
1058 struct request_queue *q;
1059 int min, max, i;
1060
bd919d45 1061 dout("rbd_coll_end_req_index %p index %d ret %d len %llu\n",
8986cb37 1062 coll, index, (int)ret, (unsigned long long)len);
1fec7093
YS		 1063
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++) {
8986cb37 1083 __blk_end_request(rq, (int)coll->status[i].rc,
1fec7093
YS		 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
725afc97 1091static void rbd_coll_end_req(struct rbd_request *rbd_req,
8986cb37 1092 s32 ret, u64 len)
1fec7093 1093{
725afc97
AE		 1094 rbd_coll_end_req_index(rbd_req->rq,
1095 rbd_req->coll, rbd_req->coll_index,
1096 ret, len);
1fec7093
YS		 1097}
1098
602adf40
YS		 1099/*
1100 * Send ceph osd request
1101 */
1102static int rbd_do_request(struct request *rq,
0ce1a794 1103 struct rbd_device *rbd_dev,
602adf40
YS		 1104 struct ceph_snap_context *snapc,
1105 u64 snapid,
aded07ea 1106 const char *object_name, u64 ofs, u64 len,
602adf40
YS		 1107 struct bio *bio,
1108 struct page **pages,
1109 int num_pages,
1110 int flags,
1111 struct ceph_osd_req_op *ops,
1fec7093
YS		 1112 struct rbd_req_coll *coll,
1113 int coll_index,
5f29ddd4
AE		 1114 void (*rbd_cb)(struct ceph_osd_request *,
1115 struct ceph_msg *),
59c2be1e
YS		 1116 struct ceph_osd_request **linger_req,
1117 u64 *ver)
602adf40 1118{
5f29ddd4 1119 struct ceph_osd_request *osd_req;
602adf40
YS		 1120 struct ceph_file_layout *layout;
1121 int ret;
1122 u64 bno;
1123 struct timespec mtime = CURRENT_TIME;
725afc97 1124 struct rbd_request *rbd_req;
602adf40 1125 struct ceph_osd_request_head *reqhead;
1dbb4399 1126 struct ceph_osd_client *osdc;
602adf40 1127
725afc97 1128 rbd_req = kzalloc(sizeof(*rbd_req), GFP_NOIO);
cd323ac0 1129 if (!rbd_req)
1fec7093 1130 return -ENOMEM;
1fec7093
YS		 1131
1132 if (coll) {
725afc97
AE		 1133 rbd_req->coll = coll;
1134 rbd_req->coll_index = coll_index;
1fec7093 1135 }
602adf40 1136
f7760dad
AE		 1137 dout("rbd_do_request object_name=%s ofs=%llu len=%llu coll=%p[%d]\n",
1138 object_name, (unsigned long long) ofs,
1139 (unsigned long long) len, coll, coll_index);
602adf40 1140
0ce1a794 1141 osdc = &rbd_dev->rbd_client->client->osdc;
5f29ddd4 1142 osd_req = ceph_osdc_alloc_request(osdc, flags, snapc, ops,
1dbb4399 1143 false, GFP_NOIO, pages, bio);
5f29ddd4 1144 if (!osd_req) {
4ad12621 1145 ret = -ENOMEM;
602adf40
YS		 1146 goto done_pages;
1147 }
1148
5f29ddd4 1149 osd_req->r_callback = rbd_cb;
602adf40 1150
725afc97
AE		 1151 rbd_req->rq = rq;
1152 rbd_req->bio = bio;
1153 rbd_req->pages = pages;
1154 rbd_req->len = len;
602adf40 1155
5f29ddd4 1156 osd_req->r_priv = rbd_req;
602adf40 1157
5f29ddd4 1158 reqhead = osd_req->r_request->front.iov_base;
602adf40
YS		 1159 reqhead->snapid = cpu_to_le64(CEPH_NOSNAP);
1160
5f29ddd4
AE		 1161 strncpy(osd_req->r_oid, object_name, sizeof(osd_req->r_oid));
1162 osd_req->r_oid_len = strlen(osd_req->r_oid);
602adf40 1163
5f29ddd4 1164 layout = &osd_req->r_file_layout;
602adf40
YS		 1165 memset(layout, 0, sizeof(*layout));
1166 layout->fl_stripe_unit = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
1167 layout->fl_stripe_count = cpu_to_le32(1);
1168 layout->fl_object_size = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
0d7dbfce 1169 layout->fl_pg_pool = cpu_to_le32((int) rbd_dev->spec->pool_id);
6cae3717 1170 ret = ceph_calc_raw_layout(osdc, layout, snapid, ofs, &len, &bno,
5f29ddd4 1171 osd_req, ops);
6cae3717 1172 rbd_assert(ret == 0);
602adf40 1173
5f29ddd4 1174 ceph_osdc_build_request(osd_req, ofs, &len,
602adf40
YS		 1175 ops,
1176 snapc,
1177 &mtime,
5f29ddd4 1178 osd_req->r_oid, osd_req->r_oid_len);
602adf40 1179
59c2be1e 1180 if (linger_req) {
5f29ddd4
AE		 1181 ceph_osdc_set_request_linger(osdc, osd_req);
1182 *linger_req = osd_req;
59c2be1e
YS		 1183 }
1184
5f29ddd4 1185 ret = ceph_osdc_start_request(osdc, osd_req, false);
602adf40
YS		 1186 if (ret < 0)
1187 goto done_err;
1188
1189 if (!rbd_cb) {
5f29ddd4
AE		 1190 u64 version;
1191
1192 ret = ceph_osdc_wait_request(osdc, osd_req);
1193 version = le64_to_cpu(osd_req->r_reassert_version.version);
59c2be1e 1194 if (ver)
5f29ddd4
AE		 1195 *ver = version;
1196 dout("reassert_ver=%llu\n", (unsigned long long) version);
1197 ceph_osdc_put_request(osd_req);
602adf40
YS		 1198 }
1199 return ret;
1200
1201done_err:
725afc97 1202 bio_chain_put(rbd_req->bio);
5f29ddd4 1203 ceph_osdc_put_request(osd_req);
602adf40 1204done_pages:
725afc97 1205 kfree(rbd_req);
602adf40
YS		 1206 return ret;
1207}
1208
1209/*
1210 * Ceph osd op callback
1211 */
5f29ddd4 1212static void rbd_req_cb(struct ceph_osd_request *osd_req, struct ceph_msg *msg)
602adf40 1213{
5f29ddd4 1214 struct rbd_request *rbd_req = osd_req->r_priv;
602adf40
YS		 1215 struct ceph_osd_reply_head *replyhead;
1216 struct ceph_osd_op *op;
8986cb37 1217 s32 rc;
602adf40
YS		 1218 u64 bytes;
1219 int read_op;
1220
1221 /* parse reply */
1222 replyhead = msg->front.iov_base;
1223 WARN_ON(le32_to_cpu(replyhead->num_ops) == 0);
1224 op = (void *)(replyhead + 1);
8986cb37 1225 rc = (s32)le32_to_cpu(replyhead->result);
602adf40 1226 bytes = le64_to_cpu(op->extent.length);
895cfcc8 1227 read_op = (le16_to_cpu(op->op) == CEPH_OSD_OP_READ);
602adf40 1228
bd919d45
AE		 1229 dout("rbd_req_cb bytes=%llu readop=%d rc=%d\n",
1230 (unsigned long long) bytes, read_op, (int) rc);
602adf40 1231
8986cb37 1232 if (rc == (s32)-ENOENT && read_op) {
725afc97 1233 zero_bio_chain(rbd_req->bio, 0);
602adf40 1234 rc = 0;
725afc97
AE		 1235 } else if (rc == 0 && read_op && bytes < rbd_req->len) {
1236 zero_bio_chain(rbd_req->bio, bytes);
1237 bytes = rbd_req->len;
602adf40
YS		 1238 }
1239
725afc97 1240 rbd_coll_end_req(rbd_req, rc, bytes);
602adf40 1241
725afc97
AE		 1242 if (rbd_req->bio)
1243 bio_chain_put(rbd_req->bio);
602adf40 1244
5f29ddd4 1245 ceph_osdc_put_request(osd_req);
725afc97 1246 kfree(rbd_req);
602adf40
YS		 1247}
1248
5f29ddd4
AE		 1249static void rbd_simple_req_cb(struct ceph_osd_request *osd_req,
1250 struct ceph_msg *msg)
59c2be1e 1251{
5f29ddd4 1252 ceph_osdc_put_request(osd_req);
59c2be1e
YS		 1253}
1254
602adf40
YS		 1255/*
1256 * Do a synchronous ceph osd operation
1257 */
0ce1a794 1258static int rbd_req_sync_op(struct rbd_device *rbd_dev,
602adf40
YS		 1259 struct ceph_snap_context *snapc,
1260 u64 snapid,
602adf40 1261 int flags,
913d2fdc 1262 struct ceph_osd_req_op *ops,
aded07ea 1263 const char *object_name,
f8d4de6e
AE		 1264 u64 ofs, u64 inbound_size,
1265 char *inbound,
59c2be1e
YS		 1266 struct ceph_osd_request **linger_req,
1267 u64 *ver)
602adf40
YS		 1268{
1269 int ret;
1270 struct page **pages;
1271 int num_pages;
913d2fdc 1272
aafb230e 1273 rbd_assert(ops != NULL);
602adf40 1274
f8d4de6e 1275 num_pages = calc_pages_for(ofs, inbound_size);
602adf40 1276 pages = ceph_alloc_page_vector(num_pages, GFP_KERNEL);
b8d0638a
DC		 1277 if (IS_ERR(pages))
1278 return PTR_ERR(pages);
602adf40 1279
0ce1a794 1280 ret = rbd_do_request(NULL, rbd_dev, snapc, snapid,
f8d4de6e 1281 object_name, ofs, inbound_size, NULL,
602adf40
YS		 1282 pages, num_pages,
1283 flags,
1284 ops,
1fec7093 1285 NULL, 0,
59c2be1e
YS		 1286 NULL,
1287 linger_req, ver);
602adf40 1288 if (ret < 0)
913d2fdc 1289 goto done;
602adf40 1290
f8d4de6e
AE		 1291 if ((flags & CEPH_OSD_FLAG_READ) && inbound)
1292 ret = ceph_copy_from_page_vector(pages, inbound, ofs, ret);
602adf40 1293
602adf40
YS		 1294done:
1295 ceph_release_page_vector(pages, num_pages);
1296 return ret;
1297}
1298
1299/*
1300 * Do an asynchronous ceph osd operation
1301 */
1302static int rbd_do_op(struct request *rq,
0ce1a794 1303 struct rbd_device *rbd_dev,
602adf40 1304 struct ceph_snap_context *snapc,
602adf40 1305 u64 ofs, u64 len,
1fec7093
YS		 1306 struct bio *bio,
1307 struct rbd_req_coll *coll,
1308 int coll_index)
602adf40
YS		 1309{
1310 char *seg_name;
1311 u64 seg_ofs;
1312 u64 seg_len;
1313 int ret;
1314 struct ceph_osd_req_op *ops;
1315 u32 payload_len;
ff2e4bb5
AE		 1316 int opcode;
1317 int flags;
4634246d 1318 u64 snapid;
602adf40 1319
65ccfe21 1320 seg_name = rbd_segment_name(rbd_dev, ofs);
602adf40
YS		 1321 if (!seg_name)
1322 return -ENOMEM;
65ccfe21
AE		 1323 seg_len = rbd_segment_length(rbd_dev, ofs, len);
1324 seg_ofs = rbd_segment_offset(rbd_dev, ofs);
602adf40 1325
ff2e4bb5
AE		 1326 if (rq_data_dir(rq) == WRITE) {
1327 opcode = CEPH_OSD_OP_WRITE;
1328 flags = CEPH_OSD_FLAG_WRITE|CEPH_OSD_FLAG_ONDISK;
4634246d 1329 snapid = CEPH_NOSNAP;
ff2e4bb5
AE		 1330 payload_len = seg_len;
1331 } else {
1332 opcode = CEPH_OSD_OP_READ;
1333 flags = CEPH_OSD_FLAG_READ;
4634246d 1334 snapc = NULL;
0d7dbfce 1335 snapid = rbd_dev->spec->snap_id;
ff2e4bb5
AE		 1336 payload_len = 0;
1337 }
602adf40 1338
57cfc106
AE		 1339 ret = -ENOMEM;
1340 ops = rbd_create_rw_ops(1, opcode, payload_len);
1341 if (!ops)
602adf40
YS		 1342 goto done;
1343
1344 /* we've taken care of segment sizes earlier when we
1345 cloned the bios. We should never have a segment
1346 truncated at this point */
aafb230e 1347 rbd_assert(seg_len == len);
602adf40
YS		 1348
1349 ret = rbd_do_request(rq, rbd_dev, snapc, snapid,
1350 seg_name, seg_ofs, seg_len,
1351 bio,
1352 NULL, 0,
1353 flags,
1354 ops,
1fec7093 1355 coll, coll_index,
59c2be1e 1356 rbd_req_cb, 0, NULL);
cd323ac0
AE		 1357 if (ret < 0)
1358 rbd_coll_end_req_index(rq, coll, coll_index,
1359 (s32)ret, seg_len);
11f77002 1360 rbd_destroy_ops(ops);
602adf40
YS		 1361done:
1362 kfree(seg_name);
1363 return ret;
1364}
1365
602adf40
YS		 1366/*
1367 * Request sync osd read
1368 */
0ce1a794 1369static int rbd_req_sync_read(struct rbd_device *rbd_dev,
602adf40 1370 u64 snapid,
aded07ea 1371 const char *object_name,
602adf40 1372 u64 ofs, u64 len,
59c2be1e
YS		 1373 char *buf,
1374 u64 *ver)
602adf40 1375{
913d2fdc
AE		 1376 struct ceph_osd_req_op *ops;
1377 int ret;
1378
1379 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_READ, 0);
1380 if (!ops)
1381 return -ENOMEM;
1382
1383 ret = rbd_req_sync_op(rbd_dev, NULL,
b06e6a6b 1384 snapid,
602adf40 1385 CEPH_OSD_FLAG_READ,
913d2fdc
AE		 1386 ops, object_name, ofs, len, buf, NULL, ver);
1387 rbd_destroy_ops(ops);
1388
1389 return ret;
602adf40
YS		 1390}
1391
1392/*
59c2be1e
YS		 1393 * Request sync osd watch
1394 */
0ce1a794 1395static int rbd_req_sync_notify_ack(struct rbd_device *rbd_dev,
59c2be1e 1396 u64 ver,
7f0a24d8 1397 u64 notify_id)
59c2be1e
YS		 1398{
1399 struct ceph_osd_req_op *ops;
11f77002
SW		 1400 int ret;
1401
57cfc106
AE		 1402 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_NOTIFY_ACK, 0);
1403 if (!ops)
1404 return -ENOMEM;
59c2be1e 1405
a71b891b 1406 ops[0].watch.ver = cpu_to_le64(ver);
59c2be1e
YS		 1407 ops[0].watch.cookie = notify_id;
1408 ops[0].watch.flag = 0;
1409
0ce1a794 1410 ret = rbd_do_request(NULL, rbd_dev, NULL, CEPH_NOSNAP,
7f0a24d8 1411 rbd_dev->header_name, 0, 0, NULL,
ad4f232f 1412 NULL, 0,
59c2be1e
YS		 1413 CEPH_OSD_FLAG_READ,
1414 ops,
1fec7093 1415 NULL, 0,
59c2be1e
YS		 1416 rbd_simple_req_cb, 0, NULL);
1417
1418 rbd_destroy_ops(ops);
1419 return ret;
1420}
1421
1422static void rbd_watch_cb(u64 ver, u64 notify_id, u8 opcode, void *data)
1423{
0ce1a794 1424 struct rbd_device *rbd_dev = (struct rbd_device *)data;
a71b891b 1425 u64 hver;
13143d2d
SW		 1426 int rc;
1427
0ce1a794 1428 if (!rbd_dev)
59c2be1e
YS		 1429 return;
1430
bd919d45
AE		 1431 dout("rbd_watch_cb %s notify_id=%llu opcode=%u\n",
1432 rbd_dev->header_name, (unsigned long long) notify_id,
1433 (unsigned int) opcode);
117973fb 1434 rc = rbd_dev_refresh(rbd_dev, &hver);
13143d2d 1435 if (rc)
06ecc6cb
AE		 1436 rbd_warn(rbd_dev, "got notification but failed to "
1437 " update snaps: %d\n", rc);
59c2be1e 1438
7f0a24d8 1439 rbd_req_sync_notify_ack(rbd_dev, hver, notify_id);
59c2be1e
YS		 1440}
1441
1442/*
1443 * Request sync osd watch
1444 */
0e6f322d 1445static int rbd_req_sync_watch(struct rbd_device *rbd_dev)
59c2be1e
YS		 1446{
1447 struct ceph_osd_req_op *ops;
0ce1a794 1448 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
57cfc106 1449 int ret;
59c2be1e 1450
57cfc106
AE		 1451 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_WATCH, 0);
1452 if (!ops)
1453 return -ENOMEM;
59c2be1e
YS		 1454
1455 ret = ceph_osdc_create_event(osdc, rbd_watch_cb, 0,
0ce1a794 1456 (void *)rbd_dev, &rbd_dev->watch_event);
59c2be1e
YS		 1457 if (ret < 0)
1458 goto fail;
1459
0e6f322d 1460 ops[0].watch.ver = cpu_to_le64(rbd_dev->header.obj_version);
0ce1a794 1461 ops[0].watch.cookie = cpu_to_le64(rbd_dev->watch_event->cookie);
59c2be1e
YS		 1462 ops[0].watch.flag = 1;
1463
0ce1a794 1464 ret = rbd_req_sync_op(rbd_dev, NULL,
59c2be1e 1465 CEPH_NOSNAP,
59c2be1e
YS		 1466 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1467 ops,
0e6f322d
AE		 1468 rbd_dev->header_name,
1469 0, 0, NULL,
0ce1a794 1470 &rbd_dev->watch_request, NULL);
59c2be1e
YS		 1471
1472 if (ret < 0)
1473 goto fail_event;
1474
1475 rbd_destroy_ops(ops);
1476 return 0;
1477
1478fail_event:
0ce1a794
AE		 1479 ceph_osdc_cancel_event(rbd_dev->watch_event);
1480 rbd_dev->watch_event = NULL;
59c2be1e
YS		 1481fail:
1482 rbd_destroy_ops(ops);
1483 return ret;
1484}
1485
79e3057c
YS		 1486/*
1487 * Request sync osd unwatch
1488 */
070c633f 1489static int rbd_req_sync_unwatch(struct rbd_device *rbd_dev)
79e3057c
YS		 1490{
1491 struct ceph_osd_req_op *ops;
57cfc106 1492 int ret;
79e3057c 1493
57cfc106
AE		 1494 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_WATCH, 0);
1495 if (!ops)
1496 return -ENOMEM;
79e3057c
YS		 1497
1498 ops[0].watch.ver = 0;
0ce1a794 1499 ops[0].watch.cookie = cpu_to_le64(rbd_dev->watch_event->cookie);
79e3057c
YS		 1500 ops[0].watch.flag = 0;
1501
0ce1a794 1502 ret = rbd_req_sync_op(rbd_dev, NULL,
79e3057c 1503 CEPH_NOSNAP,
79e3057c
YS		 1504 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1505 ops,
070c633f
AE		 1506 rbd_dev->header_name,
1507 0, 0, NULL, NULL, NULL);
1508
79e3057c
YS		 1509
1510 rbd_destroy_ops(ops);
0ce1a794
AE		 1511 ceph_osdc_cancel_event(rbd_dev->watch_event);
1512 rbd_dev->watch_event = NULL;
79e3057c
YS		 1513 return ret;
1514}
1515
602adf40 1516/*
3cb4a687 1517 * Synchronous osd object method call
602adf40 1518 */
0ce1a794 1519static int rbd_req_sync_exec(struct rbd_device *rbd_dev,
aded07ea
AE		 1520 const char *object_name,
1521 const char *class_name,
1522 const char *method_name,
3cb4a687
AE		 1523 const char *outbound,
1524 size_t outbound_size,
f8d4de6e
AE		 1525 char *inbound,
1526 size_t inbound_size,
3cb4a687 1527 int flags,
59c2be1e 1528 u64 *ver)
602adf40
YS		 1529{
1530 struct ceph_osd_req_op *ops;
aded07ea
AE		 1531 int class_name_len = strlen(class_name);
1532 int method_name_len = strlen(method_name);
3cb4a687 1533 int payload_size;
57cfc106
AE		 1534 int ret;
1535
3cb4a687
AE		 1536 /*
1537 * Any input parameters required by the method we're calling
1538 * will be sent along with the class and method names as
1539 * part of the message payload. That data and its size are
1540 * supplied via the indata and indata_len fields (named from
1541 * the perspective of the server side) in the OSD request
1542 * operation.
1543 */
1544 payload_size = class_name_len + method_name_len + outbound_size;
1545 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_CALL, payload_size);
57cfc106
AE		 1546 if (!ops)
1547 return -ENOMEM;
602adf40 1548
aded07ea
AE		 1549 ops[0].cls.class_name = class_name;
1550 ops[0].cls.class_len = (__u8) class_name_len;
1551 ops[0].cls.method_name = method_name;
1552 ops[0].cls.method_len = (__u8) method_name_len;
602adf40 1553 ops[0].cls.argc = 0;
3cb4a687
AE		 1554 ops[0].cls.indata = outbound;
1555 ops[0].cls.indata_len = outbound_size;
602adf40 1556
0ce1a794 1557 ret = rbd_req_sync_op(rbd_dev, NULL,
602adf40 1558 CEPH_NOSNAP,
3cb4a687 1559 flags, ops,
f8d4de6e
AE		 1560 object_name, 0, inbound_size, inbound,
1561 NULL, ver);
602adf40
YS		 1562
1563 rbd_destroy_ops(ops);
1564
1565 dout("cls_exec returned %d\n", ret);
1566 return ret;
1567}
1568
1fec7093
YS		 1569static struct rbd_req_coll *rbd_alloc_coll(int num_reqs)
1570{
1571 struct rbd_req_coll *coll =
1572 kzalloc(sizeof(struct rbd_req_coll) +
1573 sizeof(struct rbd_req_status) * num_reqs,
1574 GFP_ATOMIC);
1575
1576 if (!coll)
1577 return NULL;
1578 coll->total = num_reqs;
1579 kref_init(&coll->kref);
1580 return coll;
1581}
1582
8295cda7
AE		 1583static int rbd_dev_do_request(struct request *rq,
1584 struct rbd_device *rbd_dev,
1585 struct ceph_snap_context *snapc,
1586 u64 ofs, unsigned int size,
1587 struct bio *bio_chain)
1588{
1589 int num_segs;
1590 struct rbd_req_coll *coll;
1591 unsigned int bio_offset;
1592 int cur_seg = 0;
1593
1594 dout("%s 0x%x bytes at 0x%llx\n",
1595 rq_data_dir(rq) == WRITE ? "write" : "read",
1596 size, (unsigned long long) blk_rq_pos(rq) * SECTOR_SIZE);
1597
1598 num_segs = rbd_get_num_segments(&rbd_dev->header, ofs, size);
1599 if (num_segs <= 0)
1600 return num_segs;
1601
1602 coll = rbd_alloc_coll(num_segs);
1603 if (!coll)
1604 return -ENOMEM;
1605
1606 bio_offset = 0;
1607 do {
1608 u64 limit = rbd_segment_length(rbd_dev, ofs, size);
1609 unsigned int clone_size;
1610 struct bio *bio_clone;
1611
1612 BUG_ON(limit > (u64)UINT_MAX);
1613 clone_size = (unsigned int)limit;
1614 dout("bio_chain->bi_vcnt=%hu\n", bio_chain->bi_vcnt);
1615
1616 kref_get(&coll->kref);
1617
1618 /* Pass a cloned bio chain via an osd request */
1619
1620 bio_clone = bio_chain_clone_range(&bio_chain,
1621 &bio_offset, clone_size,
1622 GFP_ATOMIC);
1623 if (bio_clone)
1624 (void)rbd_do_op(rq, rbd_dev, snapc,
1625 ofs, clone_size,
1626 bio_clone, coll, cur_seg);
1627 else
1628 rbd_coll_end_req_index(rq, coll, cur_seg,
1629 (s32)-ENOMEM,
1630 clone_size);
1631 size -= clone_size;
1632 ofs += clone_size;
1633
1634 cur_seg++;
1635 } while (size > 0);
1636 kref_put(&coll->kref, rbd_coll_release);
1637
1638 return 0;
1639}
1640
602adf40
YS		 1641/*
1642 * block device queue callback
1643 */
1644static void rbd_rq_fn(struct request_queue *q)
1645{
1646 struct rbd_device *rbd_dev = q->queuedata;
b395e8b5 1647 bool read_only = rbd_dev->mapping.read_only;
602adf40 1648 struct request *rq;
602adf40 1649
00f1f36f 1650 while ((rq = blk_fetch_request(q))) {
b395e8b5
AE		 1651 struct ceph_snap_context *snapc = NULL;
1652 unsigned int size = 0;
8295cda7 1653 int result;
602adf40 1654
602adf40
YS		 1655 dout("fetched request\n");
1656
b395e8b5
AE		 1657 /* Filter out block requests we don't understand */
1658
602adf40
YS		 1659 if ((rq->cmd_type != REQ_TYPE_FS)) {
1660 __blk_end_request_all(rq, 0);
00f1f36f 1661 continue;
602adf40 1662 }
b395e8b5 1663 spin_unlock_irq(q->queue_lock);
602adf40 1664
b395e8b5 1665 /* Stop writes to a read-only device */
602adf40 1666
b395e8b5
AE		 1667 result = -EROFS;
1668 if (read_only && rq_data_dir(rq) == WRITE)
1669 goto out_end_request;
1670
1671 /* Grab a reference to the snapshot context */
602adf40 1672
d1d25646 1673 down_read(&rbd_dev->header_rwsem);
b395e8b5
AE		 1674 if (rbd_dev->exists) {
1675 snapc = ceph_get_snap_context(rbd_dev->header.snapc);
1676 rbd_assert(snapc != NULL);
1677 }
1678 up_read(&rbd_dev->header_rwsem);
e88a36ec 1679
b395e8b5 1680 if (!snapc) {
0d7dbfce 1681 rbd_assert(rbd_dev->spec->snap_id != CEPH_NOSNAP);
d1d25646 1682 dout("request for non-existent snapshot");
b395e8b5
AE		 1683 result = -ENXIO;
1684 goto out_end_request;
e88a36ec
JD		 1685 }
1686
f7760dad 1687 size = blk_rq_bytes(rq);
b395e8b5
AE		 1688 result = rbd_dev_do_request(rq, rbd_dev, snapc,
1689 blk_rq_pos(rq) * SECTOR_SIZE,
1690 size, rq->bio);
1691out_end_request:
d1d25646 1692 ceph_put_snap_context(snapc);
8295cda7
AE		 1693 spin_lock_irq(q->queue_lock);
1694 if (!size || result < 0)
1695 __blk_end_request_all(rq, result);
602adf40
YS		 1696 }
1697}
1698
1699/*
1700 * a queue callback. Makes sure that we don't create a bio that spans across
1701 * multiple osd objects. One exception would be with a single page bios,
f7760dad 1702 * which we handle later at bio_chain_clone_range()
602adf40
YS		 1703 */
1704static int rbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bmd,
1705 struct bio_vec *bvec)
1706{
1707 struct rbd_device *rbd_dev = q->queuedata;
e5cfeed2
AE		 1708 sector_t sector_offset;
1709 sector_t sectors_per_obj;
1710 sector_t obj_sector_offset;
1711 int ret;
1712
1713 /*
1714 * Find how far into its rbd object the partition-relative
1715 * bio start sector is to offset relative to the enclosing
1716 * device.
1717 */
1718 sector_offset = get_start_sect(bmd->bi_bdev) + bmd->bi_sector;
1719 sectors_per_obj = 1 << (rbd_dev->header.obj_order - SECTOR_SHIFT);
1720 obj_sector_offset = sector_offset & (sectors_per_obj - 1);
1721
1722 /*
1723 * Compute the number of bytes from that offset to the end
1724 * of the object. Account for what's already used by the bio.
1725 */
1726 ret = (int) (sectors_per_obj - obj_sector_offset) << SECTOR_SHIFT;
1727 if (ret > bmd->bi_size)
1728 ret -= bmd->bi_size;
1729 else
1730 ret = 0;
1731
1732 /*
1733 * Don't send back more than was asked for. And if the bio
1734 * was empty, let the whole thing through because: "Note
1735 * that a block device *must* allow a single page to be
1736 * added to an empty bio."
1737 */
1738 rbd_assert(bvec->bv_len <= PAGE_SIZE);
1739 if (ret > (int) bvec->bv_len || !bmd->bi_size)
1740 ret = (int) bvec->bv_len;
1741
1742 return ret;
602adf40
YS		 1743}
1744
1745static void rbd_free_disk(struct rbd_device *rbd_dev)
1746{
1747 struct gendisk *disk = rbd_dev->disk;
1748
1749 if (!disk)
1750 return;
1751
602adf40
YS		 1752 if (disk->flags & GENHD_FL_UP)
1753 del_gendisk(disk);
1754 if (disk->queue)
1755 blk_cleanup_queue(disk->queue);
1756 put_disk(disk);
1757}
1758
1759/*
4156d998
AE		 1760 * Read the complete header for the given rbd device.
1761 *
1762 * Returns a pointer to a dynamically-allocated buffer containing
1763 * the complete and validated header. Caller can pass the address
1764 * of a variable that will be filled in with the version of the
1765 * header object at the time it was read.
1766 *
1767 * Returns a pointer-coded errno if a failure occurs.
602adf40 1768 */
4156d998
AE		 1769static struct rbd_image_header_ondisk *
1770rbd_dev_v1_header_read(struct rbd_device *rbd_dev, u64 *version)
602adf40 1771{
4156d998 1772 struct rbd_image_header_ondisk *ondisk = NULL;
50f7c4c9 1773 u32 snap_count = 0;
4156d998
AE		 1774 u64 names_size = 0;
1775 u32 want_count;
1776 int ret;
602adf40 1777
00f1f36f 1778 /*
4156d998
AE		 1779 * The complete header will include an array of its 64-bit
1780 * snapshot ids, followed by the names of those snapshots as
1781 * a contiguous block of NUL-terminated strings. Note that
1782 * the number of snapshots could change by the time we read
1783 * it in, in which case we re-read it.
00f1f36f 1784 */
4156d998
AE		 1785 do {
1786 size_t size;
1787
1788 kfree(ondisk);
1789
1790 size = sizeof (*ondisk);
1791 size += snap_count * sizeof (struct rbd_image_snap_ondisk);
1792 size += names_size;
1793 ondisk = kmalloc(size, GFP_KERNEL);
1794 if (!ondisk)
1795 return ERR_PTR(-ENOMEM);
1796
1797 ret = rbd_req_sync_read(rbd_dev, CEPH_NOSNAP,
0bed54dc 1798 rbd_dev->header_name,
4156d998
AE		 1799 0, size,
1800 (char *) ondisk, version);
1801
1802 if (ret < 0)
1803 goto out_err;
1804 if (WARN_ON((size_t) ret < size)) {
1805 ret = -ENXIO;
06ecc6cb
AE		 1806 rbd_warn(rbd_dev, "short header read (want %zd got %d)",
1807 size, ret);
4156d998
AE		 1808 goto out_err;
1809 }
1810 if (!rbd_dev_ondisk_valid(ondisk)) {
1811 ret = -ENXIO;
06ecc6cb 1812 rbd_warn(rbd_dev, "invalid header");
4156d998 1813 goto out_err;
81e759fb 1814 }
602adf40 1815
4156d998
AE		 1816 names_size = le64_to_cpu(ondisk->snap_names_len);
1817 want_count = snap_count;
1818 snap_count = le32_to_cpu(ondisk->snap_count);
1819 } while (snap_count != want_count);
00f1f36f 1820
4156d998 1821 return ondisk;
00f1f36f 1822
4156d998
AE		 1823out_err:
1824 kfree(ondisk);
1825
1826 return ERR_PTR(ret);
1827}
1828
1829/*
1830 * reload the ondisk the header
1831 */
1832static int rbd_read_header(struct rbd_device *rbd_dev,
1833 struct rbd_image_header *header)
1834{
1835 struct rbd_image_header_ondisk *ondisk;
1836 u64 ver = 0;
1837 int ret;
602adf40 1838
4156d998
AE		 1839 ondisk = rbd_dev_v1_header_read(rbd_dev, &ver);
1840 if (IS_ERR(ondisk))
1841 return PTR_ERR(ondisk);
1842 ret = rbd_header_from_disk(header, ondisk);
1843 if (ret >= 0)
1844 header->obj_version = ver;
1845 kfree(ondisk);
1846
1847 return ret;
602adf40
YS		 1848}
1849
41f38c2b 1850static void rbd_remove_all_snaps(struct rbd_device *rbd_dev)
dfc5606d
YS		 1851{
1852 struct rbd_snap *snap;
a0593290 1853 struct rbd_snap *next;
dfc5606d 1854
a0593290 1855 list_for_each_entry_safe(snap, next, &rbd_dev->snaps, node)
41f38c2b 1856 rbd_remove_snap_dev(snap);
dfc5606d
YS		 1857}
1858
9478554a
AE		 1859static void rbd_update_mapping_size(struct rbd_device *rbd_dev)
1860{
1861 sector_t size;
1862
0d7dbfce 1863 if (rbd_dev->spec->snap_id != CEPH_NOSNAP)
9478554a
AE		 1864 return;
1865
1866 size = (sector_t) rbd_dev->header.image_size / SECTOR_SIZE;
1867 dout("setting size to %llu sectors", (unsigned long long) size);
1868 rbd_dev->mapping.size = (u64) size;
1869 set_capacity(rbd_dev->disk, size);
1870}
1871
602adf40
YS		 1872/*
1873 * only read the first part of the ondisk header, without the snaps info
1874 */
117973fb 1875static int rbd_dev_v1_refresh(struct rbd_device *rbd_dev, u64 *hver)
602adf40
YS		 1876{
1877 int ret;
1878 struct rbd_image_header h;
602adf40
YS		 1879
1880 ret = rbd_read_header(rbd_dev, &h);
1881 if (ret < 0)
1882 return ret;
1883
a51aa0c0
JD		 1884 down_write(&rbd_dev->header_rwsem);
1885
9478554a
AE		 1886 /* Update image size, and check for resize of mapped image */
1887 rbd_dev->header.image_size = h.image_size;
1888 rbd_update_mapping_size(rbd_dev);
9db4b3e3 1889
849b4260 1890 /* rbd_dev->header.object_prefix shouldn't change */
602adf40 1891 kfree(rbd_dev->header.snap_sizes);
849b4260 1892 kfree(rbd_dev->header.snap_names);
d1d25646
JD		 1893 /* osd requests may still refer to snapc */
1894 ceph_put_snap_context(rbd_dev->header.snapc);
602adf40 1895
b813623a
AE		 1896 if (hver)
1897 *hver = h.obj_version;
a71b891b 1898 rbd_dev->header.obj_version = h.obj_version;
93a24e08 1899 rbd_dev->header.image_size = h.image_size;
602adf40
YS		 1900 rbd_dev->header.snapc = h.snapc;
1901 rbd_dev->header.snap_names = h.snap_names;
1902 rbd_dev->header.snap_sizes = h.snap_sizes;
849b4260
AE		 1903 /* Free the extra copy of the object prefix */
1904 WARN_ON(strcmp(rbd_dev->header.object_prefix, h.object_prefix));
1905 kfree(h.object_prefix);
1906
304f6808
AE		 1907 ret = rbd_dev_snaps_update(rbd_dev);
1908 if (!ret)
1909 ret = rbd_dev_snaps_register(rbd_dev);
dfc5606d 1910
c666601a 1911 up_write(&rbd_dev->header_rwsem);
602adf40 1912
dfc5606d 1913 return ret;
602adf40
YS		 1914}
1915
117973fb 1916static int rbd_dev_refresh(struct rbd_device *rbd_dev, u64 *hver)
1fe5e993
AE		 1917{
1918 int ret;
1919
117973fb 1920 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
1fe5e993 1921 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
117973fb
AE		 1922 if (rbd_dev->image_format == 1)
1923 ret = rbd_dev_v1_refresh(rbd_dev, hver);
1924 else
1925 ret = rbd_dev_v2_refresh(rbd_dev, hver);
1fe5e993
AE		 1926 mutex_unlock(&ctl_mutex);
1927
1928 return ret;
1929}
1930
602adf40
YS		 1931static int rbd_init_disk(struct rbd_device *rbd_dev)
1932{
1933 struct gendisk *disk;
1934 struct request_queue *q;
593a9e7b 1935 u64 segment_size;
602adf40 1936
602adf40 1937 /* create gendisk info */
602adf40
YS		 1938 disk = alloc_disk(RBD_MINORS_PER_MAJOR);
1939 if (!disk)
1fcdb8aa 1940 return -ENOMEM;
602adf40 1941
f0f8cef5 1942 snprintf(disk->disk_name, sizeof(disk->disk_name), RBD_DRV_NAME "%d",
de71a297 1943 rbd_dev->dev_id);
602adf40
YS		 1944 disk->major = rbd_dev->major;
1945 disk->first_minor = 0;
1946 disk->fops = &rbd_bd_ops;
1947 disk->private_data = rbd_dev;
1948
1949 /* init rq */
602adf40
YS		 1950 q = blk_init_queue(rbd_rq_fn, &rbd_dev->lock);
1951 if (!q)
1952 goto out_disk;
029bcbd8 1953
593a9e7b
AE		 1954 /* We use the default size, but let's be explicit about it. */
1955 blk_queue_physical_block_size(q, SECTOR_SIZE);
1956
029bcbd8 1957 /* set io sizes to object size */
593a9e7b
AE		 1958 segment_size = rbd_obj_bytes(&rbd_dev->header);
1959 blk_queue_max_hw_sectors(q, segment_size / SECTOR_SIZE);
1960 blk_queue_max_segment_size(q, segment_size);
1961 blk_queue_io_min(q, segment_size);
1962 blk_queue_io_opt(q, segment_size);
029bcbd8 1963
602adf40
YS		 1964 blk_queue_merge_bvec(q, rbd_merge_bvec);
1965 disk->queue = q;
1966
1967 q->queuedata = rbd_dev;
1968
1969 rbd_dev->disk = disk;
602adf40 1970
12f02944
AE		 1971 set_capacity(rbd_dev->disk, rbd_dev->mapping.size / SECTOR_SIZE);
1972
602adf40 1973 return 0;
602adf40
YS		 1974out_disk:
1975 put_disk(disk);
1fcdb8aa
AE		 1976
1977 return -ENOMEM;
602adf40
YS		 1978}
1979
dfc5606d
YS		 1980/*
1981 sysfs
1982*/
1983
593a9e7b
AE		 1984static struct rbd_device *dev_to_rbd_dev(struct device *dev)
1985{
1986 return container_of(dev, struct rbd_device, dev);
1987}
1988
dfc5606d
YS		 1989static ssize_t rbd_size_show(struct device *dev,
1990 struct device_attribute *attr, char *buf)
1991{
593a9e7b 1992 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
a51aa0c0
JD		 1993 sector_t size;
1994
1995 down_read(&rbd_dev->header_rwsem);
1996 size = get_capacity(rbd_dev->disk);
1997 up_read(&rbd_dev->header_rwsem);
dfc5606d 1998
a51aa0c0 1999 return sprintf(buf, "%llu\n", (unsigned long long) size * SECTOR_SIZE);
dfc5606d
YS		 2000}
2001
34b13184
AE		 2002/*
2003 * Note this shows the features for whatever's mapped, which is not
2004 * necessarily the base image.
2005 */
2006static ssize_t rbd_features_show(struct device *dev,
2007 struct device_attribute *attr, char *buf)
2008{
2009 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2010
2011 return sprintf(buf, "0x%016llx\n",
2012 (unsigned long long) rbd_dev->mapping.features);
2013}
2014
dfc5606d
YS		 2015static ssize_t rbd_major_show(struct device *dev,
2016 struct device_attribute *attr, char *buf)
2017{
593a9e7b 2018 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
602adf40 2019
dfc5606d
YS		 2020 return sprintf(buf, "%d\n", rbd_dev->major);
2021}
2022
2023static ssize_t rbd_client_id_show(struct device *dev,
2024 struct device_attribute *attr, char *buf)
602adf40 2025{
593a9e7b 2026 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
dfc5606d 2027
1dbb4399
AE		 2028 return sprintf(buf, "client%lld\n",
2029 ceph_client_id(rbd_dev->rbd_client->client));
602adf40
YS		 2030}
2031
dfc5606d
YS		 2032static ssize_t rbd_pool_show(struct device *dev,
2033 struct device_attribute *attr, char *buf)
602adf40 2034{
593a9e7b 2035 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
dfc5606d 2036
0d7dbfce 2037 return sprintf(buf, "%s\n", rbd_dev->spec->pool_name);
dfc5606d
YS		 2038}
2039
9bb2f334
AE		 2040static ssize_t rbd_pool_id_show(struct device *dev,
2041 struct device_attribute *attr, char *buf)
2042{
2043 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2044
0d7dbfce
AE		 2045 return sprintf(buf, "%llu\n",
2046 (unsigned long long) rbd_dev->spec->pool_id);
9bb2f334
AE		 2047}
2048
dfc5606d
YS		 2049static ssize_t rbd_name_show(struct device *dev,
2050 struct device_attribute *attr, char *buf)
2051{
593a9e7b 2052 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
dfc5606d 2053
a92ffdf8
AE		 2054 if (rbd_dev->spec->image_name)
2055 return sprintf(buf, "%s\n", rbd_dev->spec->image_name);
2056
2057 return sprintf(buf, "(unknown)\n");
dfc5606d
YS		 2058}
2059
589d30e0
AE		 2060static ssize_t rbd_image_id_show(struct device *dev,
2061 struct device_attribute *attr, char *buf)
2062{
2063 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2064
0d7dbfce 2065 return sprintf(buf, "%s\n", rbd_dev->spec->image_id);
589d30e0
AE		 2066}
2067
34b13184
AE		 2068/*
2069 * Shows the name of the currently-mapped snapshot (or
2070 * RBD_SNAP_HEAD_NAME for the base image).
2071 */
dfc5606d
YS		 2072static ssize_t rbd_snap_show(struct device *dev,
2073 struct device_attribute *attr,
2074 char *buf)
2075{
593a9e7b 2076 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
dfc5606d 2077
0d7dbfce 2078 return sprintf(buf, "%s\n", rbd_dev->spec->snap_name);
dfc5606d
YS		 2079}
2080
86b00e0d
AE		 2081/*
2082 * For an rbd v2 image, shows the pool id, image id, and snapshot id
2083 * for the parent image. If there is no parent, simply shows
2084 * "(no parent image)".
2085 */
2086static ssize_t rbd_parent_show(struct device *dev,
2087 struct device_attribute *attr,
2088 char *buf)
2089{
2090 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2091 struct rbd_spec *spec = rbd_dev->parent_spec;
2092 int count;
2093 char *bufp = buf;
2094
2095 if (!spec)
2096 return sprintf(buf, "(no parent image)\n");
2097
2098 count = sprintf(bufp, "pool_id %llu\npool_name %s\n",
2099 (unsigned long long) spec->pool_id, spec->pool_name);
2100 if (count < 0)
2101 return count;
2102 bufp += count;
2103
2104 count = sprintf(bufp, "image_id %s\nimage_name %s\n", spec->image_id,
2105 spec->image_name ? spec->image_name : "(unknown)");
2106 if (count < 0)
2107 return count;
2108 bufp += count;
2109
2110 count = sprintf(bufp, "snap_id %llu\nsnap_name %s\n",
2111 (unsigned long long) spec->snap_id, spec->snap_name);
2112 if (count < 0)
2113 return count;
2114 bufp += count;
2115
2116 count = sprintf(bufp, "overlap %llu\n", rbd_dev->parent_overlap);
2117 if (count < 0)
2118 return count;
2119 bufp += count;
2120
2121 return (ssize_t) (bufp - buf);
2122}
2123
dfc5606d
YS		 2124static ssize_t rbd_image_refresh(struct device *dev,
2125 struct device_attribute *attr,
2126 const char *buf,
2127 size_t size)
2128{
593a9e7b 2129 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
b813623a 2130 int ret;
602adf40 2131
117973fb 2132 ret = rbd_dev_refresh(rbd_dev, NULL);
b813623a
AE		 2133
2134 return ret < 0 ? ret : size;
dfc5606d 2135}
602adf40 2136
dfc5606d 2137static DEVICE_ATTR(size, S_IRUGO, rbd_size_show, NULL);
34b13184 2138static DEVICE_ATTR(features, S_IRUGO, rbd_features_show, NULL);
dfc5606d
YS		 2139static DEVICE_ATTR(major, S_IRUGO, rbd_major_show, NULL);
2140static DEVICE_ATTR(client_id, S_IRUGO, rbd_client_id_show, NULL);
2141static DEVICE_ATTR(pool, S_IRUGO, rbd_pool_show, NULL);
9bb2f334 2142static DEVICE_ATTR(pool_id, S_IRUGO, rbd_pool_id_show, NULL);
dfc5606d 2143static DEVICE_ATTR(name, S_IRUGO, rbd_name_show, NULL);
589d30e0 2144static DEVICE_ATTR(image_id, S_IRUGO, rbd_image_id_show, NULL);
dfc5606d
YS		 2145static DEVICE_ATTR(refresh, S_IWUSR, NULL, rbd_image_refresh);
2146static DEVICE_ATTR(current_snap, S_IRUGO, rbd_snap_show, NULL);
86b00e0d 2147static DEVICE_ATTR(parent, S_IRUGO, rbd_parent_show, NULL);
dfc5606d
YS		 2148
2149static struct attribute *rbd_attrs[] = {
2150 &dev_attr_size.attr,
34b13184 2151 &dev_attr_features.attr,
dfc5606d
YS		 2152 &dev_attr_major.attr,
2153 &dev_attr_client_id.attr,
2154 &dev_attr_pool.attr,
9bb2f334 2155 &dev_attr_pool_id.attr,
dfc5606d 2156 &dev_attr_name.attr,
589d30e0 2157 &dev_attr_image_id.attr,
dfc5606d 2158 &dev_attr_current_snap.attr,
86b00e0d 2159 &dev_attr_parent.attr,
dfc5606d 2160 &dev_attr_refresh.attr,
dfc5606d
YS		 2161 NULL
2162};
2163
2164static struct attribute_group rbd_attr_group = {
2165 .attrs = rbd_attrs,
2166};
2167
2168static const struct attribute_group *rbd_attr_groups[] = {
2169 &rbd_attr_group,
2170 NULL
2171};
2172
2173static void rbd_sysfs_dev_release(struct device *dev)
2174{
2175}
2176
2177static struct device_type rbd_device_type = {
2178 .name = "rbd",
2179 .groups = rbd_attr_groups,
2180 .release = rbd_sysfs_dev_release,
2181};
2182
2183
2184/*
2185 sysfs - snapshots
2186*/
2187
2188static ssize_t rbd_snap_size_show(struct device *dev,
2189 struct device_attribute *attr,
2190 char *buf)
2191{
2192 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2193
3591538f 2194 return sprintf(buf, "%llu\n", (unsigned long long)snap->size);
dfc5606d
YS		 2195}
2196
2197static ssize_t rbd_snap_id_show(struct device *dev,
2198 struct device_attribute *attr,
2199 char *buf)
2200{
2201 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2202
3591538f 2203 return sprintf(buf, "%llu\n", (unsigned long long)snap->id);
dfc5606d
YS		 2204}
2205
34b13184
AE		 2206static ssize_t rbd_snap_features_show(struct device *dev,
2207 struct device_attribute *attr,
2208 char *buf)
2209{
2210 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2211
2212 return sprintf(buf, "0x%016llx\n",
2213 (unsigned long long) snap->features);
2214}
2215
dfc5606d
YS		 2216static DEVICE_ATTR(snap_size, S_IRUGO, rbd_snap_size_show, NULL);
2217static DEVICE_ATTR(snap_id, S_IRUGO, rbd_snap_id_show, NULL);
34b13184 2218static DEVICE_ATTR(snap_features, S_IRUGO, rbd_snap_features_show, NULL);
dfc5606d
YS		 2219
2220static struct attribute *rbd_snap_attrs[] = {
2221 &dev_attr_snap_size.attr,
2222 &dev_attr_snap_id.attr,
34b13184 2223 &dev_attr_snap_features.attr,
dfc5606d
YS		 2224 NULL,
2225};
2226
2227static struct attribute_group rbd_snap_attr_group = {
2228 .attrs = rbd_snap_attrs,
2229};
2230
2231static void rbd_snap_dev_release(struct device *dev)
2232{
2233 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2234 kfree(snap->name);
2235 kfree(snap);
2236}
2237
2238static const struct attribute_group *rbd_snap_attr_groups[] = {
2239 &rbd_snap_attr_group,
2240 NULL
2241};
2242
2243static struct device_type rbd_snap_device_type = {
2244 .groups = rbd_snap_attr_groups,
2245 .release = rbd_snap_dev_release,
2246};
2247
8b8fb99c
AE		 2248static struct rbd_spec *rbd_spec_get(struct rbd_spec *spec)
2249{
2250 kref_get(&spec->kref);
2251
2252 return spec;
2253}
2254
2255static void rbd_spec_free(struct kref *kref);
2256static void rbd_spec_put(struct rbd_spec *spec)
2257{
2258 if (spec)
2259 kref_put(&spec->kref, rbd_spec_free);
2260}
2261
2262static struct rbd_spec *rbd_spec_alloc(void)
2263{
2264 struct rbd_spec *spec;
2265
2266 spec = kzalloc(sizeof (*spec), GFP_KERNEL);
2267 if (!spec)
2268 return NULL;
2269 kref_init(&spec->kref);
2270
2271 rbd_spec_put(rbd_spec_get(spec)); /* TEMPORARY */
2272
2273 return spec;
2274}
2275
2276static void rbd_spec_free(struct kref *kref)
2277{
2278 struct rbd_spec *spec = container_of(kref, struct rbd_spec, kref);
2279
2280 kfree(spec->pool_name);
2281 kfree(spec->image_id);
2282 kfree(spec->image_name);
2283 kfree(spec->snap_name);
2284 kfree(spec);
2285}
2286
c53d5893
AE		 2287struct rbd_device *rbd_dev_create(struct rbd_client *rbdc,
2288 struct rbd_spec *spec)
2289{
2290 struct rbd_device *rbd_dev;
2291
2292 rbd_dev = kzalloc(sizeof (*rbd_dev), GFP_KERNEL);
2293 if (!rbd_dev)
2294 return NULL;
2295
2296 spin_lock_init(&rbd_dev->lock);
2297 INIT_LIST_HEAD(&rbd_dev->node);
2298 INIT_LIST_HEAD(&rbd_dev->snaps);
2299 init_rwsem(&rbd_dev->header_rwsem);
2300
2301 rbd_dev->spec = spec;
2302 rbd_dev->rbd_client = rbdc;
2303
2304 return rbd_dev;
2305}
2306
2307static void rbd_dev_destroy(struct rbd_device *rbd_dev)
2308{
86b00e0d 2309 rbd_spec_put(rbd_dev->parent_spec);
c53d5893
AE		 2310 kfree(rbd_dev->header_name);
2311 rbd_put_client(rbd_dev->rbd_client);
2312 rbd_spec_put(rbd_dev->spec);
2313 kfree(rbd_dev);
2314}
2315
304f6808
AE		 2316static bool rbd_snap_registered(struct rbd_snap *snap)
2317{
2318 bool ret = snap->dev.type == &rbd_snap_device_type;
2319 bool reg = device_is_registered(&snap->dev);
2320
2321 rbd_assert(!ret ^ reg);
2322
2323 return ret;
2324}
2325
41f38c2b 2326static void rbd_remove_snap_dev(struct rbd_snap *snap)
dfc5606d
YS		 2327{
2328 list_del(&snap->node);
304f6808
AE		 2329 if (device_is_registered(&snap->dev))
2330 device_unregister(&snap->dev);
dfc5606d
YS		 2331}
2332
14e7085d 2333static int rbd_register_snap_dev(struct rbd_snap *snap,
dfc5606d
YS		 2334 struct device *parent)
2335{
2336 struct device *dev = &snap->dev;
2337 int ret;
2338
2339 dev->type = &rbd_snap_device_type;
2340 dev->parent = parent;
2341 dev->release = rbd_snap_dev_release;
d4b125e9 2342 dev_set_name(dev, "%s%s", RBD_SNAP_DEV_NAME_PREFIX, snap->name);
304f6808
AE		 2343 dout("%s: registering device for snapshot %s\n", __func__, snap->name);
2344
dfc5606d
YS		 2345 ret = device_register(dev);
2346
2347 return ret;
2348}
2349
4e891e0a 2350static struct rbd_snap *__rbd_add_snap_dev(struct rbd_device *rbd_dev,
c8d18425 2351 const char *snap_name,
34b13184
AE		 2352 u64 snap_id, u64 snap_size,
2353 u64 snap_features)
dfc5606d 2354{
4e891e0a 2355 struct rbd_snap *snap;
dfc5606d 2356 int ret;
4e891e0a
AE		 2357
2358 snap = kzalloc(sizeof (*snap), GFP_KERNEL);
dfc5606d 2359 if (!snap)
4e891e0a
AE		 2360 return ERR_PTR(-ENOMEM);
2361
2362 ret = -ENOMEM;
c8d18425 2363 snap->name = kstrdup(snap_name, GFP_KERNEL);
4e891e0a
AE		 2364 if (!snap->name)
2365 goto err;
2366
c8d18425
AE		 2367 snap->id = snap_id;
2368 snap->size = snap_size;
34b13184 2369 snap->features = snap_features;
4e891e0a
AE		 2370
2371 return snap;
2372
dfc5606d
YS		 2373err:
2374 kfree(snap->name);
2375 kfree(snap);
4e891e0a
AE		 2376
2377 return ERR_PTR(ret);
dfc5606d
YS		 2378}
2379
cd892126
AE		 2380static char *rbd_dev_v1_snap_info(struct rbd_device *rbd_dev, u32 which,
2381 u64 *snap_size, u64 *snap_features)
2382{
2383 char *snap_name;
2384
2385 rbd_assert(which < rbd_dev->header.snapc->num_snaps);
2386
2387 *snap_size = rbd_dev->header.snap_sizes[which];
2388 *snap_features = 0; /* No features for v1 */
2389
2390 /* Skip over names until we find the one we are looking for */
2391
2392 snap_name = rbd_dev->header.snap_names;
2393 while (which--)
2394 snap_name += strlen(snap_name) + 1;
2395
2396 return snap_name;
2397}
2398
9d475de5
AE		 2399/*
2400 * Get the size and object order for an image snapshot, or if
2401 * snap_id is CEPH_NOSNAP, gets this information for the base
2402 * image.
2403 */
2404static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
2405 u8 *order, u64 *snap_size)
2406{
2407 __le64 snapid = cpu_to_le64(snap_id);
2408 int ret;
2409 struct {
2410 u8 order;
2411 __le64 size;
2412 } __attribute__ ((packed)) size_buf = { 0 };
2413
2414 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2415 "rbd", "get_size",
2416 (char *) &snapid, sizeof (snapid),
2417 (char *) &size_buf, sizeof (size_buf),
2418 CEPH_OSD_FLAG_READ, NULL);
2419 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2420 if (ret < 0)
2421 return ret;
2422
2423 *order = size_buf.order;
2424 *snap_size = le64_to_cpu(size_buf.size);
2425
2426 dout(" snap_id 0x%016llx order = %u, snap_size = %llu\n",
2427 (unsigned long long) snap_id, (unsigned int) *order,
2428 (unsigned long long) *snap_size);
2429
2430 return 0;
2431}
2432
2433static int rbd_dev_v2_image_size(struct rbd_device *rbd_dev)
2434{
2435 return _rbd_dev_v2_snap_size(rbd_dev, CEPH_NOSNAP,
2436 &rbd_dev->header.obj_order,
2437 &rbd_dev->header.image_size);
2438}
2439
1e130199
AE		 2440static int rbd_dev_v2_object_prefix(struct rbd_device *rbd_dev)
2441{
2442 void *reply_buf;
2443 int ret;
2444 void *p;
2445
2446 reply_buf = kzalloc(RBD_OBJ_PREFIX_LEN_MAX, GFP_KERNEL);
2447 if (!reply_buf)
2448 return -ENOMEM;
2449
2450 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2451 "rbd", "get_object_prefix",
2452 NULL, 0,
2453 reply_buf, RBD_OBJ_PREFIX_LEN_MAX,
2454 CEPH_OSD_FLAG_READ, NULL);
2455 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2456 if (ret < 0)
2457 goto out;
a0ea3a40 2458 ret = 0; /* rbd_req_sync_exec() can return positive */
1e130199
AE		 2459
2460 p = reply_buf;
2461 rbd_dev->header.object_prefix = ceph_extract_encoded_string(&p,
2462 p + RBD_OBJ_PREFIX_LEN_MAX,
2463 NULL, GFP_NOIO);
2464
2465 if (IS_ERR(rbd_dev->header.object_prefix)) {
2466 ret = PTR_ERR(rbd_dev->header.object_prefix);
2467 rbd_dev->header.object_prefix = NULL;
2468 } else {
2469 dout(" object_prefix = %s\n", rbd_dev->header.object_prefix);
2470 }
2471
2472out:
2473 kfree(reply_buf);
2474
2475 return ret;
2476}
2477
b1b5402a
AE		 2478static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
2479 u64 *snap_features)
2480{
2481 __le64 snapid = cpu_to_le64(snap_id);
2482 struct {
2483 __le64 features;
2484 __le64 incompat;
2485 } features_buf = { 0 };
d889140c 2486 u64 incompat;
b1b5402a
AE		 2487 int ret;
2488
2489 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2490 "rbd", "get_features",
2491 (char *) &snapid, sizeof (snapid),
2492 (char *) &features_buf, sizeof (features_buf),
2493 CEPH_OSD_FLAG_READ, NULL);
2494 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2495 if (ret < 0)
2496 return ret;
d889140c
AE		 2497
2498 incompat = le64_to_cpu(features_buf.incompat);
2499 if (incompat & ~RBD_FEATURES_ALL)
b8f5c6ed 2500 return -ENXIO;
d889140c 2501
b1b5402a
AE		 2502 *snap_features = le64_to_cpu(features_buf.features);
2503
2504 dout(" snap_id 0x%016llx features = 0x%016llx incompat = 0x%016llx\n",
2505 (unsigned long long) snap_id,
2506 (unsigned long long) *snap_features,
2507 (unsigned long long) le64_to_cpu(features_buf.incompat));
2508
2509 return 0;
2510}
2511
2512static int rbd_dev_v2_features(struct rbd_device *rbd_dev)
2513{
2514 return _rbd_dev_v2_snap_features(rbd_dev, CEPH_NOSNAP,
2515 &rbd_dev->header.features);
2516}
2517
86b00e0d
AE		 2518static int rbd_dev_v2_parent_info(struct rbd_device *rbd_dev)
2519{
2520 struct rbd_spec *parent_spec;
2521 size_t size;
2522 void *reply_buf = NULL;
2523 __le64 snapid;
2524 void *p;
2525 void *end;
2526 char *image_id;
2527 u64 overlap;
86b00e0d
AE		 2528 int ret;
2529
2530 parent_spec = rbd_spec_alloc();
2531 if (!parent_spec)
2532 return -ENOMEM;
2533
2534 size = sizeof (__le64) + /* pool_id */
2535 sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX + /* image_id */
2536 sizeof (__le64) + /* snap_id */
2537 sizeof (__le64); /* overlap */
2538 reply_buf = kmalloc(size, GFP_KERNEL);
2539 if (!reply_buf) {
2540 ret = -ENOMEM;
2541 goto out_err;
2542 }
2543
2544 snapid = cpu_to_le64(CEPH_NOSNAP);
2545 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2546 "rbd", "get_parent",
2547 (char *) &snapid, sizeof (snapid),
2548 (char *) reply_buf, size,
2549 CEPH_OSD_FLAG_READ, NULL);
2550 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2551 if (ret < 0)
2552 goto out_err;
2553
2554 ret = -ERANGE;
2555 p = reply_buf;
2556 end = (char *) reply_buf + size;
2557 ceph_decode_64_safe(&p, end, parent_spec->pool_id, out_err);
2558 if (parent_spec->pool_id == CEPH_NOPOOL)
2559 goto out; /* No parent? No problem. */
2560
979ed480 2561 image_id = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
86b00e0d
AE		 2562 if (IS_ERR(image_id)) {
2563 ret = PTR_ERR(image_id);
2564 goto out_err;
2565 }
2566 parent_spec->image_id = image_id;
2567 ceph_decode_64_safe(&p, end, parent_spec->snap_id, out_err);
2568 ceph_decode_64_safe(&p, end, overlap, out_err);
2569
2570 rbd_dev->parent_overlap = overlap;
2571 rbd_dev->parent_spec = parent_spec;
2572 parent_spec = NULL; /* rbd_dev now owns this */
2573out:
2574 ret = 0;
2575out_err:
2576 kfree(reply_buf);
2577 rbd_spec_put(parent_spec);
2578
2579 return ret;
2580}
2581
9e15b77d
AE		 2582static char *rbd_dev_image_name(struct rbd_device *rbd_dev)
2583{
2584 size_t image_id_size;
2585 char *image_id;
2586 void *p;
2587 void *end;
2588 size_t size;
2589 void *reply_buf = NULL;
2590 size_t len = 0;
2591 char *image_name = NULL;
2592 int ret;
2593
2594 rbd_assert(!rbd_dev->spec->image_name);
2595
69e7a02f
AE		 2596 len = strlen(rbd_dev->spec->image_id);
2597 image_id_size = sizeof (__le32) + len;
9e15b77d
AE		 2598 image_id = kmalloc(image_id_size, GFP_KERNEL);
2599 if (!image_id)
2600 return NULL;
2601
2602 p = image_id;
2603 end = (char *) image_id + image_id_size;
69e7a02f 2604 ceph_encode_string(&p, end, rbd_dev->spec->image_id, (u32) len);
9e15b77d
AE		 2605
2606 size = sizeof (__le32) + RBD_IMAGE_NAME_LEN_MAX;
2607 reply_buf = kmalloc(size, GFP_KERNEL);
2608 if (!reply_buf)
2609 goto out;
2610
2611 ret = rbd_req_sync_exec(rbd_dev, RBD_DIRECTORY,
2612 "rbd", "dir_get_name",
2613 image_id, image_id_size,
2614 (char *) reply_buf, size,
2615 CEPH_OSD_FLAG_READ, NULL);
2616 if (ret < 0)
2617 goto out;
2618 p = reply_buf;
2619 end = (char *) reply_buf + size;
2620 image_name = ceph_extract_encoded_string(&p, end, &len, GFP_KERNEL);
2621 if (IS_ERR(image_name))
2622 image_name = NULL;
2623 else
2624 dout("%s: name is %s len is %zd\n", __func__, image_name, len);
2625out:
2626 kfree(reply_buf);
2627 kfree(image_id);
2628
2629 return image_name;
2630}
2631
2632/*
2633 * When a parent image gets probed, we only have the pool, image,
2634 * and snapshot ids but not the names of any of them. This call
2635 * is made later to fill in those names. It has to be done after
2636 * rbd_dev_snaps_update() has completed because some of the
2637 * information (in particular, snapshot name) is not available
2638 * until then.
2639 */
2640static int rbd_dev_probe_update_spec(struct rbd_device *rbd_dev)
2641{
2642 struct ceph_osd_client *osdc;
2643 const char *name;
2644 void *reply_buf = NULL;
2645 int ret;
2646
2647 if (rbd_dev->spec->pool_name)
2648 return 0; /* Already have the names */
2649
2650 /* Look up the pool name */
2651
2652 osdc = &rbd_dev->rbd_client->client->osdc;
2653 name = ceph_pg_pool_name_by_id(osdc->osdmap, rbd_dev->spec->pool_id);
935dc89f
AE		 2654 if (!name) {
2655 rbd_warn(rbd_dev, "there is no pool with id %llu",
2656 rbd_dev->spec->pool_id); /* Really a BUG() */
2657 return -EIO;
2658 }
9e15b77d
AE		 2659
2660 rbd_dev->spec->pool_name = kstrdup(name, GFP_KERNEL);
2661 if (!rbd_dev->spec->pool_name)
2662 return -ENOMEM;
2663
2664 /* Fetch the image name; tolerate failure here */
2665
2666 name = rbd_dev_image_name(rbd_dev);
69e7a02f 2667 if (name)
9e15b77d 2668 rbd_dev->spec->image_name = (char *) name;
69e7a02f 2669 else
06ecc6cb 2670 rbd_warn(rbd_dev, "unable to get image name");
9e15b77d
AE		 2671
2672 /* Look up the snapshot name. */
2673
2674 name = rbd_snap_name(rbd_dev, rbd_dev->spec->snap_id);
2675 if (!name) {
935dc89f
AE		 2676 rbd_warn(rbd_dev, "no snapshot with id %llu",
2677 rbd_dev->spec->snap_id); /* Really a BUG() */
9e15b77d
AE		 2678 ret = -EIO;
2679 goto out_err;
2680 }
2681 rbd_dev->spec->snap_name = kstrdup(name, GFP_KERNEL);
2682 if(!rbd_dev->spec->snap_name)
2683 goto out_err;
2684
2685 return 0;
2686out_err:
2687 kfree(reply_buf);
2688 kfree(rbd_dev->spec->pool_name);
2689 rbd_dev->spec->pool_name = NULL;
2690
2691 return ret;
2692}
2693
6e14b1a6 2694static int rbd_dev_v2_snap_context(struct rbd_device *rbd_dev, u64 *ver)
35d489f9
AE		 2695{
2696 size_t size;
2697 int ret;
2698 void *reply_buf;
2699 void *p;
2700 void *end;
2701 u64 seq;
2702 u32 snap_count;
2703 struct ceph_snap_context *snapc;
2704 u32 i;
2705
2706 /*
2707 * We'll need room for the seq value (maximum snapshot id),
2708 * snapshot count, and array of that many snapshot ids.
2709 * For now we have a fixed upper limit on the number we're
2710 * prepared to receive.
2711 */
2712 size = sizeof (__le64) + sizeof (__le32) +
2713 RBD_MAX_SNAP_COUNT * sizeof (__le64);
2714 reply_buf = kzalloc(size, GFP_KERNEL);
2715 if (!reply_buf)
2716 return -ENOMEM;
2717
2718 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2719 "rbd", "get_snapcontext",
2720 NULL, 0,
2721 reply_buf, size,
6e14b1a6 2722 CEPH_OSD_FLAG_READ, ver);
35d489f9
AE		 2723 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2724 if (ret < 0)
2725 goto out;
2726
2727 ret = -ERANGE;
2728 p = reply_buf;
2729 end = (char *) reply_buf + size;
2730 ceph_decode_64_safe(&p, end, seq, out);
2731 ceph_decode_32_safe(&p, end, snap_count, out);
2732
2733 /*
2734 * Make sure the reported number of snapshot ids wouldn't go
2735 * beyond the end of our buffer. But before checking that,
2736 * make sure the computed size of the snapshot context we
2737 * allocate is representable in a size_t.
2738 */
2739 if (snap_count > (SIZE_MAX - sizeof (struct ceph_snap_context))
2740 / sizeof (u64)) {
2741 ret = -EINVAL;
2742 goto out;
2743 }
2744 if (!ceph_has_room(&p, end, snap_count * sizeof (__le64)))
2745 goto out;
2746
2747 size = sizeof (struct ceph_snap_context) +
2748 snap_count * sizeof (snapc->snaps[0]);
2749 snapc = kmalloc(size, GFP_KERNEL);
2750 if (!snapc) {
2751 ret = -ENOMEM;
2752 goto out;
2753 }
2754
2755 atomic_set(&snapc->nref, 1);
2756 snapc->seq = seq;
2757 snapc->num_snaps = snap_count;
2758 for (i = 0; i < snap_count; i++)
2759 snapc->snaps[i] = ceph_decode_64(&p);
2760
2761 rbd_dev->header.snapc = snapc;
2762
2763 dout(" snap context seq = %llu, snap_count = %u\n",
2764 (unsigned long long) seq, (unsigned int) snap_count);
2765
2766out:
2767 kfree(reply_buf);
2768
2769 return 0;
2770}
2771
b8b1e2db
AE		 2772static char *rbd_dev_v2_snap_name(struct rbd_device *rbd_dev, u32 which)
2773{
2774 size_t size;
2775 void *reply_buf;
2776 __le64 snap_id;
2777 int ret;
2778 void *p;
2779 void *end;
b8b1e2db
AE		 2780 char *snap_name;
2781
2782 size = sizeof (__le32) + RBD_MAX_SNAP_NAME_LEN;
2783 reply_buf = kmalloc(size, GFP_KERNEL);
2784 if (!reply_buf)
2785 return ERR_PTR(-ENOMEM);
2786
2787 snap_id = cpu_to_le64(rbd_dev->header.snapc->snaps[which]);
2788 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2789 "rbd", "get_snapshot_name",
2790 (char *) &snap_id, sizeof (snap_id),
2791 reply_buf, size,
2792 CEPH_OSD_FLAG_READ, NULL);
2793 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2794 if (ret < 0)
2795 goto out;
2796
2797 p = reply_buf;
2798 end = (char *) reply_buf + size;
e5c35534 2799 snap_name = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
b8b1e2db
AE		 2800 if (IS_ERR(snap_name)) {
2801 ret = PTR_ERR(snap_name);
2802 goto out;
2803 } else {
2804 dout(" snap_id 0x%016llx snap_name = %s\n",
2805 (unsigned long long) le64_to_cpu(snap_id), snap_name);
2806 }
2807 kfree(reply_buf);
2808
2809 return snap_name;
2810out:
2811 kfree(reply_buf);
2812
2813 return ERR_PTR(ret);
2814}
2815
2816static char *rbd_dev_v2_snap_info(struct rbd_device *rbd_dev, u32 which,
2817 u64 *snap_size, u64 *snap_features)
2818{
2819 __le64 snap_id;
2820 u8 order;
2821 int ret;
2822
2823 snap_id = rbd_dev->header.snapc->snaps[which];
2824 ret = _rbd_dev_v2_snap_size(rbd_dev, snap_id, &order, snap_size);
2825 if (ret)
2826 return ERR_PTR(ret);
2827 ret = _rbd_dev_v2_snap_features(rbd_dev, snap_id, snap_features);
2828 if (ret)
2829 return ERR_PTR(ret);
2830
2831 return rbd_dev_v2_snap_name(rbd_dev, which);
2832}
2833
2834static char *rbd_dev_snap_info(struct rbd_device *rbd_dev, u32 which,
2835 u64 *snap_size, u64 *snap_features)
2836{
2837 if (rbd_dev->image_format == 1)
2838 return rbd_dev_v1_snap_info(rbd_dev, which,
2839 snap_size, snap_features);
2840 if (rbd_dev->image_format == 2)
2841 return rbd_dev_v2_snap_info(rbd_dev, which,
2842 snap_size, snap_features);
2843 return ERR_PTR(-EINVAL);
2844}
2845
117973fb
AE		 2846static int rbd_dev_v2_refresh(struct rbd_device *rbd_dev, u64 *hver)
2847{
2848 int ret;
2849 __u8 obj_order;
2850
2851 down_write(&rbd_dev->header_rwsem);
2852
2853 /* Grab old order first, to see if it changes */
2854
2855 obj_order = rbd_dev->header.obj_order,
2856 ret = rbd_dev_v2_image_size(rbd_dev);
2857 if (ret)
2858 goto out;
2859 if (rbd_dev->header.obj_order != obj_order) {
2860 ret = -EIO;
2861 goto out;
2862 }
2863 rbd_update_mapping_size(rbd_dev);
2864
2865 ret = rbd_dev_v2_snap_context(rbd_dev, hver);
2866 dout("rbd_dev_v2_snap_context returned %d\n", ret);
2867 if (ret)
2868 goto out;
2869 ret = rbd_dev_snaps_update(rbd_dev);
2870 dout("rbd_dev_snaps_update returned %d\n", ret);
2871 if (ret)
2872 goto out;
2873 ret = rbd_dev_snaps_register(rbd_dev);
2874 dout("rbd_dev_snaps_register returned %d\n", ret);
2875out:
2876 up_write(&rbd_dev->header_rwsem);
2877
2878 return ret;
2879}
2880
dfc5606d 2881/*
35938150
AE		 2882 * Scan the rbd device's current snapshot list and compare it to the
2883 * newly-received snapshot context. Remove any existing snapshots
2884 * not present in the new snapshot context. Add a new snapshot for
2885 * any snaphots in the snapshot context not in the current list.
2886 * And verify there are no changes to snapshots we already know
2887 * about.
2888 *
2889 * Assumes the snapshots in the snapshot context are sorted by
2890 * snapshot id, highest id first. (Snapshots in the rbd_dev's list
2891 * are also maintained in that order.)
dfc5606d 2892 */
304f6808 2893static int rbd_dev_snaps_update(struct rbd_device *rbd_dev)
dfc5606d 2894{
35938150
AE		 2895 struct ceph_snap_context *snapc = rbd_dev->header.snapc;
2896 const u32 snap_count = snapc->num_snaps;
35938150
AE		 2897 struct list_head *head = &rbd_dev->snaps;
2898 struct list_head *links = head->next;
2899 u32 index = 0;
dfc5606d 2900
9fcbb800 2901 dout("%s: snap count is %u\n", __func__, (unsigned int) snap_count);
35938150
AE		 2902 while (index < snap_count || links != head) {
2903 u64 snap_id;
2904 struct rbd_snap *snap;
cd892126
AE		 2905 char *snap_name;
2906 u64 snap_size = 0;
2907 u64 snap_features = 0;
dfc5606d 2908
35938150
AE		 2909 snap_id = index < snap_count ? snapc->snaps[index]
2910 : CEPH_NOSNAP;
2911 snap = links != head ? list_entry(links, struct rbd_snap, node)
2912 : NULL;
aafb230e 2913 rbd_assert(!snap || snap->id != CEPH_NOSNAP);
dfc5606d 2914
35938150
AE		 2915 if (snap_id == CEPH_NOSNAP || (snap && snap->id > snap_id)) {
2916 struct list_head *next = links->next;
dfc5606d 2917
35938150 2918 /* Existing snapshot not in the new snap context */
dfc5606d 2919
0d7dbfce 2920 if (rbd_dev->spec->snap_id == snap->id)
daba5fdb 2921 rbd_dev->exists = false;
41f38c2b 2922 rbd_remove_snap_dev(snap);
9fcbb800 2923 dout("%ssnap id %llu has been removed\n",
0d7dbfce
AE		 2924 rbd_dev->spec->snap_id == snap->id ?
2925 "mapped " : "",
9fcbb800 2926 (unsigned long long) snap->id);
35938150
AE		 2927
2928 /* Done with this list entry; advance */
2929
2930 links = next;
dfc5606d
YS		 2931 continue;
2932 }
35938150 2933
b8b1e2db
AE		 2934 snap_name = rbd_dev_snap_info(rbd_dev, index,
2935 &snap_size, &snap_features);
cd892126
AE		 2936 if (IS_ERR(snap_name))
2937 return PTR_ERR(snap_name);
2938
9fcbb800
AE		 2939 dout("entry %u: snap_id = %llu\n", (unsigned int) snap_count,
2940 (unsigned long long) snap_id);
35938150
AE		 2941 if (!snap || (snap_id != CEPH_NOSNAP && snap->id < snap_id)) {
2942 struct rbd_snap *new_snap;
2943
2944 /* We haven't seen this snapshot before */
2945
c8d18425 2946 new_snap = __rbd_add_snap_dev(rbd_dev, snap_name,
cd892126 2947 snap_id, snap_size, snap_features);
9fcbb800
AE		 2948 if (IS_ERR(new_snap)) {
2949 int err = PTR_ERR(new_snap);
2950
2951 dout(" failed to add dev, error %d\n", err);
2952
2953 return err;
2954 }
35938150
AE		 2955
2956 /* New goes before existing, or at end of list */
2957
9fcbb800 2958 dout(" added dev%s\n", snap ? "" : " at end\n");
35938150
AE		 2959 if (snap)
2960 list_add_tail(&new_snap->node, &snap->node);
2961 else
523f3258 2962 list_add_tail(&new_snap->node, head);
35938150
AE		 2963 } else {
2964 /* Already have this one */
2965
9fcbb800
AE		 2966 dout(" already present\n");
2967
cd892126 2968 rbd_assert(snap->size == snap_size);
aafb230e 2969 rbd_assert(!strcmp(snap->name, snap_name));
cd892126 2970 rbd_assert(snap->features == snap_features);
35938150
AE		 2971
2972 /* Done with this list entry; advance */
2973
2974 links = links->next;
dfc5606d 2975 }
35938150
AE		 2976
2977 /* Advance to the next entry in the snapshot context */
2978
2979 index++;
dfc5606d 2980 }
9fcbb800 2981 dout("%s: done\n", __func__);
dfc5606d
YS		 2982
2983 return 0;
2984}
2985
304f6808
AE		 2986/*
2987 * Scan the list of snapshots and register the devices for any that
2988 * have not already been registered.
2989 */
2990static int rbd_dev_snaps_register(struct rbd_device *rbd_dev)
2991{
2992 struct rbd_snap *snap;
2993 int ret = 0;
2994
2995 dout("%s called\n", __func__);
86ff77bb
AE		 2996 if (WARN_ON(!device_is_registered(&rbd_dev->dev)))
2997 return -EIO;
304f6808
AE		 2998
2999 list_for_each_entry(snap, &rbd_dev->snaps, node) {
3000 if (!rbd_snap_registered(snap)) {
3001 ret = rbd_register_snap_dev(snap, &rbd_dev->dev);
3002 if (ret < 0)
3003 break;
3004 }
3005 }
3006 dout("%s: returning %d\n", __func__, ret);
3007
3008 return ret;
3009}
3010
dfc5606d
YS		 3011static int rbd_bus_add_dev(struct rbd_device *rbd_dev)
3012{
dfc5606d 3013 struct device *dev;
cd789ab9 3014 int ret;
dfc5606d
YS		 3015
3016 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
dfc5606d 3017
cd789ab9 3018 dev = &rbd_dev->dev;
dfc5606d
YS		 3019 dev->bus = &rbd_bus_type;
3020 dev->type = &rbd_device_type;
3021 dev->parent = &rbd_root_dev;
3022 dev->release = rbd_dev_release;
de71a297 3023 dev_set_name(dev, "%d", rbd_dev->dev_id);
dfc5606d 3024 ret = device_register(dev);
dfc5606d 3025
dfc5606d 3026 mutex_unlock(&ctl_mutex);
cd789ab9 3027
dfc5606d 3028 return ret;
602adf40
YS		 3029}
3030
dfc5606d
YS		 3031static void rbd_bus_del_dev(struct rbd_device *rbd_dev)
3032{
3033 device_unregister(&rbd_dev->dev);
3034}
3035
59c2be1e
YS		 3036static int rbd_init_watch_dev(struct rbd_device *rbd_dev)
3037{
3038 int ret, rc;
3039
3040 do {
0e6f322d 3041 ret = rbd_req_sync_watch(rbd_dev);
59c2be1e 3042 if (ret == -ERANGE) {
117973fb 3043 rc = rbd_dev_refresh(rbd_dev, NULL);
59c2be1e
YS		 3044 if (rc < 0)
3045 return rc;
3046 }
3047 } while (ret == -ERANGE);
3048
3049 return ret;
3050}
3051
e2839308 3052static atomic64_t rbd_dev_id_max = ATOMIC64_INIT(0);
1ddbe94e
AE		 3053
3054/*
499afd5b
AE		 3055 * Get a unique rbd identifier for the given new rbd_dev, and add
3056 * the rbd_dev to the global list. The minimum rbd id is 1.
1ddbe94e 3057 */
e2839308 3058static void rbd_dev_id_get(struct rbd_device *rbd_dev)
b7f23c36 3059{
e2839308 3060 rbd_dev->dev_id = atomic64_inc_return(&rbd_dev_id_max);
499afd5b
AE		 3061
3062 spin_lock(&rbd_dev_list_lock);
3063 list_add_tail(&rbd_dev->node, &rbd_dev_list);
3064 spin_unlock(&rbd_dev_list_lock);
e2839308
AE		 3065 dout("rbd_dev %p given dev id %llu\n", rbd_dev,
3066 (unsigned long long) rbd_dev->dev_id);
1ddbe94e 3067}
b7f23c36 3068
1ddbe94e 3069/*
499afd5b
AE		 3070 * Remove an rbd_dev from the global list, and record that its
3071 * identifier is no longer in use.
1ddbe94e 3072 */
e2839308 3073static void rbd_dev_id_put(struct rbd_device *rbd_dev)
1ddbe94e 3074{
d184f6bf 3075 struct list_head *tmp;
de71a297 3076 int rbd_id = rbd_dev->dev_id;
d184f6bf
AE		 3077 int max_id;
3078
aafb230e 3079 rbd_assert(rbd_id > 0);
499afd5b 3080
e2839308
AE		 3081 dout("rbd_dev %p released dev id %llu\n", rbd_dev,
3082 (unsigned long long) rbd_dev->dev_id);
499afd5b
AE		 3083 spin_lock(&rbd_dev_list_lock);
3084 list_del_init(&rbd_dev->node);
d184f6bf
AE		 3085
3086 /*
3087 * If the id being "put" is not the current maximum, there
3088 * is nothing special we need to do.
3089 */
e2839308 3090 if (rbd_id != atomic64_read(&rbd_dev_id_max)) {
d184f6bf
AE		 3091 spin_unlock(&rbd_dev_list_lock);
3092 return;
3093 }
3094
3095 /*
3096 * We need to update the current maximum id. Search the
3097 * list to find out what it is. We're more likely to find
3098 * the maximum at the end, so search the list backward.
3099 */
3100 max_id = 0;
3101 list_for_each_prev(tmp, &rbd_dev_list) {
3102 struct rbd_device *rbd_dev;
3103
3104 rbd_dev = list_entry(tmp, struct rbd_device, node);
b213e0b1
AE		 3105 if (rbd_dev->dev_id > max_id)
3106 max_id = rbd_dev->dev_id;
d184f6bf 3107 }
499afd5b 3108 spin_unlock(&rbd_dev_list_lock);
b7f23c36 3109
1ddbe94e 3110 /*
e2839308 3111 * The max id could have been updated by rbd_dev_id_get(), in
d184f6bf
AE		 3112 * which case it now accurately reflects the new maximum.
3113 * Be careful not to overwrite the maximum value in that
3114 * case.
1ddbe94e 3115 */
e2839308
AE		 3116 atomic64_cmpxchg(&rbd_dev_id_max, rbd_id, max_id);
3117 dout(" max dev id has been reset\n");
b7f23c36
AE		 3118}
3119
e28fff26
AE		 3120/*
3121 * Skips over white space at *buf, and updates *buf to point to the
3122 * first found non-space character (if any). Returns the length of
593a9e7b
AE		 3123 * the token (string of non-white space characters) found. Note
3124 * that *buf must be terminated with '\0'.
e28fff26
AE		 3125 */
3126static inline size_t next_token(const char **buf)
3127{
3128 /*
3129 * These are the characters that produce nonzero for
3130 * isspace() in the "C" and "POSIX" locales.
3131 */
3132 const char *spaces = " \f\n\r\t\v";
3133
3134 *buf += strspn(*buf, spaces); /* Find start of token */
3135
3136 return strcspn(*buf, spaces); /* Return token length */
3137}
3138
3139/*
3140 * Finds the next token in *buf, and if the provided token buffer is
3141 * big enough, copies the found token into it. The result, if
593a9e7b
AE		 3142 * copied, is guaranteed to be terminated with '\0'. Note that *buf
3143 * must be terminated with '\0' on entry.
e28fff26
AE		 3144 *
3145 * Returns the length of the token found (not including the '\0').
3146 * Return value will be 0 if no token is found, and it will be >=
3147 * token_size if the token would not fit.
3148 *
593a9e7b 3149 * The *buf pointer will be updated to point beyond the end of the
e28fff26
AE		 3150 * found token. Note that this occurs even if the token buffer is
3151 * too small to hold it.
3152 */
3153static inline size_t copy_token(const char **buf,
3154 char *token,
3155 size_t token_size)
3156{
3157 size_t len;
3158
3159 len = next_token(buf);
3160 if (len < token_size) {
3161 memcpy(token, *buf, len);
3162 *(token + len) = '\0';
3163 }
3164 *buf += len;
3165
3166 return len;
3167}
3168
ea3352f4
AE		 3169/*
3170 * Finds the next token in *buf, dynamically allocates a buffer big
3171 * enough to hold a copy of it, and copies the token into the new
3172 * buffer. The copy is guaranteed to be terminated with '\0'. Note
3173 * that a duplicate buffer is created even for a zero-length token.
3174 *
3175 * Returns a pointer to the newly-allocated duplicate, or a null
3176 * pointer if memory for the duplicate was not available. If
3177 * the lenp argument is a non-null pointer, the length of the token
3178 * (not including the '\0') is returned in *lenp.
3179 *
3180 * If successful, the *buf pointer will be updated to point beyond
3181 * the end of the found token.
3182 *
3183 * Note: uses GFP_KERNEL for allocation.
3184 */
3185static inline char *dup_token(const char **buf, size_t *lenp)
3186{
3187 char *dup;
3188 size_t len;
3189
3190 len = next_token(buf);
4caf35f9 3191 dup = kmemdup(*buf, len + 1, GFP_KERNEL);
ea3352f4
AE		 3192 if (!dup)
3193 return NULL;
ea3352f4
AE		 3194 *(dup + len) = '\0';
3195 *buf += len;
3196
3197 if (lenp)
3198 *lenp = len;
3199
3200 return dup;
3201}
3202
a725f65e 3203/*
859c31df
AE		 3204 * Parse the options provided for an "rbd add" (i.e., rbd image
3205 * mapping) request. These arrive via a write to /sys/bus/rbd/add,
3206 * and the data written is passed here via a NUL-terminated buffer.
3207 * Returns 0 if successful or an error code otherwise.
d22f76e7 3208 *
859c31df
AE		 3209 * The information extracted from these options is recorded in
3210 * the other parameters which return dynamically-allocated
3211 * structures:
3212 * ceph_opts
3213 * The address of a pointer that will refer to a ceph options
3214 * structure. Caller must release the returned pointer using
3215 * ceph_destroy_options() when it is no longer needed.
3216 * rbd_opts
3217 * Address of an rbd options pointer. Fully initialized by
3218 * this function; caller must release with kfree().
3219 * spec
3220 * Address of an rbd image specification pointer. Fully
3221 * initialized by this function based on parsed options.
3222 * Caller must release with rbd_spec_put().
3223 *
3224 * The options passed take this form:
3225 * <mon_addrs> <options> <pool_name> <image_name> [<snap_id>]
3226 * where:
3227 * <mon_addrs>
3228 * A comma-separated list of one or more monitor addresses.
3229 * A monitor address is an ip address, optionally followed
3230 * by a port number (separated by a colon).
3231 * I.e.: ip1[:port1][,ip2[:port2]...]
3232 * <options>
3233 * A comma-separated list of ceph and/or rbd options.
3234 * <pool_name>
3235 * The name of the rados pool containing the rbd image.
3236 * <image_name>
3237 * The name of the image in that pool to map.
3238 * <snap_id>
3239 * An optional snapshot id. If provided, the mapping will
3240 * present data from the image at the time that snapshot was
3241 * created. The image head is used if no snapshot id is
3242 * provided. Snapshot mappings are always read-only.
a725f65e 3243 */
859c31df 3244static int rbd_add_parse_args(const char *buf,
dc79b113 3245 struct ceph_options **ceph_opts,
859c31df
AE		 3246 struct rbd_options **opts,
3247 struct rbd_spec **rbd_spec)
e28fff26 3248{
d22f76e7 3249 size_t len;
859c31df 3250 char *options;
0ddebc0c
AE		 3251 const char *mon_addrs;
3252 size_t mon_addrs_size;
859c31df 3253 struct rbd_spec *spec = NULL;
4e9afeba 3254 struct rbd_options *rbd_opts = NULL;
859c31df 3255 struct ceph_options *copts;
dc79b113 3256 int ret;
e28fff26
AE		 3257
3258 /* The first four tokens are required */
3259
7ef3214a 3260 len = next_token(&buf);
4fb5d671
AE		 3261 if (!len) {
3262 rbd_warn(NULL, "no monitor address(es) provided");
3263 return -EINVAL;
3264 }
0ddebc0c 3265 mon_addrs = buf;
f28e565a 3266 mon_addrs_size = len + 1;
7ef3214a 3267 buf += len;
a725f65e 3268
dc79b113 3269 ret = -EINVAL;
f28e565a
AE		 3270 options = dup_token(&buf, NULL);
3271 if (!options)
dc79b113 3272 return -ENOMEM;
4fb5d671
AE		 3273 if (!*options) {
3274 rbd_warn(NULL, "no options provided");
3275 goto out_err;
3276 }
e28fff26 3277
859c31df
AE		 3278 spec = rbd_spec_alloc();
3279 if (!spec)
f28e565a 3280 goto out_mem;
859c31df
AE		 3281
3282 spec->pool_name = dup_token(&buf, NULL);
3283 if (!spec->pool_name)
3284 goto out_mem;
4fb5d671
AE		 3285 if (!*spec->pool_name) {
3286 rbd_warn(NULL, "no pool name provided");
3287 goto out_err;
3288 }
e28fff26 3289
69e7a02f 3290 spec->image_name = dup_token(&buf, NULL);
859c31df 3291 if (!spec->image_name)
f28e565a 3292 goto out_mem;
4fb5d671
AE		 3293 if (!*spec->image_name) {
3294 rbd_warn(NULL, "no image name provided");
3295 goto out_err;
3296 }
d4b125e9 3297
f28e565a
AE		 3298 /*
3299 * Snapshot name is optional; default is to use "-"
3300 * (indicating the head/no snapshot).
3301 */
3feeb894 3302 len = next_token(&buf);
820a5f3e 3303 if (!len) {
3feeb894
AE		 3304 buf = RBD_SNAP_HEAD_NAME; /* No snapshot supplied */
3305 len = sizeof (RBD_SNAP_HEAD_NAME) - 1;
f28e565a 3306 } else if (len > RBD_MAX_SNAP_NAME_LEN) {
dc79b113 3307 ret = -ENAMETOOLONG;
f28e565a 3308 goto out_err;
849b4260 3309 }
4caf35f9 3310 spec->snap_name = kmemdup(buf, len + 1, GFP_KERNEL);
859c31df 3311 if (!spec->snap_name)
f28e565a 3312 goto out_mem;
859c31df 3313 *(spec->snap_name + len) = '\0';
e5c35534 3314
0ddebc0c 3315 /* Initialize all rbd options to the defaults */
e28fff26 3316
4e9afeba
AE		 3317 rbd_opts = kzalloc(sizeof (*rbd_opts), GFP_KERNEL);
3318 if (!rbd_opts)
3319 goto out_mem;
3320
3321 rbd_opts->read_only = RBD_READ_ONLY_DEFAULT;
d22f76e7 3322
859c31df 3323 copts = ceph_parse_options(options, mon_addrs,
0ddebc0c 3324 mon_addrs + mon_addrs_size - 1,
4e9afeba 3325 parse_rbd_opts_token, rbd_opts);
859c31df
AE		 3326 if (IS_ERR(copts)) {
3327 ret = PTR_ERR(copts);
dc79b113
AE		 3328 goto out_err;
3329 }
859c31df
AE		 3330 kfree(options);
3331
3332 *ceph_opts = copts;
4e9afeba 3333 *opts = rbd_opts;
859c31df 3334 *rbd_spec = spec;
0ddebc0c 3335
dc79b113 3336 return 0;
f28e565a 3337out_mem:
dc79b113 3338 ret = -ENOMEM;
d22f76e7 3339out_err:
859c31df
AE		 3340 kfree(rbd_opts);
3341 rbd_spec_put(spec);
f28e565a 3342 kfree(options);
d22f76e7 3343
dc79b113 3344 return ret;
a725f65e
AE		 3345}
3346
589d30e0
AE		 3347/*
3348 * An rbd format 2 image has a unique identifier, distinct from the
3349 * name given to it by the user. Internally, that identifier is
3350 * what's used to specify the names of objects related to the image.
3351 *
3352 * A special "rbd id" object is used to map an rbd image name to its
3353 * id. If that object doesn't exist, then there is no v2 rbd image
3354 * with the supplied name.
3355 *
3356 * This function will record the given rbd_dev's image_id field if
3357 * it can be determined, and in that case will return 0. If any
3358 * errors occur a negative errno will be returned and the rbd_dev's
3359 * image_id field will be unchanged (and should be NULL).
3360 */
3361static int rbd_dev_image_id(struct rbd_device *rbd_dev)
3362{
3363 int ret;
3364 size_t size;
3365 char *object_name;
3366 void *response;
3367 void *p;
3368
2c0d0a10
AE		 3369 /*
3370 * When probing a parent image, the image id is already
3371 * known (and the image name likely is not). There's no
3372 * need to fetch the image id again in this case.
3373 */
3374 if (rbd_dev->spec->image_id)
3375 return 0;
3376
589d30e0
AE		 3377 /*
3378 * First, see if the format 2 image id file exists, and if
3379 * so, get the image's persistent id from it.
3380 */
69e7a02f 3381 size = sizeof (RBD_ID_PREFIX) + strlen(rbd_dev->spec->image_name);
589d30e0
AE		 3382 object_name = kmalloc(size, GFP_NOIO);
3383 if (!object_name)
3384 return -ENOMEM;
0d7dbfce 3385 sprintf(object_name, "%s%s", RBD_ID_PREFIX, rbd_dev->spec->image_name);
589d30e0
AE		 3386 dout("rbd id object name is %s\n", object_name);
3387
3388 /* Response will be an encoded string, which includes a length */
3389
3390 size = sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX;
3391 response = kzalloc(size, GFP_NOIO);
3392 if (!response) {
3393 ret = -ENOMEM;
3394 goto out;
3395 }
3396
3397 ret = rbd_req_sync_exec(rbd_dev, object_name,
3398 "rbd", "get_id",
3399 NULL, 0,
3400 response, RBD_IMAGE_ID_LEN_MAX,
3401 CEPH_OSD_FLAG_READ, NULL);
3402 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
3403 if (ret < 0)
3404 goto out;
a0ea3a40 3405 ret = 0; /* rbd_req_sync_exec() can return positive */
589d30e0
AE		 3406
3407 p = response;
0d7dbfce 3408 rbd_dev->spec->image_id = ceph_extract_encoded_string(&p,
589d30e0 3409 p + RBD_IMAGE_ID_LEN_MAX,
979ed480 3410 NULL, GFP_NOIO);
0d7dbfce
AE		 3411 if (IS_ERR(rbd_dev->spec->image_id)) {
3412 ret = PTR_ERR(rbd_dev->spec->image_id);
3413 rbd_dev->spec->image_id = NULL;
589d30e0 3414 } else {
0d7dbfce 3415 dout("image_id is %s\n", rbd_dev->spec->image_id);
589d30e0
AE		 3416 }
3417out:
3418 kfree(response);
3419 kfree(object_name);
3420
3421 return ret;
3422}
3423
a30b71b9
AE		 3424static int rbd_dev_v1_probe(struct rbd_device *rbd_dev)
3425{
3426 int ret;
3427 size_t size;
3428
3429 /* Version 1 images have no id; empty string is used */
3430
0d7dbfce
AE		 3431 rbd_dev->spec->image_id = kstrdup("", GFP_KERNEL);
3432 if (!rbd_dev->spec->image_id)
a30b71b9 3433 return -ENOMEM;
a30b71b9
AE		 3434
3435 /* Record the header object name for this rbd image. */
3436
69e7a02f 3437 size = strlen(rbd_dev->spec->image_name) + sizeof (RBD_SUFFIX);
a30b71b9
AE		 3438 rbd_dev->header_name = kmalloc(size, GFP_KERNEL);
3439 if (!rbd_dev->header_name) {
3440 ret = -ENOMEM;
3441 goto out_err;
3442 }
0d7dbfce
AE		 3443 sprintf(rbd_dev->header_name, "%s%s",
3444 rbd_dev->spec->image_name, RBD_SUFFIX);
a30b71b9
AE		 3445
3446 /* Populate rbd image metadata */
3447
3448 ret = rbd_read_header(rbd_dev, &rbd_dev->header);
3449 if (ret < 0)
3450 goto out_err;
86b00e0d
AE		 3451
3452 /* Version 1 images have no parent (no layering) */
3453
3454 rbd_dev->parent_spec = NULL;
3455 rbd_dev->parent_overlap = 0;
3456
a30b71b9
AE		 3457 rbd_dev->image_format = 1;
3458
3459 dout("discovered version 1 image, header name is %s\n",
3460 rbd_dev->header_name);
3461
3462 return 0;
3463
3464out_err:
3465 kfree(rbd_dev->header_name);
3466 rbd_dev->header_name = NULL;
0d7dbfce
AE		 3467 kfree(rbd_dev->spec->image_id);
3468 rbd_dev->spec->image_id = NULL;
a30b71b9
AE		 3469
3470 return ret;
3471}
3472
3473static int rbd_dev_v2_probe(struct rbd_device *rbd_dev)
3474{
3475 size_t size;
9d475de5 3476 int ret;
6e14b1a6 3477 u64 ver = 0;
a30b71b9
AE		 3478
3479 /*
3480 * Image id was filled in by the caller. Record the header
3481 * object name for this rbd image.
3482 */
979ed480 3483 size = sizeof (RBD_HEADER_PREFIX) + strlen(rbd_dev->spec->image_id);
a30b71b9
AE		 3484 rbd_dev->header_name = kmalloc(size, GFP_KERNEL);
3485 if (!rbd_dev->header_name)
3486 return -ENOMEM;
3487 sprintf(rbd_dev->header_name, "%s%s",
0d7dbfce 3488 RBD_HEADER_PREFIX, rbd_dev->spec->image_id);
9d475de5
AE		 3489
3490 /* Get the size and object order for the image */
3491
3492 ret = rbd_dev_v2_image_size(rbd_dev);
1e130199
AE		 3493 if (ret < 0)
3494 goto out_err;
3495
3496 /* Get the object prefix (a.k.a. block_name) for the image */
3497
3498 ret = rbd_dev_v2_object_prefix(rbd_dev);
b1b5402a
AE		 3499 if (ret < 0)
3500 goto out_err;
3501
d889140c 3502 /* Get the and check features for the image */
b1b5402a
AE		 3503
3504 ret = rbd_dev_v2_features(rbd_dev);
9d475de5
AE		 3505 if (ret < 0)
3506 goto out_err;
35d489f9 3507
86b00e0d
AE		 3508 /* If the image supports layering, get the parent info */
3509
3510 if (rbd_dev->header.features & RBD_FEATURE_LAYERING) {
3511 ret = rbd_dev_v2_parent_info(rbd_dev);
3512 if (ret < 0)
3513 goto out_err;
3514 }
3515
6e14b1a6
AE		 3516 /* crypto and compression type aren't (yet) supported for v2 images */
3517
3518 rbd_dev->header.crypt_type = 0;
3519 rbd_dev->header.comp_type = 0;
35d489f9 3520
6e14b1a6
AE		 3521 /* Get the snapshot context, plus the header version */
3522
3523 ret = rbd_dev_v2_snap_context(rbd_dev, &ver);
35d489f9
AE		 3524 if (ret)
3525 goto out_err;
6e14b1a6
AE		 3526 rbd_dev->header.obj_version = ver;
3527
a30b71b9
AE		 3528 rbd_dev->image_format = 2;
3529
3530 dout("discovered version 2 image, header name is %s\n",
3531 rbd_dev->header_name);
3532
35152979 3533 return 0;
9d475de5 3534out_err:
86b00e0d
AE		 3535 rbd_dev->parent_overlap = 0;
3536 rbd_spec_put(rbd_dev->parent_spec);
3537 rbd_dev->parent_spec = NULL;
9d475de5
AE		 3538 kfree(rbd_dev->header_name);
3539 rbd_dev->header_name = NULL;
1e130199
AE		 3540 kfree(rbd_dev->header.object_prefix);
3541 rbd_dev->header.object_prefix = NULL;
9d475de5
AE		 3542
3543 return ret;
a30b71b9
AE		 3544}
3545
83a06263
AE		 3546static int rbd_dev_probe_finish(struct rbd_device *rbd_dev)
3547{
3548 int ret;
3549
3550 /* no need to lock here, as rbd_dev is not registered yet */
3551 ret = rbd_dev_snaps_update(rbd_dev);
3552 if (ret)
3553 return ret;
3554
9e15b77d
AE		 3555 ret = rbd_dev_probe_update_spec(rbd_dev);
3556 if (ret)
3557 goto err_out_snaps;
3558
83a06263
AE		 3559 ret = rbd_dev_set_mapping(rbd_dev);
3560 if (ret)
3561 goto err_out_snaps;
3562
3563 /* generate unique id: find highest unique id, add one */
3564 rbd_dev_id_get(rbd_dev);
3565
3566 /* Fill in the device name, now that we have its id. */
3567 BUILD_BUG_ON(DEV_NAME_LEN
3568 < sizeof (RBD_DRV_NAME) + MAX_INT_FORMAT_WIDTH);
3569 sprintf(rbd_dev->name, "%s%d", RBD_DRV_NAME, rbd_dev->dev_id);
3570
3571 /* Get our block major device number. */
3572
3573 ret = register_blkdev(0, rbd_dev->name);
3574 if (ret < 0)
3575 goto err_out_id;
3576 rbd_dev->major = ret;
3577
3578 /* Set up the blkdev mapping. */
3579
3580 ret = rbd_init_disk(rbd_dev);
3581 if (ret)
3582 goto err_out_blkdev;
3583
3584 ret = rbd_bus_add_dev(rbd_dev);
3585 if (ret)
3586 goto err_out_disk;
3587
3588 /*
3589 * At this point cleanup in the event of an error is the job
3590 * of the sysfs code (initiated by rbd_bus_del_dev()).
3591 */
3592 down_write(&rbd_dev->header_rwsem);
3593 ret = rbd_dev_snaps_register(rbd_dev);
3594 up_write(&rbd_dev->header_rwsem);
3595 if (ret)
3596 goto err_out_bus;
3597
3598 ret = rbd_init_watch_dev(rbd_dev);
3599 if (ret)
3600 goto err_out_bus;
3601
3602 /* Everything's ready. Announce the disk to the world. */
3603
3604 add_disk(rbd_dev->disk);
3605
3606 pr_info("%s: added with size 0x%llx\n", rbd_dev->disk->disk_name,
3607 (unsigned long long) rbd_dev->mapping.size);
3608
3609 return ret;
3610err_out_bus:
3611 /* this will also clean up rest of rbd_dev stuff */
3612
3613 rbd_bus_del_dev(rbd_dev);
3614
3615 return ret;
3616err_out_disk:
3617 rbd_free_disk(rbd_dev);
3618err_out_blkdev:
3619 unregister_blkdev(rbd_dev->major, rbd_dev->name);
3620err_out_id:
3621 rbd_dev_id_put(rbd_dev);
3622err_out_snaps:
3623 rbd_remove_all_snaps(rbd_dev);
3624
3625 return ret;
3626}
3627
a30b71b9
AE		 3628/*
3629 * Probe for the existence of the header object for the given rbd
3630 * device. For format 2 images this includes determining the image
3631 * id.
3632 */
3633static int rbd_dev_probe(struct rbd_device *rbd_dev)
3634{
3635 int ret;
3636
3637 /*
3638 * Get the id from the image id object. If it's not a
3639 * format 2 image, we'll get ENOENT back, and we'll assume
3640 * it's a format 1 image.
3641 */
3642 ret = rbd_dev_image_id(rbd_dev);
3643 if (ret)
3644 ret = rbd_dev_v1_probe(rbd_dev);
3645 else
3646 ret = rbd_dev_v2_probe(rbd_dev);
83a06263 3647 if (ret) {
a30b71b9
AE		 3648 dout("probe failed, returning %d\n", ret);
3649
83a06263
AE		 3650 return ret;
3651 }
3652
3653 ret = rbd_dev_probe_finish(rbd_dev);
3654 if (ret)
3655 rbd_header_free(&rbd_dev->header);
3656
a30b71b9
AE		 3657 return ret;
3658}
3659
59c2be1e
YS		 3660static ssize_t rbd_add(struct bus_type *bus,
3661 const char *buf,
3662 size_t count)
602adf40 3663{
cb8627c7 3664 struct rbd_device *rbd_dev = NULL;
dc79b113 3665 struct ceph_options *ceph_opts = NULL;
4e9afeba 3666 struct rbd_options *rbd_opts = NULL;
859c31df 3667 struct rbd_spec *spec = NULL;
9d3997fd 3668 struct rbd_client *rbdc;
27cc2594
AE		 3669 struct ceph_osd_client *osdc;
3670 int rc = -ENOMEM;
602adf40
YS		 3671
3672 if (!try_module_get(THIS_MODULE))
3673 return -ENODEV;
3674
602adf40 3675 /* parse add command */
859c31df 3676 rc = rbd_add_parse_args(buf, &ceph_opts, &rbd_opts, &spec);
dc79b113 3677 if (rc < 0)
bd4ba655 3678 goto err_out_module;
78cea76e 3679
9d3997fd
AE		 3680 rbdc = rbd_get_client(ceph_opts);
3681 if (IS_ERR(rbdc)) {
3682 rc = PTR_ERR(rbdc);
0ddebc0c 3683 goto err_out_args;
9d3997fd 3684 }
c53d5893 3685 ceph_opts = NULL; /* rbd_dev client now owns this */
602adf40 3686
602adf40 3687 /* pick the pool */
9d3997fd 3688 osdc = &rbdc->client->osdc;
859c31df 3689 rc = ceph_pg_poolid_by_name(osdc->osdmap, spec->pool_name);
602adf40
YS		 3690 if (rc < 0)
3691 goto err_out_client;
859c31df
AE		 3692 spec->pool_id = (u64) rc;
3693
c53d5893 3694 rbd_dev = rbd_dev_create(rbdc, spec);
bd4ba655
AE		 3695 if (!rbd_dev)
3696 goto err_out_client;
c53d5893
AE		 3697 rbdc = NULL; /* rbd_dev now owns this */
3698 spec = NULL; /* rbd_dev now owns this */
602adf40 3699
bd4ba655 3700 rbd_dev->mapping.read_only = rbd_opts->read_only;
c53d5893
AE		 3701 kfree(rbd_opts);
3702 rbd_opts = NULL; /* done with this */
bd4ba655 3703
a30b71b9
AE		 3704 rc = rbd_dev_probe(rbd_dev);
3705 if (rc < 0)
c53d5893 3706 goto err_out_rbd_dev;
05fd6f6f 3707
602adf40 3708 return count;
c53d5893
AE		 3709err_out_rbd_dev:
3710 rbd_dev_destroy(rbd_dev);
bd4ba655 3711err_out_client:
9d3997fd 3712 rbd_put_client(rbdc);
0ddebc0c 3713err_out_args:
78cea76e
AE		 3714 if (ceph_opts)
3715 ceph_destroy_options(ceph_opts);
4e9afeba 3716 kfree(rbd_opts);
859c31df 3717 rbd_spec_put(spec);
bd4ba655
AE		 3718err_out_module:
3719 module_put(THIS_MODULE);
27cc2594 3720
602adf40 3721 dout("Error adding device %s\n", buf);
27cc2594
AE		 3722
3723 return (ssize_t) rc;
602adf40
YS		 3724}
3725
de71a297 3726static struct rbd_device *__rbd_get_dev(unsigned long dev_id)
602adf40
YS		 3727{
3728 struct list_head *tmp;
3729 struct rbd_device *rbd_dev;
3730
e124a82f 3731 spin_lock(&rbd_dev_list_lock);
602adf40
YS		 3732 list_for_each(tmp, &rbd_dev_list) {
3733 rbd_dev = list_entry(tmp, struct rbd_device, node);
de71a297 3734 if (rbd_dev->dev_id == dev_id) {
e124a82f 3735 spin_unlock(&rbd_dev_list_lock);
602adf40 3736 return rbd_dev;
e124a82f 3737 }
602adf40 3738 }
e124a82f 3739 spin_unlock(&rbd_dev_list_lock);
602adf40
YS		 3740 return NULL;
3741}
3742
dfc5606d 3743static void rbd_dev_release(struct device *dev)
602adf40 3744{
593a9e7b 3745 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
602adf40 3746
1dbb4399
AE		 3747 if (rbd_dev->watch_request) {
3748 struct ceph_client *client = rbd_dev->rbd_client->client;
3749
3750 ceph_osdc_unregister_linger_request(&client->osdc,
59c2be1e 3751 rbd_dev->watch_request);
1dbb4399 3752 }
59c2be1e 3753 if (rbd_dev->watch_event)
070c633f 3754 rbd_req_sync_unwatch(rbd_dev);
59c2be1e 3755
602adf40
YS		 3756
3757 /* clean up and free blkdev */
3758 rbd_free_disk(rbd_dev);
3759 unregister_blkdev(rbd_dev->major, rbd_dev->name);
32eec68d 3760
2ac4e75d
AE		 3761 /* release allocated disk header fields */
3762 rbd_header_free(&rbd_dev->header);
3763
32eec68d 3764 /* done with the id, and with the rbd_dev */
e2839308 3765 rbd_dev_id_put(rbd_dev);
c53d5893
AE		 3766 rbd_assert(rbd_dev->rbd_client != NULL);
3767 rbd_dev_destroy(rbd_dev);
602adf40
YS		 3768
3769 /* release module ref */
3770 module_put(THIS_MODULE);
602adf40
YS		 3771}
3772
dfc5606d
YS		 3773static ssize_t rbd_remove(struct bus_type *bus,
3774 const char *buf,
3775 size_t count)
602adf40
YS		 3776{
3777 struct rbd_device *rbd_dev = NULL;
3778 int target_id, rc;
3779 unsigned long ul;
3780 int ret = count;
3781
3782 rc = strict_strtoul(buf, 10, &ul);
3783 if (rc)
3784 return rc;
3785
3786 /* convert to int; abort if we lost anything in the conversion */
3787 target_id = (int) ul;
3788 if (target_id != ul)
3789 return -EINVAL;
3790
3791 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
3792
3793 rbd_dev = __rbd_get_dev(target_id);
3794 if (!rbd_dev) {
3795 ret = -ENOENT;
3796 goto done;
42382b70
AE		 3797 }
3798
3799 if (rbd_dev->open_count) {
3800 ret = -EBUSY;
3801 goto done;
602adf40
YS		 3802 }
3803
41f38c2b 3804 rbd_remove_all_snaps(rbd_dev);
dfc5606d 3805 rbd_bus_del_dev(rbd_dev);
602adf40
YS		 3806
3807done:
3808 mutex_unlock(&ctl_mutex);
aafb230e 3809
602adf40
YS		 3810 return ret;
3811}
3812
602adf40
YS		 3813/*
3814 * create control files in sysfs
dfc5606d 3815 * /sys/bus/rbd/...
602adf40
YS		 3816 */
3817static int rbd_sysfs_init(void)
3818{
dfc5606d 3819 int ret;
602adf40 3820
fed4c143 3821 ret = device_register(&rbd_root_dev);
21079786 3822 if (ret < 0)
dfc5606d 3823 return ret;
602adf40 3824
fed4c143
AE		 3825 ret = bus_register(&rbd_bus_type);
3826 if (ret < 0)
3827 device_unregister(&rbd_root_dev);
602adf40 3828
602adf40
YS		 3829 return ret;
3830}
3831
3832static void rbd_sysfs_cleanup(void)
3833{
dfc5606d 3834 bus_unregister(&rbd_bus_type);
fed4c143 3835 device_unregister(&rbd_root_dev);
602adf40
YS		 3836}
3837
3838int __init rbd_init(void)
3839{
3840 int rc;
3841
3842 rc = rbd_sysfs_init();
3843 if (rc)
3844 return rc;
f0f8cef5 3845 pr_info("loaded " RBD_DRV_NAME_LONG "\n");
602adf40
YS		 3846 return 0;
3847}
3848
3849void __exit rbd_exit(void)
3850{
3851 rbd_sysfs_cleanup();
3852}
3853
3854module_init(rbd_init);
3855module_exit(rbd_exit);
3856
3857MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
3858MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
3859MODULE_DESCRIPTION("rados block device");
3860
3861/* following authorship retained from original osdblk.c */
3862MODULE_AUTHOR("Jeff Garzik <jeff@garzik.org>");
3863
3864MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.382413 seconds and 5 git commands to generate.