aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/ABI/testing/sysfs-bus-rbd18
-rw-r--r--drivers/block/rbd.c1784
-rw-r--r--drivers/block/rbd_types.h27
-rw-r--r--fs/ceph/addr.c19
-rw-r--r--fs/ceph/caps.c2
-rw-r--r--fs/ceph/file.c4
-rw-r--r--fs/ceph/ioctl.c8
-rw-r--r--fs/ceph/mds_client.c3
-rw-r--r--fs/ceph/super.c37
-rw-r--r--include/linux/ceph/mon_client.h1
-rw-r--r--include/linux/ceph/osd_client.h2
-rw-r--r--include/linux/ceph/osdmap.h6
-rw-r--r--net/ceph/mon_client.c7
-rw-r--r--net/ceph/osd_client.c47
-rw-r--r--net/ceph/osdmap.c18
-rw-r--r--net/ceph/pagelist.c5
16 files changed, 1299 insertions, 689 deletions
diff --git a/Documentation/ABI/testing/sysfs-bus-rbd b/Documentation/ABI/testing/sysfs-bus-rbd
index 3c17b62899f6..1cf2adf46b11 100644
--- a/Documentation/ABI/testing/sysfs-bus-rbd
+++ b/Documentation/ABI/testing/sysfs-bus-rbd
@@ -25,6 +25,10 @@ client_id
25 25
26 The ceph unique client id that was assigned for this specific session. 26 The ceph unique client id that was assigned for this specific session.
27 27
28features
29
30 A hexadecimal encoding of the feature bits for this image.
31
28major 32major
29 33
30 The block device major number. 34 The block device major number.
@@ -33,6 +37,11 @@ name
33 37
34 The name of the rbd image. 38 The name of the rbd image.
35 39
40image_id
41
42 The unique id for the rbd image. (For rbd image format 1
43 this is empty.)
44
36pool 45pool
37 46
38 The name of the storage pool where this rbd image resides. 47 The name of the storage pool where this rbd image resides.
@@ -57,12 +66,6 @@ current_snap
57 66
58 The current snapshot for which the device is mapped. 67 The current snapshot for which the device is mapped.
59 68
60create_snap
61
62 Create a snapshot:
63
64 $ echo <snap-name> > /sys/bus/rbd/devices/<dev-id>/snap_create
65
66snap_* 69snap_*
67 70
68 A directory per each snapshot 71 A directory per each snapshot
@@ -79,4 +82,7 @@ snap_size
79 82
80 The size of the image when this snapshot was taken. 83 The size of the image when this snapshot was taken.
81 84
85snap_features
86
87 A hexadecimal encoding of the feature bits for this snapshot.
82 88
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index 54a55f03115d..bb3d9be3b1b4 100644
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -41,6 +41,8 @@
41 41
42#include "rbd_types.h" 42#include "rbd_types.h"
43 43
44#define RBD_DEBUG /* Activate rbd_assert() calls */
45
44/* 46/*
45 * The basic unit of block I/O is a sector. It is interpreted in a 47 * The basic unit of block I/O is a sector. It is interpreted in a
46 * number of contexts in Linux (blk, bio, genhd), but the default is 48 * number of contexts in Linux (blk, bio, genhd), but the default is
@@ -50,16 +52,24 @@
50#define SECTOR_SHIFT 9 52#define SECTOR_SHIFT 9
51#define SECTOR_SIZE (1ULL << SECTOR_SHIFT) 53#define SECTOR_SIZE (1ULL << SECTOR_SHIFT)
52 54
55/* It might be useful to have this defined elsewhere too */
56
57#define U64_MAX ((u64) (~0ULL))
58
53#define RBD_DRV_NAME "rbd" 59#define RBD_DRV_NAME "rbd"
54#define RBD_DRV_NAME_LONG "rbd (rados block device)" 60#define RBD_DRV_NAME_LONG "rbd (rados block device)"
55 61
56#define RBD_MINORS_PER_MAJOR 256 /* max minors per blkdev */ 62#define RBD_MINORS_PER_MAJOR 256 /* max minors per blkdev */
57 63
58#define RBD_MAX_SNAP_NAME_LEN 32 64#define RBD_MAX_SNAP_NAME_LEN 32
65#define RBD_MAX_SNAP_COUNT 510 /* allows max snapc to fit in 4KB */
59#define RBD_MAX_OPT_LEN 1024 66#define RBD_MAX_OPT_LEN 1024
60 67
61#define RBD_SNAP_HEAD_NAME "-" 68#define RBD_SNAP_HEAD_NAME "-"
62 69
70#define RBD_IMAGE_ID_LEN_MAX 64
71#define RBD_OBJ_PREFIX_LEN_MAX 64
72
63/* 73/*
64 * An RBD device name will be "rbd#", where the "rbd" comes from 74 * An RBD device name will be "rbd#", where the "rbd" comes from
65 * RBD_DRV_NAME above, and # is a unique integer identifier. 75 * RBD_DRV_NAME above, and # is a unique integer identifier.
@@ -69,21 +79,22 @@
69#define DEV_NAME_LEN 32 79#define DEV_NAME_LEN 32
70#define MAX_INT_FORMAT_WIDTH ((5 * sizeof (int)) / 2 + 1) 80#define MAX_INT_FORMAT_WIDTH ((5 * sizeof (int)) / 2 + 1)
71 81
72#define RBD_NOTIFY_TIMEOUT_DEFAULT 10 82#define RBD_READ_ONLY_DEFAULT false
73 83
74/* 84/*
75 * block device image metadata (in-memory version) 85 * block device image metadata (in-memory version)
76 */ 86 */
77struct rbd_image_header { 87struct rbd_image_header {
78 u64 image_size; 88 /* These four fields never change for a given rbd image */
79 char *object_prefix; 89 char *object_prefix;
90 u64 features;
80 __u8 obj_order; 91 __u8 obj_order;
81 __u8 crypt_type; 92 __u8 crypt_type;
82 __u8 comp_type; 93 __u8 comp_type;
83 struct ceph_snap_context *snapc;
84 size_t snap_names_len;
85 u32 total_snaps;
86 94
95 /* The remaining fields need to be updated occasionally */
96 u64 image_size;
97 struct ceph_snap_context *snapc;
87 char *snap_names; 98 char *snap_names;
88 u64 *snap_sizes; 99 u64 *snap_sizes;
89 100
@@ -91,7 +102,7 @@ struct rbd_image_header {
91}; 102};
92 103
93struct rbd_options { 104struct rbd_options {
94 int notify_timeout; 105 bool read_only;
95}; 106};
96 107
97/* 108/*
@@ -99,7 +110,6 @@ struct rbd_options {
99 */ 110 */
100struct rbd_client { 111struct rbd_client {
101 struct ceph_client *client; 112 struct ceph_client *client;
102 struct rbd_options *rbd_opts;
103 struct kref kref; 113 struct kref kref;
104 struct list_head node; 114 struct list_head node;
105}; 115};
@@ -141,6 +151,16 @@ struct rbd_snap {
141 u64 size; 151 u64 size;
142 struct list_head node; 152 struct list_head node;
143 u64 id; 153 u64 id;
154 u64 features;
155};
156
157struct rbd_mapping {
158 char *snap_name;
159 u64 snap_id;
160 u64 size;
161 u64 features;
162 bool snap_exists;
163 bool read_only;
144}; 164};
145 165
146/* 166/*
@@ -151,8 +171,9 @@ struct rbd_device {
151 171
152 int major; /* blkdev assigned major */ 172 int major; /* blkdev assigned major */
153 struct gendisk *disk; /* blkdev's gendisk and rq */ 173 struct gendisk *disk; /* blkdev's gendisk and rq */
154 struct request_queue *q;
155 174
175 u32 image_format; /* Either 1 or 2 */
176 struct rbd_options rbd_opts;
156 struct rbd_client *rbd_client; 177 struct rbd_client *rbd_client;
157 178
158 char name[DEV_NAME_LEN]; /* blkdev name, e.g. rbd3 */ 179 char name[DEV_NAME_LEN]; /* blkdev name, e.g. rbd3 */
@@ -160,6 +181,8 @@ struct rbd_device {
160 spinlock_t lock; /* queue lock */ 181 spinlock_t lock; /* queue lock */
161 182
162 struct rbd_image_header header; 183 struct rbd_image_header header;
184 char *image_id;
185 size_t image_id_len;
163 char *image_name; 186 char *image_name;
164 size_t image_name_len; 187 size_t image_name_len;
165 char *header_name; 188 char *header_name;
@@ -171,13 +194,8 @@ struct rbd_device {
171 194
172 /* protects updating the header */ 195 /* protects updating the header */
173 struct rw_semaphore header_rwsem; 196 struct rw_semaphore header_rwsem;
174 /* name of the snapshot this device reads from */ 197
175 char *snap_name; 198 struct rbd_mapping mapping;
176 /* id of the snapshot this device reads from */
177 u64 snap_id; /* current snapshot id */
178 /* whether the snap_id this device reads from still exists */
179 bool snap_exists;
180 int read_only;
181 199
182 struct list_head node; 200 struct list_head node;
183 201
@@ -196,12 +214,10 @@ static DEFINE_SPINLOCK(rbd_dev_list_lock);
196static LIST_HEAD(rbd_client_list); /* clients */ 214static LIST_HEAD(rbd_client_list); /* clients */
197static DEFINE_SPINLOCK(rbd_client_list_lock); 215static DEFINE_SPINLOCK(rbd_client_list_lock);
198 216
199static int __rbd_init_snaps_header(struct rbd_device *rbd_dev); 217static int rbd_dev_snaps_update(struct rbd_device *rbd_dev);
218static int rbd_dev_snaps_register(struct rbd_device *rbd_dev);
219
200static void rbd_dev_release(struct device *dev); 220static void rbd_dev_release(struct device *dev);
201static ssize_t rbd_snap_add(struct device *dev,
202 struct device_attribute *attr,
203 const char *buf,
204 size_t count);
205static void __rbd_remove_snap_dev(struct rbd_snap *snap); 221static void __rbd_remove_snap_dev(struct rbd_snap *snap);
206 222
207static ssize_t rbd_add(struct bus_type *bus, const char *buf, 223static ssize_t rbd_add(struct bus_type *bus, const char *buf,
@@ -229,6 +245,18 @@ static struct device rbd_root_dev = {
229 .release = rbd_root_dev_release, 245 .release = rbd_root_dev_release,
230}; 246};
231 247
248#ifdef RBD_DEBUG
249#define rbd_assert(expr) \
250 if (unlikely(!(expr))) { \
251 printk(KERN_ERR "\nAssertion failure in %s() " \
252 "at line %d:\n\n" \
253 "\trbd_assert(%s);\n\n", \
254 __func__, __LINE__, #expr); \
255 BUG(); \
256 }
257#else /* !RBD_DEBUG */
258# define rbd_assert(expr) ((void) 0)
259#endif /* !RBD_DEBUG */
232 260
233static struct device *rbd_get_dev(struct rbd_device *rbd_dev) 261static struct device *rbd_get_dev(struct rbd_device *rbd_dev)
234{ 262{
@@ -246,11 +274,11 @@ static int rbd_open(struct block_device *bdev, fmode_t mode)
246{ 274{
247 struct rbd_device *rbd_dev = bdev->bd_disk->private_data; 275 struct rbd_device *rbd_dev = bdev->bd_disk->private_data;
248 276
249 if ((mode & FMODE_WRITE) && rbd_dev->read_only) 277 if ((mode & FMODE_WRITE) && rbd_dev->mapping.read_only)
250 return -EROFS; 278 return -EROFS;
251 279
252 rbd_get_dev(rbd_dev); 280 rbd_get_dev(rbd_dev);
253 set_device_ro(bdev, rbd_dev->read_only); 281 set_device_ro(bdev, rbd_dev->mapping.read_only);
254 282
255 return 0; 283 return 0;
256} 284}
@@ -274,8 +302,7 @@ static const struct block_device_operations rbd_bd_ops = {
274 * Initialize an rbd client instance. 302 * Initialize an rbd client instance.
275 * We own *ceph_opts. 303 * We own *ceph_opts.
276 */ 304 */
277static struct rbd_client *rbd_client_create(struct ceph_options *ceph_opts, 305static struct rbd_client *rbd_client_create(struct ceph_options *ceph_opts)
278 struct rbd_options *rbd_opts)
279{ 306{
280 struct rbd_client *rbdc; 307 struct rbd_client *rbdc;
281 int ret = -ENOMEM; 308 int ret = -ENOMEM;
@@ -299,8 +326,6 @@ static struct rbd_client *rbd_client_create(struct ceph_options *ceph_opts,
299 if (ret < 0) 326 if (ret < 0)
300 goto out_err; 327 goto out_err;
301 328
302 rbdc->rbd_opts = rbd_opts;
303
304 spin_lock(&rbd_client_list_lock); 329 spin_lock(&rbd_client_list_lock);
305 list_add_tail(&rbdc->node, &rbd_client_list); 330 list_add_tail(&rbdc->node, &rbd_client_list);
306 spin_unlock(&rbd_client_list_lock); 331 spin_unlock(&rbd_client_list_lock);
@@ -322,36 +347,52 @@ out_opt:
322} 347}
323 348
324/* 349/*
325 * Find a ceph client with specific addr and configuration. 350 * Find a ceph client with specific addr and configuration. If
351 * found, bump its reference count.
326 */ 352 */
327static struct rbd_client *__rbd_client_find(struct ceph_options *ceph_opts) 353static struct rbd_client *rbd_client_find(struct ceph_options *ceph_opts)
328{ 354{
329 struct rbd_client *client_node; 355 struct rbd_client *client_node;
356 bool found = false;
330 357
331 if (ceph_opts->flags & CEPH_OPT_NOSHARE) 358 if (ceph_opts->flags & CEPH_OPT_NOSHARE)
332 return NULL; 359 return NULL;
333 360
334 list_for_each_entry(client_node, &rbd_client_list, node) 361 spin_lock(&rbd_client_list_lock);
335 if (!ceph_compare_options(ceph_opts, client_node->client)) 362 list_for_each_entry(client_node, &rbd_client_list, node) {
336 return client_node; 363 if (!ceph_compare_options(ceph_opts, client_node->client)) {
337 return NULL; 364 kref_get(&client_node->kref);
365 found = true;
366 break;
367 }
368 }
369 spin_unlock(&rbd_client_list_lock);
370
371 return found ? client_node : NULL;
338} 372}
339 373
340/* 374/*
341 * mount options 375 * mount options
342 */ 376 */
343enum { 377enum {
344 Opt_notify_timeout,
345 Opt_last_int, 378 Opt_last_int,
346 /* int args above */ 379 /* int args above */
347 Opt_last_string, 380 Opt_last_string,
348 /* string args above */ 381 /* string args above */
382 Opt_read_only,
383 Opt_read_write,
384 /* Boolean args above */
385 Opt_last_bool,
349}; 386};
350 387
351static match_table_t rbd_opts_tokens = { 388static match_table_t rbd_opts_tokens = {
352 {Opt_notify_timeout, "notify_timeout=%d"},
353 /* int args above */ 389 /* int args above */
354 /* string args above */ 390 /* string args above */
391 {Opt_read_only, "mapping.read_only"},
392 {Opt_read_only, "ro"}, /* Alternate spelling */
393 {Opt_read_write, "read_write"},
394 {Opt_read_write, "rw"}, /* Alternate spelling */
395 /* Boolean args above */
355 {-1, NULL} 396 {-1, NULL}
356}; 397};
357 398
@@ -376,16 +417,22 @@ static int parse_rbd_opts_token(char *c, void *private)
376 } else if (token > Opt_last_int && token < Opt_last_string) { 417 } else if (token > Opt_last_int && token < Opt_last_string) {
377 dout("got string token %d val %s\n", token, 418 dout("got string token %d val %s\n", token,
378 argstr[0].from); 419 argstr[0].from);
420 } else if (token > Opt_last_string && token < Opt_last_bool) {
421 dout("got Boolean token %d\n", token);
379 } else { 422 } else {
380 dout("got token %d\n", token); 423 dout("got token %d\n", token);
381 } 424 }
382 425
383 switch (token) { 426 switch (token) {
384 case Opt_notify_timeout: 427 case Opt_read_only:
385 rbd_opts->notify_timeout = intval; 428 rbd_opts->read_only = true;
429 break;
430 case Opt_read_write:
431 rbd_opts->read_only = false;
386 break; 432 break;
387 default: 433 default:
388 BUG_ON(token); 434 rbd_assert(false);
435 break;
389 } 436 }
390 return 0; 437 return 0;
391} 438}
@@ -394,48 +441,33 @@ static int parse_rbd_opts_token(char *c, void *private)
394 * Get a ceph client with specific addr and configuration, if one does 441 * Get a ceph client with specific addr and configuration, if one does
395 * not exist create it. 442 * not exist create it.
396 */ 443 */
397static struct rbd_client *rbd_get_client(const char *mon_addr, 444static int rbd_get_client(struct rbd_device *rbd_dev, const char *mon_addr,
398 size_t mon_addr_len, 445 size_t mon_addr_len, char *options)
399 char *options)
400{ 446{
401 struct rbd_client *rbdc; 447 struct rbd_options *rbd_opts = &rbd_dev->rbd_opts;
402 struct ceph_options *ceph_opts; 448 struct ceph_options *ceph_opts;
403 struct rbd_options *rbd_opts; 449 struct rbd_client *rbdc;
404
405 rbd_opts = kzalloc(sizeof(*rbd_opts), GFP_KERNEL);
406 if (!rbd_opts)
407 return ERR_PTR(-ENOMEM);
408 450
409 rbd_opts->notify_timeout = RBD_NOTIFY_TIMEOUT_DEFAULT; 451 rbd_opts->read_only = RBD_READ_ONLY_DEFAULT;
410 452
411 ceph_opts = ceph_parse_options(options, mon_addr, 453 ceph_opts = ceph_parse_options(options, mon_addr,
412 mon_addr + mon_addr_len, 454 mon_addr + mon_addr_len,
413 parse_rbd_opts_token, rbd_opts); 455 parse_rbd_opts_token, rbd_opts);
414 if (IS_ERR(ceph_opts)) { 456 if (IS_ERR(ceph_opts))
415 kfree(rbd_opts); 457 return PTR_ERR(ceph_opts);
416 return ERR_CAST(ceph_opts);
417 }
418 458
419 spin_lock(&rbd_client_list_lock); 459 rbdc = rbd_client_find(ceph_opts);
420 rbdc = __rbd_client_find(ceph_opts);
421 if (rbdc) { 460 if (rbdc) {
422 /* using an existing client */ 461 /* using an existing client */
423 kref_get(&rbdc->kref);
424 spin_unlock(&rbd_client_list_lock);
425
426 ceph_destroy_options(ceph_opts); 462 ceph_destroy_options(ceph_opts);
427 kfree(rbd_opts); 463 } else {
428 464 rbdc = rbd_client_create(ceph_opts);
429 return rbdc; 465 if (IS_ERR(rbdc))
466 return PTR_ERR(rbdc);
430 } 467 }
431 spin_unlock(&rbd_client_list_lock); 468 rbd_dev->rbd_client = rbdc;
432
433 rbdc = rbd_client_create(ceph_opts, rbd_opts);
434 469
435 if (IS_ERR(rbdc)) 470 return 0;
436 kfree(rbd_opts);
437
438 return rbdc;
439} 471}
440 472
441/* 473/*
@@ -453,7 +485,6 @@ static void rbd_client_release(struct kref *kref)
453 spin_unlock(&rbd_client_list_lock); 485 spin_unlock(&rbd_client_list_lock);
454 486
455 ceph_destroy_client(rbdc->client); 487 ceph_destroy_client(rbdc->client);
456 kfree(rbdc->rbd_opts);
457 kfree(rbdc); 488 kfree(rbdc);
458} 489}
459 490
@@ -479,10 +510,38 @@ static void rbd_coll_release(struct kref *kref)
479 kfree(coll); 510 kfree(coll);
480} 511}
481 512
513static bool rbd_image_format_valid(u32 image_format)
514{
515 return image_format == 1 || image_format == 2;
516}
517
482static bool rbd_dev_ondisk_valid(struct rbd_image_header_ondisk *ondisk) 518static bool rbd_dev_ondisk_valid(struct rbd_image_header_ondisk *ondisk)
483{ 519{
484 return !memcmp(&ondisk->text, 520 size_t size;
485 RBD_HEADER_TEXT, sizeof (RBD_HEADER_TEXT)); 521 u32 snap_count;
522
523 /* The header has to start with the magic rbd header text */
524 if (memcmp(&ondisk->text, RBD_HEADER_TEXT, sizeof (RBD_HEADER_TEXT)))
525 return false;
526
527 /*
528 * The size of a snapshot header has to fit in a size_t, and
529 * that limits the number of snapshots.
530 */
531 snap_count = le32_to_cpu(ondisk->snap_count);
532 size = SIZE_MAX - sizeof (struct ceph_snap_context);
533 if (snap_count > size / sizeof (__le64))
534 return false;
535
536 /*
537 * Not only that, but the size of the entire the snapshot
538 * header must also be representable in a size_t.
539 */
540 size -= snap_count * sizeof (__le64);
541 if ((u64) size < le64_to_cpu(ondisk->snap_names_len))
542 return false;
543
544 return true;
486} 545}
487 546
488/* 547/*
@@ -490,179 +549,203 @@ static bool rbd_dev_ondisk_valid(struct rbd_image_header_ondisk *ondisk)
490 * header. 549 * header.
491 */ 550 */
492static int rbd_header_from_disk(struct rbd_image_header *header, 551static int rbd_header_from_disk(struct rbd_image_header *header,
493 struct rbd_image_header_ondisk *ondisk, 552 struct rbd_image_header_ondisk *ondisk)
494 u32 allocated_snaps)
495{ 553{
496 u32 snap_count; 554 u32 snap_count;
555 size_t len;
556 size_t size;
557 u32 i;
497 558
498 if (!rbd_dev_ondisk_valid(ondisk)) 559 memset(header, 0, sizeof (*header));
499 return -ENXIO;
500 560
501 snap_count = le32_to_cpu(ondisk->snap_count); 561 snap_count = le32_to_cpu(ondisk->snap_count);
502 if (snap_count > (SIZE_MAX - sizeof(struct ceph_snap_context)) 562
503 / sizeof (u64)) 563 len = strnlen(ondisk->object_prefix, sizeof (ondisk->object_prefix));
504 return -EINVAL; 564 header->object_prefix = kmalloc(len + 1, GFP_KERNEL);
505 header->snapc = kmalloc(sizeof(struct ceph_snap_context) + 565 if (!header->object_prefix)
506 snap_count * sizeof(u64),
507 GFP_KERNEL);
508 if (!header->snapc)
509 return -ENOMEM; 566 return -ENOMEM;
567 memcpy(header->object_prefix, ondisk->object_prefix, len);
568 header->object_prefix[len] = '\0';
510 569
511 if (snap_count) { 570 if (snap_count) {
512 header->snap_names_len = le64_to_cpu(ondisk->snap_names_len); 571 u64 snap_names_len = le64_to_cpu(ondisk->snap_names_len);
513 header->snap_names = kmalloc(header->snap_names_len, 572
514 GFP_KERNEL); 573 /* Save a copy of the snapshot names */
574
575 if (snap_names_len > (u64) SIZE_MAX)
576 return -EIO;
577 header->snap_names = kmalloc(snap_names_len, GFP_KERNEL);
515 if (!header->snap_names) 578 if (!header->snap_names)
516 goto err_snapc; 579 goto out_err;
517 header->snap_sizes = kmalloc(snap_count * sizeof(u64), 580 /*
518 GFP_KERNEL); 581 * Note that rbd_dev_v1_header_read() guarantees
582 * the ondisk buffer we're working with has
583 * snap_names_len bytes beyond the end of the
584 * snapshot id array, this memcpy() is safe.
585 */
586 memcpy(header->snap_names, &ondisk->snaps[snap_count],
587 snap_names_len);
588
589 /* Record each snapshot's size */
590
591 size = snap_count * sizeof (*header->snap_sizes);
592 header->snap_sizes = kmalloc(size, GFP_KERNEL);
519 if (!header->snap_sizes) 593 if (!header->snap_sizes)
520 goto err_names; 594 goto out_err;
595 for (i = 0; i < snap_count; i++)
596 header->snap_sizes[i] =
597 le64_to_cpu(ondisk->snaps[i].image_size);
521 } else { 598 } else {
522 WARN_ON(ondisk->snap_names_len); 599 WARN_ON(ondisk->snap_names_len);
523 header->snap_names_len = 0;
524 header->snap_names = NULL; 600 header->snap_names = NULL;
525 header->snap_sizes = NULL; 601 header->snap_sizes = NULL;
526 } 602 }
527 603
528 header->object_prefix = kmalloc(sizeof (ondisk->block_name) + 1, 604 header->features = 0; /* No features support in v1 images */
529 GFP_KERNEL);
530 if (!header->object_prefix)
531 goto err_sizes;
532
533 memcpy(header->object_prefix, ondisk->block_name,
534 sizeof(ondisk->block_name));
535 header->object_prefix[sizeof (ondisk->block_name)] = '\0';
536
537 header->image_size = le64_to_cpu(ondisk->image_size);
538 header->obj_order = ondisk->options.order; 605 header->obj_order = ondisk->options.order;
539 header->crypt_type = ondisk->options.crypt_type; 606 header->crypt_type = ondisk->options.crypt_type;
540 header->comp_type = ondisk->options.comp_type; 607 header->comp_type = ondisk->options.comp_type;
541 608
609 /* Allocate and fill in the snapshot context */
610
611 header->image_size = le64_to_cpu(ondisk->image_size);
612 size = sizeof (struct ceph_snap_context);
613 size += snap_count * sizeof (header->snapc->snaps[0]);
614 header->snapc = kzalloc(size, GFP_KERNEL);
615 if (!header->snapc)
616 goto out_err;
617
542 atomic_set(&header->snapc->nref, 1); 618 atomic_set(&header->snapc->nref, 1);
543 header->snapc->seq = le64_to_cpu(ondisk->snap_seq); 619 header->snapc->seq = le64_to_cpu(ondisk->snap_seq);
544 header->snapc->num_snaps = snap_count; 620 header->snapc->num_snaps = snap_count;
545 header->total_snaps = snap_count; 621 for (i = 0; i < snap_count; i++)
546 622 header->snapc->snaps[i] =
547 if (snap_count && allocated_snaps == snap_count) { 623 le64_to_cpu(ondisk->snaps[i].id);
548 int i;
549
550 for (i = 0; i < snap_count; i++) {
551 header->snapc->snaps[i] =
552 le64_to_cpu(ondisk->snaps[i].id);
553 header->snap_sizes[i] =
554 le64_to_cpu(ondisk->snaps[i].image_size);
555 }
556
557 /* copy snapshot names */
558 memcpy(header->snap_names, &ondisk->snaps[snap_count],
559 header->snap_names_len);
560 }
561 624
562 return 0; 625 return 0;
563 626
564err_sizes: 627out_err:
565 kfree(header->snap_sizes); 628 kfree(header->snap_sizes);
566 header->snap_sizes = NULL; 629 header->snap_sizes = NULL;
567err_names:
568 kfree(header->snap_names); 630 kfree(header->snap_names);
569 header->snap_names = NULL; 631 header->snap_names = NULL;
570err_snapc: 632 kfree(header->object_prefix);
571 kfree(header->snapc); 633 header->object_prefix = NULL;
572 header->snapc = NULL;
573 634
574 return -ENOMEM; 635 return -ENOMEM;
575} 636}
576 637
577static int snap_by_name(struct rbd_image_header *header, const char *snap_name, 638static int snap_by_name(struct rbd_device *rbd_dev, const char *snap_name)
578 u64 *seq, u64 *size)
579{ 639{
580 int i;
581 char *p = header->snap_names;
582 640
583 for (i = 0; i < header->total_snaps; i++) { 641 struct rbd_snap *snap;
584 if (!strcmp(snap_name, p)) {
585 642
586 /* Found it. Pass back its id and/or size */ 643 list_for_each_entry(snap, &rbd_dev->snaps, node) {
644 if (!strcmp(snap_name, snap->name)) {
645 rbd_dev->mapping.snap_id = snap->id;
646 rbd_dev->mapping.size = snap->size;
647 rbd_dev->mapping.features = snap->features;
587 648
588 if (seq) 649 return 0;
589 *seq = header->snapc->snaps[i];
590 if (size)
591 *size = header->snap_sizes[i];
592 return i;
593 } 650 }
594 p += strlen(p) + 1; /* Skip ahead to the next name */
595 } 651 }
652
596 return -ENOENT; 653 return -ENOENT;
597} 654}
598 655
599static int rbd_header_set_snap(struct rbd_device *rbd_dev, u64 *size) 656static int rbd_dev_set_mapping(struct rbd_device *rbd_dev, char *snap_name)
600{ 657{
601 int ret; 658 int ret;
602 659
603 down_write(&rbd_dev->header_rwsem); 660 if (!memcmp(snap_name, RBD_SNAP_HEAD_NAME,
604
605 if (!memcmp(rbd_dev->snap_name, RBD_SNAP_HEAD_NAME,
606 sizeof (RBD_SNAP_HEAD_NAME))) { 661 sizeof (RBD_SNAP_HEAD_NAME))) {
607 rbd_dev->snap_id = CEPH_NOSNAP; 662 rbd_dev->mapping.snap_id = CEPH_NOSNAP;
608 rbd_dev->snap_exists = false; 663 rbd_dev->mapping.size = rbd_dev->header.image_size;
609 rbd_dev->read_only = 0; 664 rbd_dev->mapping.features = rbd_dev->header.features;
610 if (size) 665 rbd_dev->mapping.snap_exists = false;
611 *size = rbd_dev->header.image_size; 666 rbd_dev->mapping.read_only = rbd_dev->rbd_opts.read_only;
667 ret = 0;
612 } else { 668 } else {
613 u64 snap_id = 0; 669 ret = snap_by_name(rbd_dev, snap_name);
614
615 ret = snap_by_name(&rbd_dev->header, rbd_dev->snap_name,
616 &snap_id, size);
617 if (ret < 0) 670 if (ret < 0)
618 goto done; 671 goto done;
619 rbd_dev->snap_id = snap_id; 672 rbd_dev->mapping.snap_exists = true;
620 rbd_dev->snap_exists = true; 673 rbd_dev->mapping.read_only = true;
621 rbd_dev->read_only = 1;
622 } 674 }
623 675 rbd_dev->mapping.snap_name = snap_name;
624 ret = 0;
625done: 676done:
626 up_write(&rbd_dev->header_rwsem);
627 return ret; 677 return ret;
628} 678}
629 679
630static void rbd_header_free(struct rbd_image_header *header) 680static void rbd_header_free(struct rbd_image_header *header)
631{ 681{
632 kfree(header->object_prefix); 682 kfree(header->object_prefix);
683 header->object_prefix = NULL;
633 kfree(header->snap_sizes); 684 kfree(header->snap_sizes);
685 header->snap_sizes = NULL;
634 kfree(header->snap_names); 686 kfree(header->snap_names);
687 header->snap_names = NULL;
635 ceph_put_snap_context(header->snapc); 688 ceph_put_snap_context(header->snapc);
689 header->snapc = NULL;
636} 690}
637 691
638/* 692static char *rbd_segment_name(struct rbd_device *rbd_dev, u64 offset)
639 * get the actual striped segment name, offset and length 693{
640 */ 694 char *name;
641static u64 rbd_get_segment(struct rbd_image_header *header, 695 u64 segment;
642 const char *object_prefix, 696 int ret;
643 u64 ofs, u64 len, 697
644 char *seg_name, u64 *segofs) 698 name = kmalloc(RBD_MAX_SEG_NAME_LEN + 1, GFP_NOIO);
699 if (!name)
700 return NULL;
701 segment = offset >> rbd_dev->header.obj_order;
702 ret = snprintf(name, RBD_MAX_SEG_NAME_LEN, "%s.%012llx",
703 rbd_dev->header.object_prefix, segment);
704 if (ret < 0 || ret >= RBD_MAX_SEG_NAME_LEN) {
705 pr_err("error formatting segment name for #%llu (%d)\n",
706 segment, ret);
707 kfree(name);
708 name = NULL;
709 }
710
711 return name;
712}
713
714static u64 rbd_segment_offset(struct rbd_device *rbd_dev, u64 offset)
645{ 715{
646 u64 seg = ofs >> header->obj_order; 716 u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
647 717
648 if (seg_name) 718 return offset & (segment_size - 1);
649 snprintf(seg_name, RBD_MAX_SEG_NAME_LEN, 719}
650 "%s.%012llx", object_prefix, seg); 720
721static u64 rbd_segment_length(struct rbd_device *rbd_dev,
722 u64 offset, u64 length)
723{
724 u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
651 725
652 ofs = ofs & ((1 << header->obj_order) - 1); 726 offset &= segment_size - 1;
653 len = min_t(u64, len, (1 << header->obj_order) - ofs);
654 727
655 if (segofs) 728 rbd_assert(length <= U64_MAX - offset);
656 *segofs = ofs; 729 if (offset + length > segment_size)
730 length = segment_size - offset;
657 731
658 return len; 732 return length;
659} 733}
660 734
661static int rbd_get_num_segments(struct rbd_image_header *header, 735static int rbd_get_num_segments(struct rbd_image_header *header,
662 u64 ofs, u64 len) 736 u64 ofs, u64 len)
663{ 737{
664 u64 start_seg = ofs >> header->obj_order; 738 u64 start_seg;
665 u64 end_seg = (ofs + len - 1) >> header->obj_order; 739 u64 end_seg;
740
741 if (!len)
742 return 0;
743 if (len - 1 > U64_MAX - ofs)
744 return -ERANGE;
745
746 start_seg = ofs >> header->obj_order;
747 end_seg = (ofs + len - 1) >> header->obj_order;
748
666 return end_seg - start_seg + 1; 749 return end_seg - start_seg + 1;
667} 750}
668 751
@@ -724,7 +807,9 @@ static struct bio *bio_chain_clone(struct bio **old, struct bio **next,
724 struct bio_pair **bp, 807 struct bio_pair **bp,
725 int len, gfp_t gfpmask) 808 int len, gfp_t gfpmask)
726{ 809{
727 struct bio *tmp, *old_chain = *old, *new_chain = NULL, *tail = NULL; 810 struct bio *old_chain = *old;
811 struct bio *new_chain = NULL;
812 struct bio *tail;
728 int total = 0; 813 int total = 0;
729 814
730 if (*bp) { 815 if (*bp) {
@@ -733,9 +818,12 @@ static struct bio *bio_chain_clone(struct bio **old, struct bio **next,
733 } 818 }
734 819
735 while (old_chain && (total < len)) { 820 while (old_chain && (total < len)) {
821 struct bio *tmp;
822
736 tmp = bio_kmalloc(gfpmask, old_chain->bi_max_vecs); 823 tmp = bio_kmalloc(gfpmask, old_chain->bi_max_vecs);
737 if (!tmp) 824 if (!tmp)
738 goto err_out; 825 goto err_out;
826 gfpmask &= ~__GFP_WAIT; /* can't wait after the first */
739 827
740 if (total + old_chain->bi_size > len) { 828 if (total + old_chain->bi_size > len) {
741 struct bio_pair *bp; 829 struct bio_pair *bp;
@@ -763,24 +851,18 @@ static struct bio *bio_chain_clone(struct bio **old, struct bio **next,
763 } 851 }
764 852
765 tmp->bi_bdev = NULL; 853 tmp->bi_bdev = NULL;
766 gfpmask &= ~__GFP_WAIT;
767 tmp->bi_next = NULL; 854 tmp->bi_next = NULL;
768 855 if (new_chain)
769 if (!new_chain) {
770 new_chain = tail = tmp;
771 } else {
772 tail->bi_next = tmp; 856 tail->bi_next = tmp;
773 tail = tmp; 857 else
774 } 858 new_chain = tmp;
859 tail = tmp;
775 old_chain = old_chain->bi_next; 860 old_chain = old_chain->bi_next;
776 861
777 total += tmp->bi_size; 862 total += tmp->bi_size;
778 } 863 }
779 864
780 BUG_ON(total < len); 865 rbd_assert(total == len);
781
782 if (tail)
783 tail->bi_next = NULL;
784 866
785 *old = old_chain; 867 *old = old_chain;
786 868
@@ -938,8 +1020,9 @@ static int rbd_do_request(struct request *rq,
938 layout->fl_stripe_count = cpu_to_le32(1); 1020 layout->fl_stripe_count = cpu_to_le32(1);
939 layout->fl_object_size = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER); 1021 layout->fl_object_size = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
940 layout->fl_pg_pool = cpu_to_le32(rbd_dev->pool_id); 1022 layout->fl_pg_pool = cpu_to_le32(rbd_dev->pool_id);
941 ceph_calc_raw_layout(osdc, layout, snapid, ofs, &len, &bno, 1023 ret = ceph_calc_raw_layout(osdc, layout, snapid, ofs, &len, &bno,
942 req, ops); 1024 req, ops);
1025 rbd_assert(ret == 0);
943 1026
944 ceph_osdc_build_request(req, ofs, &len, 1027 ceph_osdc_build_request(req, ofs, &len,
945 ops, 1028 ops,
@@ -1030,8 +1113,8 @@ static int rbd_req_sync_op(struct rbd_device *rbd_dev,
1030 int flags, 1113 int flags,
1031 struct ceph_osd_req_op *ops, 1114 struct ceph_osd_req_op *ops,
1032 const char *object_name, 1115 const char *object_name,
1033 u64 ofs, u64 len, 1116 u64 ofs, u64 inbound_size,
1034 char *buf, 1117 char *inbound,
1035 struct ceph_osd_request **linger_req, 1118 struct ceph_osd_request **linger_req,
1036 u64 *ver) 1119 u64 *ver)
1037{ 1120{
@@ -1039,15 +1122,15 @@ static int rbd_req_sync_op(struct rbd_device *rbd_dev,
1039 struct page **pages; 1122 struct page **pages;
1040 int num_pages; 1123 int num_pages;
1041 1124
1042 BUG_ON(ops == NULL); 1125 rbd_assert(ops != NULL);
1043 1126
1044 num_pages = calc_pages_for(ofs , len); 1127 num_pages = calc_pages_for(ofs, inbound_size);
1045 pages = ceph_alloc_page_vector(num_pages, GFP_KERNEL); 1128 pages = ceph_alloc_page_vector(num_pages, GFP_KERNEL);
1046 if (IS_ERR(pages)) 1129 if (IS_ERR(pages))
1047 return PTR_ERR(pages); 1130 return PTR_ERR(pages);
1048 1131
1049 ret = rbd_do_request(NULL, rbd_dev, snapc, snapid, 1132 ret = rbd_do_request(NULL, rbd_dev, snapc, snapid,
1050 object_name, ofs, len, NULL, 1133 object_name, ofs, inbound_size, NULL,
1051 pages, num_pages, 1134 pages, num_pages,
1052 flags, 1135 flags,
1053 ops, 1136 ops,
@@ -1057,8 +1140,8 @@ static int rbd_req_sync_op(struct rbd_device *rbd_dev,
1057 if (ret < 0) 1140 if (ret < 0)
1058 goto done; 1141 goto done;
1059 1142
1060 if ((flags & CEPH_OSD_FLAG_READ) && buf) 1143 if ((flags & CEPH_OSD_FLAG_READ) && inbound)
1061 ret = ceph_copy_from_page_vector(pages, buf, ofs, ret); 1144 ret = ceph_copy_from_page_vector(pages, inbound, ofs, ret);
1062 1145
1063done: 1146done:
1064 ceph_release_page_vector(pages, num_pages); 1147 ceph_release_page_vector(pages, num_pages);
@@ -1085,14 +1168,11 @@ static int rbd_do_op(struct request *rq,
1085 struct ceph_osd_req_op *ops; 1168 struct ceph_osd_req_op *ops;
1086 u32 payload_len; 1169 u32 payload_len;
1087 1170
1088 seg_name = kmalloc(RBD_MAX_SEG_NAME_LEN + 1, GFP_NOIO); 1171 seg_name = rbd_segment_name(rbd_dev, ofs);
1089 if (!seg_name) 1172 if (!seg_name)
1090 return -ENOMEM; 1173 return -ENOMEM;
1091 1174 seg_len = rbd_segment_length(rbd_dev, ofs, len);
1092 seg_len = rbd_get_segment(&rbd_dev->header, 1175 seg_ofs = rbd_segment_offset(rbd_dev, ofs);
1093 rbd_dev->header.object_prefix,
1094 ofs, len,
1095 seg_name, &seg_ofs);
1096 1176
1097 payload_len = (flags & CEPH_OSD_FLAG_WRITE ? seg_len : 0); 1177 payload_len = (flags & CEPH_OSD_FLAG_WRITE ? seg_len : 0);
1098 1178
@@ -1104,7 +1184,7 @@ static int rbd_do_op(struct request *rq,
1104 /* we've taken care of segment sizes earlier when we 1184 /* we've taken care of segment sizes earlier when we
1105 cloned the bios. We should never have a segment 1185 cloned the bios. We should never have a segment
1106 truncated at this point */ 1186 truncated at this point */
1107 BUG_ON(seg_len < len); 1187 rbd_assert(seg_len == len);
1108 1188
1109 ret = rbd_do_request(rq, rbd_dev, snapc, snapid, 1189 ret = rbd_do_request(rq, rbd_dev, snapc, snapid,
1110 seg_name, seg_ofs, seg_len, 1190 seg_name, seg_ofs, seg_len,
@@ -1306,89 +1386,36 @@ static int rbd_req_sync_unwatch(struct rbd_device *rbd_dev)
1306 return ret; 1386 return ret;
1307} 1387}
1308 1388
1309struct rbd_notify_info {
1310 struct rbd_device *rbd_dev;
1311};
1312
1313static void rbd_notify_cb(u64 ver, u64 notify_id, u8 opcode, void *data)
1314{
1315 struct rbd_device *rbd_dev = (struct rbd_device *)data;
1316 if (!rbd_dev)
1317 return;
1318
1319 dout("rbd_notify_cb %s notify_id=%llu opcode=%u\n",
1320 rbd_dev->header_name, (unsigned long long) notify_id,
1321 (unsigned int) opcode);
1322}
1323
1324/* 1389/*
1325 * Request sync osd notify 1390 * Synchronous osd object method call
1326 */
1327static int rbd_req_sync_notify(struct rbd_device *rbd_dev)
1328{
1329 struct ceph_osd_req_op *ops;
1330 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
1331 struct ceph_osd_event *event;
1332 struct rbd_notify_info info;
1333 int payload_len = sizeof(u32) + sizeof(u32);
1334 int ret;
1335
1336 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_NOTIFY, payload_len);
1337 if (!ops)
1338 return -ENOMEM;
1339
1340 info.rbd_dev = rbd_dev;
1341
1342 ret = ceph_osdc_create_event(osdc, rbd_notify_cb, 1,
1343 (void *)&info, &event);
1344 if (ret < 0)
1345 goto fail;
1346
1347 ops[0].watch.ver = 1;
1348 ops[0].watch.flag = 1;
1349 ops[0].watch.cookie = event->cookie;
1350 ops[0].watch.prot_ver = RADOS_NOTIFY_VER;
1351 ops[0].watch.timeout = 12;
1352
1353 ret = rbd_req_sync_op(rbd_dev, NULL,
1354 CEPH_NOSNAP,
1355 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1356 ops,
1357 rbd_dev->header_name,
1358 0, 0, NULL, NULL, NULL);
1359 if (ret < 0)
1360 goto fail_event;
1361
1362 ret = ceph_osdc_wait_event(event, CEPH_OSD_TIMEOUT_DEFAULT);
1363 dout("ceph_osdc_wait_event returned %d\n", ret);
1364 rbd_destroy_ops(ops);
1365 return 0;
1366
1367fail_event:
1368 ceph_osdc_cancel_event(event);
1369fail:
1370 rbd_destroy_ops(ops);
1371 return ret;
1372}
1373
1374/*
1375 * Request sync osd read
1376 */ 1391 */
1377static int rbd_req_sync_exec(struct rbd_device *rbd_dev, 1392static int rbd_req_sync_exec(struct rbd_device *rbd_dev,
1378 const char *object_name, 1393 const char *object_name,
1379 const char *class_name, 1394 const char *class_name,
1380 const char *method_name, 1395 const char *method_name,
1381 const char *data, 1396 const char *outbound,
1382 int len, 1397 size_t outbound_size,
1398 char *inbound,
1399 size_t inbound_size,
1400 int flags,
1383 u64 *ver) 1401 u64 *ver)
1384{ 1402{
1385 struct ceph_osd_req_op *ops; 1403 struct ceph_osd_req_op *ops;
1386 int class_name_len = strlen(class_name); 1404 int class_name_len = strlen(class_name);
1387 int method_name_len = strlen(method_name); 1405 int method_name_len = strlen(method_name);
1406 int payload_size;
1388 int ret; 1407 int ret;
1389 1408
1390 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_CALL, 1409 /*
1391 class_name_len + method_name_len + len); 1410 * Any input parameters required by the method we're calling
1411 * will be sent along with the class and method names as
1412 * part of the message payload. That data and its size are
1413 * supplied via the indata and indata_len fields (named from
1414 * the perspective of the server side) in the OSD request
1415 * operation.
1416 */
1417 payload_size = class_name_len + method_name_len + outbound_size;
1418 ops = rbd_create_rw_ops(1, CEPH_OSD_OP_CALL, payload_size);
1392 if (!ops) 1419 if (!ops)
1393 return -ENOMEM; 1420 return -ENOMEM;
1394 1421
@@ -1397,14 +1424,14 @@ static int rbd_req_sync_exec(struct rbd_device *rbd_dev,
1397 ops[0].cls.method_name = method_name; 1424 ops[0].cls.method_name = method_name;
1398 ops[0].cls.method_len = (__u8) method_name_len; 1425 ops[0].cls.method_len = (__u8) method_name_len;
1399 ops[0].cls.argc = 0; 1426 ops[0].cls.argc = 0;
1400 ops[0].cls.indata = data; 1427 ops[0].cls.indata = outbound;
1401 ops[0].cls.indata_len = len; 1428 ops[0].cls.indata_len = outbound_size;
1402 1429
1403 ret = rbd_req_sync_op(rbd_dev, NULL, 1430 ret = rbd_req_sync_op(rbd_dev, NULL,
1404 CEPH_NOSNAP, 1431 CEPH_NOSNAP,
1405 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK, 1432 flags, ops,
1406 ops, 1433 object_name, 0, inbound_size, inbound,
1407 object_name, 0, 0, NULL, NULL, ver); 1434 NULL, ver);
1408 1435
1409 rbd_destroy_ops(ops); 1436 rbd_destroy_ops(ops);
1410 1437
@@ -1446,10 +1473,6 @@ static void rbd_rq_fn(struct request_queue *q)
1446 struct rbd_req_coll *coll; 1473 struct rbd_req_coll *coll;
1447 struct ceph_snap_context *snapc; 1474 struct ceph_snap_context *snapc;
1448 1475
1449 /* peek at request from block layer */
1450 if (!rq)
1451 break;
1452
1453 dout("fetched request\n"); 1476 dout("fetched request\n");
1454 1477
1455 /* filter out block requests we don't understand */ 1478 /* filter out block requests we don't understand */
@@ -1464,7 +1487,7 @@ static void rbd_rq_fn(struct request_queue *q)
1464 size = blk_rq_bytes(rq); 1487 size = blk_rq_bytes(rq);
1465 ofs = blk_rq_pos(rq) * SECTOR_SIZE; 1488 ofs = blk_rq_pos(rq) * SECTOR_SIZE;
1466 rq_bio = rq->bio; 1489 rq_bio = rq->bio;
1467 if (do_write && rbd_dev->read_only) { 1490 if (do_write && rbd_dev->mapping.read_only) {
1468 __blk_end_request_all(rq, -EROFS); 1491 __blk_end_request_all(rq, -EROFS);
1469 continue; 1492 continue;
1470 } 1493 }
@@ -1473,7 +1496,8 @@ static void rbd_rq_fn(struct request_queue *q)
1473 1496
1474 down_read(&rbd_dev->header_rwsem); 1497 down_read(&rbd_dev->header_rwsem);
1475 1498
1476 if (rbd_dev->snap_id != CEPH_NOSNAP && !rbd_dev->snap_exists) { 1499 if (rbd_dev->mapping.snap_id != CEPH_NOSNAP &&
1500 !rbd_dev->mapping.snap_exists) {
1477 up_read(&rbd_dev->header_rwsem); 1501 up_read(&rbd_dev->header_rwsem);
1478 dout("request for non-existent snapshot"); 1502 dout("request for non-existent snapshot");
1479 spin_lock_irq(q->queue_lock); 1503 spin_lock_irq(q->queue_lock);
@@ -1490,6 +1514,12 @@ static void rbd_rq_fn(struct request_queue *q)
1490 size, (unsigned long long) blk_rq_pos(rq) * SECTOR_SIZE); 1514 size, (unsigned long long) blk_rq_pos(rq) * SECTOR_SIZE);
1491 1515
1492 num_segs = rbd_get_num_segments(&rbd_dev->header, ofs, size); 1516 num_segs = rbd_get_num_segments(&rbd_dev->header, ofs, size);
1517 if (num_segs <= 0) {
1518 spin_lock_irq(q->queue_lock);
1519 __blk_end_request_all(rq, num_segs);
1520 ceph_put_snap_context(snapc);
1521 continue;
1522 }
1493 coll = rbd_alloc_coll(num_segs); 1523 coll = rbd_alloc_coll(num_segs);
1494 if (!coll) { 1524 if (!coll) {
1495 spin_lock_irq(q->queue_lock); 1525 spin_lock_irq(q->queue_lock);
@@ -1501,10 +1531,7 @@ static void rbd_rq_fn(struct request_queue *q)
1501 do { 1531 do {
1502 /* a bio clone to be passed down to OSD req */ 1532 /* a bio clone to be passed down to OSD req */
1503 dout("rq->bio->bi_vcnt=%hu\n", rq->bio->bi_vcnt); 1533 dout("rq->bio->bi_vcnt=%hu\n", rq->bio->bi_vcnt);
1504 op_size = rbd_get_segment(&rbd_dev->header, 1534 op_size = rbd_segment_length(rbd_dev, ofs, size);
1505 rbd_dev->header.object_prefix,
1506 ofs, size,
1507 NULL, NULL);
1508 kref_get(&coll->kref); 1535 kref_get(&coll->kref);
1509 bio = bio_chain_clone(&rq_bio, &next_bio, &bp, 1536 bio = bio_chain_clone(&rq_bio, &next_bio, &bp,
1510 op_size, GFP_ATOMIC); 1537 op_size, GFP_ATOMIC);
@@ -1524,7 +1551,7 @@ static void rbd_rq_fn(struct request_queue *q)
1524 coll, cur_seg); 1551 coll, cur_seg);
1525 else 1552 else
1526 rbd_req_read(rq, rbd_dev, 1553 rbd_req_read(rq, rbd_dev,
1527 rbd_dev->snap_id, 1554 rbd_dev->mapping.snap_id,
1528 ofs, 1555 ofs,
1529 op_size, bio, 1556 op_size, bio,
1530 coll, cur_seg); 1557 coll, cur_seg);
@@ -1580,8 +1607,6 @@ static void rbd_free_disk(struct rbd_device *rbd_dev)
1580 if (!disk) 1607 if (!disk)
1581 return; 1608 return;
1582 1609
1583 rbd_header_free(&rbd_dev->header);
1584
1585 if (disk->flags & GENHD_FL_UP) 1610 if (disk->flags & GENHD_FL_UP)
1586 del_gendisk(disk); 1611 del_gendisk(disk);
1587 if (disk->queue) 1612 if (disk->queue)
@@ -1590,105 +1615,96 @@ static void rbd_free_disk(struct rbd_device *rbd_dev)
1590} 1615}
1591 1616
1592/* 1617/*
1593 * reload the ondisk the header 1618 * Read the complete header for the given rbd device.
1619 *
1620 * Returns a pointer to a dynamically-allocated buffer containing
1621 * the complete and validated header. Caller can pass the address
1622 * of a variable that will be filled in with the version of the
1623 * header object at the time it was read.
1624 *
1625 * Returns a pointer-coded errno if a failure occurs.
1594 */ 1626 */
1595static int rbd_read_header(struct rbd_device *rbd_dev, 1627static struct rbd_image_header_ondisk *
1596 struct rbd_image_header *header) 1628rbd_dev_v1_header_read(struct rbd_device *rbd_dev, u64 *version)
1597{ 1629{
1598 ssize_t rc; 1630 struct rbd_image_header_ondisk *ondisk = NULL;
1599 struct rbd_image_header_ondisk *dh;
1600 u32 snap_count = 0; 1631 u32 snap_count = 0;
1601 u64 ver; 1632 u64 names_size = 0;
1602 size_t len; 1633 u32 want_count;
1634 int ret;
1603 1635
1604 /* 1636 /*
1605 * First reads the fixed-size header to determine the number 1637 * The complete header will include an array of its 64-bit
1606 * of snapshots, then re-reads it, along with all snapshot 1638 * snapshot ids, followed by the names of those snapshots as
1607 * records as well as their stored names. 1639 * a contiguous block of NUL-terminated strings. Note that
1640 * the number of snapshots could change by the time we read
1641 * it in, in which case we re-read it.
1608 */ 1642 */
1609 len = sizeof (*dh); 1643 do {
1610 while (1) { 1644 size_t size;
1611 dh = kmalloc(len, GFP_KERNEL); 1645
1612 if (!dh) 1646 kfree(ondisk);
1613 return -ENOMEM; 1647
1614 1648 size = sizeof (*ondisk);
1615 rc = rbd_req_sync_read(rbd_dev, 1649 size += snap_count * sizeof (struct rbd_image_snap_ondisk);
1616 CEPH_NOSNAP, 1650 size += names_size;
1651 ondisk = kmalloc(size, GFP_KERNEL);
1652 if (!ondisk)
1653 return ERR_PTR(-ENOMEM);
1654
1655 ret = rbd_req_sync_read(rbd_dev, CEPH_NOSNAP,
1617 rbd_dev->header_name, 1656 rbd_dev->header_name,
1618 0, len, 1657 0, size,
1619 (char *)dh, &ver); 1658 (char *) ondisk, version);
1620 if (rc < 0) 1659
1621 goto out_dh; 1660 if (ret < 0)
1622 1661 goto out_err;
1623 rc = rbd_header_from_disk(header, dh, snap_count); 1662 if (WARN_ON((size_t) ret < size)) {
1624 if (rc < 0) { 1663 ret = -ENXIO;
1625 if (rc == -ENXIO) 1664 pr_warning("short header read for image %s"
1626 pr_warning("unrecognized header format" 1665 " (want %zd got %d)\n",
1627 " for image %s\n", 1666 rbd_dev->image_name, size, ret);
1628 rbd_dev->image_name); 1667 goto out_err;
1629 goto out_dh; 1668 }
1669 if (!rbd_dev_ondisk_valid(ondisk)) {
1670 ret = -ENXIO;
1671 pr_warning("invalid header for image %s\n",
1672 rbd_dev->image_name);
1673 goto out_err;
1630 } 1674 }
1631 1675
1632 if (snap_count == header->total_snaps) 1676 names_size = le64_to_cpu(ondisk->snap_names_len);
1633 break; 1677 want_count = snap_count;
1678 snap_count = le32_to_cpu(ondisk->snap_count);
1679 } while (snap_count != want_count);
1634 1680
1635 snap_count = header->total_snaps; 1681 return ondisk;
1636 len = sizeof (*dh) +
1637 snap_count * sizeof(struct rbd_image_snap_ondisk) +
1638 header->snap_names_len;
1639 1682
1640 rbd_header_free(header); 1683out_err:
1641 kfree(dh); 1684 kfree(ondisk);
1642 }
1643 header->obj_version = ver;
1644 1685
1645out_dh: 1686 return ERR_PTR(ret);
1646 kfree(dh);
1647 return rc;
1648} 1687}
1649 1688
1650/* 1689/*
1651 * create a snapshot 1690 * reload the ondisk the header
1652 */ 1691 */
1653static int rbd_header_add_snap(struct rbd_device *rbd_dev, 1692static int rbd_read_header(struct rbd_device *rbd_dev,
1654 const char *snap_name, 1693 struct rbd_image_header *header)
1655 gfp_t gfp_flags)
1656{ 1694{
1657 int name_len = strlen(snap_name); 1695 struct rbd_image_header_ondisk *ondisk;
1658 u64 new_snapid; 1696 u64 ver = 0;
1659 int ret; 1697 int ret;
1660 void *data, *p, *e;
1661 struct ceph_mon_client *monc;
1662
1663 /* we should create a snapshot only if we're pointing at the head */
1664 if (rbd_dev->snap_id != CEPH_NOSNAP)
1665 return -EINVAL;
1666 1698
1667 monc = &rbd_dev->rbd_client->client->monc; 1699 ondisk = rbd_dev_v1_header_read(rbd_dev, &ver);
1668 ret = ceph_monc_create_snapid(monc, rbd_dev->pool_id, &new_snapid); 1700 if (IS_ERR(ondisk))
1669 dout("created snapid=%llu\n", (unsigned long long) new_snapid); 1701 return PTR_ERR(ondisk);
1670 if (ret < 0) 1702 ret = rbd_header_from_disk(header, ondisk);
1671 return ret; 1703 if (ret >= 0)
1672 1704 header->obj_version = ver;
1673 data = kmalloc(name_len + 16, gfp_flags); 1705 kfree(ondisk);
1674 if (!data)
1675 return -ENOMEM;
1676 1706
1677 p = data; 1707 return ret;
1678 e = data + name_len + 16;
1679
1680 ceph_encode_string_safe(&p, e, snap_name, name_len, bad);
1681 ceph_encode_64_safe(&p, e, new_snapid, bad);
1682
1683 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
1684 "rbd", "snap_add",
1685 data, p - data, NULL);
1686
1687 kfree(data);
1688
1689 return ret < 0 ? ret : 0;
1690bad:
1691 return -ERANGE;
1692} 1708}
1693 1709
1694static void __rbd_remove_all_snaps(struct rbd_device *rbd_dev) 1710static void __rbd_remove_all_snaps(struct rbd_device *rbd_dev)
@@ -1715,11 +1731,15 @@ static int __rbd_refresh_header(struct rbd_device *rbd_dev, u64 *hver)
1715 down_write(&rbd_dev->header_rwsem); 1731 down_write(&rbd_dev->header_rwsem);
1716 1732
1717 /* resized? */ 1733 /* resized? */
1718 if (rbd_dev->snap_id == CEPH_NOSNAP) { 1734 if (rbd_dev->mapping.snap_id == CEPH_NOSNAP) {
1719 sector_t size = (sector_t) h.image_size / SECTOR_SIZE; 1735 sector_t size = (sector_t) h.image_size / SECTOR_SIZE;
1720 1736
1721 dout("setting size to %llu sectors", (unsigned long long) size); 1737 if (size != (sector_t) rbd_dev->mapping.size) {
1722 set_capacity(rbd_dev->disk, size); 1738 dout("setting size to %llu sectors",
1739 (unsigned long long) size);
1740 rbd_dev->mapping.size = (u64) size;
1741 set_capacity(rbd_dev->disk, size);
1742 }
1723 } 1743 }
1724 1744
1725 /* rbd_dev->header.object_prefix shouldn't change */ 1745 /* rbd_dev->header.object_prefix shouldn't change */
@@ -1732,16 +1752,16 @@ static int __rbd_refresh_header(struct rbd_device *rbd_dev, u64 *hver)
1732 *hver = h.obj_version; 1752 *hver = h.obj_version;
1733 rbd_dev->header.obj_version = h.obj_version; 1753 rbd_dev->header.obj_version = h.obj_version;
1734 rbd_dev->header.image_size = h.image_size; 1754 rbd_dev->header.image_size = h.image_size;
1735 rbd_dev->header.total_snaps = h.total_snaps;
1736 rbd_dev->header.snapc = h.snapc; 1755 rbd_dev->header.snapc = h.snapc;
1737 rbd_dev->header.snap_names = h.snap_names; 1756 rbd_dev->header.snap_names = h.snap_names;
1738 rbd_dev->header.snap_names_len = h.snap_names_len;
1739 rbd_dev->header.snap_sizes = h.snap_sizes; 1757 rbd_dev->header.snap_sizes = h.snap_sizes;
1740 /* Free the extra copy of the object prefix */ 1758 /* Free the extra copy of the object prefix */
1741 WARN_ON(strcmp(rbd_dev->header.object_prefix, h.object_prefix)); 1759 WARN_ON(strcmp(rbd_dev->header.object_prefix, h.object_prefix));
1742 kfree(h.object_prefix); 1760 kfree(h.object_prefix);
1743 1761
1744 ret = __rbd_init_snaps_header(rbd_dev); 1762 ret = rbd_dev_snaps_update(rbd_dev);
1763 if (!ret)
1764 ret = rbd_dev_snaps_register(rbd_dev);
1745 1765
1746 up_write(&rbd_dev->header_rwsem); 1766 up_write(&rbd_dev->header_rwsem);
1747 1767
@@ -1763,29 +1783,12 @@ static int rbd_init_disk(struct rbd_device *rbd_dev)
1763{ 1783{
1764 struct gendisk *disk; 1784 struct gendisk *disk;
1765 struct request_queue *q; 1785 struct request_queue *q;
1766 int rc;
1767 u64 segment_size; 1786 u64 segment_size;
1768 u64 total_size = 0;
1769
1770 /* contact OSD, request size info about the object being mapped */
1771 rc = rbd_read_header(rbd_dev, &rbd_dev->header);
1772 if (rc)
1773 return rc;
1774
1775 /* no need to lock here, as rbd_dev is not registered yet */
1776 rc = __rbd_init_snaps_header(rbd_dev);
1777 if (rc)
1778 return rc;
1779
1780 rc = rbd_header_set_snap(rbd_dev, &total_size);
1781 if (rc)
1782 return rc;
1783 1787
1784 /* create gendisk info */ 1788 /* create gendisk info */
1785 rc = -ENOMEM;
1786 disk = alloc_disk(RBD_MINORS_PER_MAJOR); 1789 disk = alloc_disk(RBD_MINORS_PER_MAJOR);
1787 if (!disk) 1790 if (!disk)
1788 goto out; 1791 return -ENOMEM;
1789 1792
1790 snprintf(disk->disk_name, sizeof(disk->disk_name), RBD_DRV_NAME "%d", 1793 snprintf(disk->disk_name, sizeof(disk->disk_name), RBD_DRV_NAME "%d",
1791 rbd_dev->dev_id); 1794 rbd_dev->dev_id);
@@ -1795,7 +1798,6 @@ static int rbd_init_disk(struct rbd_device *rbd_dev)
1795 disk->private_data = rbd_dev; 1798 disk->private_data = rbd_dev;
1796 1799
1797 /* init rq */ 1800 /* init rq */
1798 rc = -ENOMEM;
1799 q = blk_init_queue(rbd_rq_fn, &rbd_dev->lock); 1801 q = blk_init_queue(rbd_rq_fn, &rbd_dev->lock);
1800 if (!q) 1802 if (!q)
1801 goto out_disk; 1803 goto out_disk;
@@ -1816,20 +1818,14 @@ static int rbd_init_disk(struct rbd_device *rbd_dev)
1816 q->queuedata = rbd_dev; 1818 q->queuedata = rbd_dev;
1817 1819
1818 rbd_dev->disk = disk; 1820 rbd_dev->disk = disk;
1819 rbd_dev->q = q;
1820 1821
1821 /* finally, announce the disk to the world */ 1822 set_capacity(rbd_dev->disk, rbd_dev->mapping.size / SECTOR_SIZE);
1822 set_capacity(disk, total_size / SECTOR_SIZE);
1823 add_disk(disk);
1824 1823
1825 pr_info("%s: added with size 0x%llx\n",
1826 disk->disk_name, (unsigned long long)total_size);
1827 return 0; 1824 return 0;
1828
1829out_disk: 1825out_disk:
1830 put_disk(disk); 1826 put_disk(disk);
1831out: 1827
1832 return rc; 1828 return -ENOMEM;
1833} 1829}
1834 1830
1835/* 1831/*
@@ -1854,6 +1850,19 @@ static ssize_t rbd_size_show(struct device *dev,
1854 return sprintf(buf, "%llu\n", (unsigned long long) size * SECTOR_SIZE); 1850 return sprintf(buf, "%llu\n", (unsigned long long) size * SECTOR_SIZE);
1855} 1851}
1856 1852
1853/*
1854 * Note this shows the features for whatever's mapped, which is not
1855 * necessarily the base image.
1856 */
1857static ssize_t rbd_features_show(struct device *dev,
1858 struct device_attribute *attr, char *buf)
1859{
1860 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
1861
1862 return sprintf(buf, "0x%016llx\n",
1863 (unsigned long long) rbd_dev->mapping.features);
1864}
1865
1857static ssize_t rbd_major_show(struct device *dev, 1866static ssize_t rbd_major_show(struct device *dev,
1858 struct device_attribute *attr, char *buf) 1867 struct device_attribute *attr, char *buf)
1859{ 1868{
@@ -1895,13 +1904,25 @@ static ssize_t rbd_name_show(struct device *dev,
1895 return sprintf(buf, "%s\n", rbd_dev->image_name); 1904 return sprintf(buf, "%s\n", rbd_dev->image_name);
1896} 1905}
1897 1906
1907static ssize_t rbd_image_id_show(struct device *dev,
1908 struct device_attribute *attr, char *buf)
1909{
1910 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
1911
1912 return sprintf(buf, "%s\n", rbd_dev->image_id);
1913}
1914
1915/*
1916 * Shows the name of the currently-mapped snapshot (or
1917 * RBD_SNAP_HEAD_NAME for the base image).
1918 */
1898static ssize_t rbd_snap_show(struct device *dev, 1919static ssize_t rbd_snap_show(struct device *dev,
1899 struct device_attribute *attr, 1920 struct device_attribute *attr,
1900 char *buf) 1921 char *buf)
1901{ 1922{
1902 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev); 1923 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
1903 1924
1904 return sprintf(buf, "%s\n", rbd_dev->snap_name); 1925 return sprintf(buf, "%s\n", rbd_dev->mapping.snap_name);
1905} 1926}
1906 1927
1907static ssize_t rbd_image_refresh(struct device *dev, 1928static ssize_t rbd_image_refresh(struct device *dev,
@@ -1918,25 +1939,27 @@ static ssize_t rbd_image_refresh(struct device *dev,
1918} 1939}
1919 1940
1920static DEVICE_ATTR(size, S_IRUGO, rbd_size_show, NULL); 1941static DEVICE_ATTR(size, S_IRUGO, rbd_size_show, NULL);
1942static DEVICE_ATTR(features, S_IRUGO, rbd_features_show, NULL);
1921static DEVICE_ATTR(major, S_IRUGO, rbd_major_show, NULL); 1943static DEVICE_ATTR(major, S_IRUGO, rbd_major_show, NULL);
1922static DEVICE_ATTR(client_id, S_IRUGO, rbd_client_id_show, NULL); 1944static DEVICE_ATTR(client_id, S_IRUGO, rbd_client_id_show, NULL);
1923static DEVICE_ATTR(pool, S_IRUGO, rbd_pool_show, NULL); 1945static DEVICE_ATTR(pool, S_IRUGO, rbd_pool_show, NULL);
1924static DEVICE_ATTR(pool_id, S_IRUGO, rbd_pool_id_show, NULL); 1946static DEVICE_ATTR(pool_id, S_IRUGO, rbd_pool_id_show, NULL);
1925static DEVICE_ATTR(name, S_IRUGO, rbd_name_show, NULL); 1947static DEVICE_ATTR(name, S_IRUGO, rbd_name_show, NULL);
1948static DEVICE_ATTR(image_id, S_IRUGO, rbd_image_id_show, NULL);
1926static DEVICE_ATTR(refresh, S_IWUSR, NULL, rbd_image_refresh); 1949static DEVICE_ATTR(refresh, S_IWUSR, NULL, rbd_image_refresh);
1927static DEVICE_ATTR(current_snap, S_IRUGO, rbd_snap_show, NULL); 1950static DEVICE_ATTR(current_snap, S_IRUGO, rbd_snap_show, NULL);
1928static DEVICE_ATTR(create_snap, S_IWUSR, NULL, rbd_snap_add);
1929 1951
1930static struct attribute *rbd_attrs[] = { 1952static struct attribute *rbd_attrs[] = {
1931 &dev_attr_size.attr, 1953 &dev_attr_size.attr,
1954 &dev_attr_features.attr,
1932 &dev_attr_major.attr, 1955 &dev_attr_major.attr,
1933 &dev_attr_client_id.attr, 1956 &dev_attr_client_id.attr,
1934 &dev_attr_pool.attr, 1957 &dev_attr_pool.attr,
1935 &dev_attr_pool_id.attr, 1958 &dev_attr_pool_id.attr,
1936 &dev_attr_name.attr, 1959 &dev_attr_name.attr,
1960 &dev_attr_image_id.attr,
1937 &dev_attr_current_snap.attr, 1961 &dev_attr_current_snap.attr,
1938 &dev_attr_refresh.attr, 1962 &dev_attr_refresh.attr,
1939 &dev_attr_create_snap.attr,
1940 NULL 1963 NULL
1941}; 1964};
1942 1965
@@ -1982,12 +2005,24 @@ static ssize_t rbd_snap_id_show(struct device *dev,
1982 return sprintf(buf, "%llu\n", (unsigned long long)snap->id); 2005 return sprintf(buf, "%llu\n", (unsigned long long)snap->id);
1983} 2006}
1984 2007
2008static ssize_t rbd_snap_features_show(struct device *dev,
2009 struct device_attribute *attr,
2010 char *buf)
2011{
2012 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
2013
2014 return sprintf(buf, "0x%016llx\n",
2015 (unsigned long long) snap->features);
2016}
2017
1985static DEVICE_ATTR(snap_size, S_IRUGO, rbd_snap_size_show, NULL); 2018static DEVICE_ATTR(snap_size, S_IRUGO, rbd_snap_size_show, NULL);
1986static DEVICE_ATTR(snap_id, S_IRUGO, rbd_snap_id_show, NULL); 2019static DEVICE_ATTR(snap_id, S_IRUGO, rbd_snap_id_show, NULL);
2020static DEVICE_ATTR(snap_features, S_IRUGO, rbd_snap_features_show, NULL);
1987 2021
1988static struct attribute *rbd_snap_attrs[] = { 2022static struct attribute *rbd_snap_attrs[] = {
1989 &dev_attr_snap_size.attr, 2023 &dev_attr_snap_size.attr,
1990 &dev_attr_snap_id.attr, 2024 &dev_attr_snap_id.attr,
2025 &dev_attr_snap_features.attr,
1991 NULL, 2026 NULL,
1992}; 2027};
1993 2028
@@ -2012,10 +2047,21 @@ static struct device_type rbd_snap_device_type = {
2012 .release = rbd_snap_dev_release, 2047 .release = rbd_snap_dev_release,
2013}; 2048};
2014 2049
2050static bool rbd_snap_registered(struct rbd_snap *snap)
2051{
2052 bool ret = snap->dev.type == &rbd_snap_device_type;
2053 bool reg = device_is_registered(&snap->dev);
2054
2055 rbd_assert(!ret ^ reg);
2056
2057 return ret;
2058}
2059
2015static void __rbd_remove_snap_dev(struct rbd_snap *snap) 2060static void __rbd_remove_snap_dev(struct rbd_snap *snap)
2016{ 2061{
2017 list_del(&snap->node); 2062 list_del(&snap->node);
2018 device_unregister(&snap->dev); 2063 if (device_is_registered(&snap->dev))
2064 device_unregister(&snap->dev);
2019} 2065}
2020 2066
2021static int rbd_register_snap_dev(struct rbd_snap *snap, 2067static int rbd_register_snap_dev(struct rbd_snap *snap,
@@ -2028,13 +2074,17 @@ static int rbd_register_snap_dev(struct rbd_snap *snap,
2028 dev->parent = parent; 2074 dev->parent = parent;
2029 dev->release = rbd_snap_dev_release; 2075 dev->release = rbd_snap_dev_release;
2030 dev_set_name(dev, "snap_%s", snap->name); 2076 dev_set_name(dev, "snap_%s", snap->name);
2077 dout("%s: registering device for snapshot %s\n", __func__, snap->name);
2078
2031 ret = device_register(dev); 2079 ret = device_register(dev);
2032 2080
2033 return ret; 2081 return ret;
2034} 2082}
2035 2083
2036static struct rbd_snap *__rbd_add_snap_dev(struct rbd_device *rbd_dev, 2084static struct rbd_snap *__rbd_add_snap_dev(struct rbd_device *rbd_dev,
2037 int i, const char *name) 2085 const char *snap_name,
2086 u64 snap_id, u64 snap_size,
2087 u64 snap_features)
2038{ 2088{
2039 struct rbd_snap *snap; 2089 struct rbd_snap *snap;
2040 int ret; 2090 int ret;
@@ -2044,17 +2094,13 @@ static struct rbd_snap *__rbd_add_snap_dev(struct rbd_device *rbd_dev,
2044 return ERR_PTR(-ENOMEM); 2094 return ERR_PTR(-ENOMEM);
2045 2095
2046 ret = -ENOMEM; 2096 ret = -ENOMEM;
2047 snap->name = kstrdup(name, GFP_KERNEL); 2097 snap->name = kstrdup(snap_name, GFP_KERNEL);
2048 if (!snap->name) 2098 if (!snap->name)
2049 goto err; 2099 goto err;
2050 2100
2051 snap->size = rbd_dev->header.snap_sizes[i]; 2101 snap->id = snap_id;
2052 snap->id = rbd_dev->header.snapc->snaps[i]; 2102 snap->size = snap_size;
2053 if (device_is_registered(&rbd_dev->dev)) { 2103 snap->features = snap_features;
2054 ret = rbd_register_snap_dev(snap, &rbd_dev->dev);
2055 if (ret < 0)
2056 goto err;
2057 }
2058 2104
2059 return snap; 2105 return snap;
2060 2106
@@ -2065,128 +2111,439 @@ err:
2065 return ERR_PTR(ret); 2111 return ERR_PTR(ret);
2066} 2112}
2067 2113
2114static char *rbd_dev_v1_snap_info(struct rbd_device *rbd_dev, u32 which,
2115 u64 *snap_size, u64 *snap_features)
2116{
2117 char *snap_name;
2118
2119 rbd_assert(which < rbd_dev->header.snapc->num_snaps);
2120
2121 *snap_size = rbd_dev->header.snap_sizes[which];
2122 *snap_features = 0; /* No features for v1 */
2123
2124 /* Skip over names until we find the one we are looking for */
2125
2126 snap_name = rbd_dev->header.snap_names;
2127 while (which--)
2128 snap_name += strlen(snap_name) + 1;
2129
2130 return snap_name;
2131}
2132
2068/* 2133/*
2069 * search for the previous snap in a null delimited string list 2134 * Get the size and object order for an image snapshot, or if
2135 * snap_id is CEPH_NOSNAP, gets this information for the base
2136 * image.
2070 */ 2137 */
2071const char *rbd_prev_snap_name(const char *name, const char *start) 2138static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
2139 u8 *order, u64 *snap_size)
2072{ 2140{
2073 if (name < start + 2) 2141 __le64 snapid = cpu_to_le64(snap_id);
2074 return NULL; 2142 int ret;
2143 struct {
2144 u8 order;
2145 __le64 size;
2146 } __attribute__ ((packed)) size_buf = { 0 };
2147
2148 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2149 "rbd", "get_size",
2150 (char *) &snapid, sizeof (snapid),
2151 (char *) &size_buf, sizeof (size_buf),
2152 CEPH_OSD_FLAG_READ, NULL);
2153 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2154 if (ret < 0)
2155 return ret;
2156
2157 *order = size_buf.order;
2158 *snap_size = le64_to_cpu(size_buf.size);
2159
2160 dout(" snap_id 0x%016llx order = %u, snap_size = %llu\n",
2161 (unsigned long long) snap_id, (unsigned int) *order,
2162 (unsigned long long) *snap_size);
2163
2164 return 0;
2165}
2166
2167static int rbd_dev_v2_image_size(struct rbd_device *rbd_dev)
2168{
2169 return _rbd_dev_v2_snap_size(rbd_dev, CEPH_NOSNAP,
2170 &rbd_dev->header.obj_order,
2171 &rbd_dev->header.image_size);
2172}
2173
2174static int rbd_dev_v2_object_prefix(struct rbd_device *rbd_dev)
2175{
2176 void *reply_buf;
2177 int ret;
2178 void *p;
2179
2180 reply_buf = kzalloc(RBD_OBJ_PREFIX_LEN_MAX, GFP_KERNEL);
2181 if (!reply_buf)
2182 return -ENOMEM;
2183
2184 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2185 "rbd", "get_object_prefix",
2186 NULL, 0,
2187 reply_buf, RBD_OBJ_PREFIX_LEN_MAX,
2188 CEPH_OSD_FLAG_READ, NULL);
2189 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2190 if (ret < 0)
2191 goto out;
2192
2193 p = reply_buf;
2194 rbd_dev->header.object_prefix = ceph_extract_encoded_string(&p,
2195 p + RBD_OBJ_PREFIX_LEN_MAX,
2196 NULL, GFP_NOIO);
2197
2198 if (IS_ERR(rbd_dev->header.object_prefix)) {
2199 ret = PTR_ERR(rbd_dev->header.object_prefix);
2200 rbd_dev->header.object_prefix = NULL;
2201 } else {
2202 dout(" object_prefix = %s\n", rbd_dev->header.object_prefix);
2203 }
2075 2204
2076 name -= 2; 2205out:
2077 while (*name) { 2206 kfree(reply_buf);
2078 if (name == start) 2207
2079 return start; 2208 return ret;
2080 name--; 2209}
2210
2211static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
2212 u64 *snap_features)
2213{
2214 __le64 snapid = cpu_to_le64(snap_id);
2215 struct {
2216 __le64 features;
2217 __le64 incompat;
2218 } features_buf = { 0 };
2219 int ret;
2220
2221 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2222 "rbd", "get_features",
2223 (char *) &snapid, sizeof (snapid),
2224 (char *) &features_buf, sizeof (features_buf),
2225 CEPH_OSD_FLAG_READ, NULL);
2226 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2227 if (ret < 0)
2228 return ret;
2229 *snap_features = le64_to_cpu(features_buf.features);
2230
2231 dout(" snap_id 0x%016llx features = 0x%016llx incompat = 0x%016llx\n",
2232 (unsigned long long) snap_id,
2233 (unsigned long long) *snap_features,
2234 (unsigned long long) le64_to_cpu(features_buf.incompat));
2235
2236 return 0;
2237}
2238
2239static int rbd_dev_v2_features(struct rbd_device *rbd_dev)
2240{
2241 return _rbd_dev_v2_snap_features(rbd_dev, CEPH_NOSNAP,
2242 &rbd_dev->header.features);
2243}
2244
2245static int rbd_dev_v2_snap_context(struct rbd_device *rbd_dev, u64 *ver)
2246{
2247 size_t size;
2248 int ret;
2249 void *reply_buf;
2250 void *p;
2251 void *end;
2252 u64 seq;
2253 u32 snap_count;
2254 struct ceph_snap_context *snapc;
2255 u32 i;
2256
2257 /*
2258 * We'll need room for the seq value (maximum snapshot id),
2259 * snapshot count, and array of that many snapshot ids.
2260 * For now we have a fixed upper limit on the number we're
2261 * prepared to receive.
2262 */
2263 size = sizeof (__le64) + sizeof (__le32) +
2264 RBD_MAX_SNAP_COUNT * sizeof (__le64);
2265 reply_buf = kzalloc(size, GFP_KERNEL);
2266 if (!reply_buf)
2267 return -ENOMEM;
2268
2269 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2270 "rbd", "get_snapcontext",
2271 NULL, 0,
2272 reply_buf, size,
2273 CEPH_OSD_FLAG_READ, ver);
2274 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2275 if (ret < 0)
2276 goto out;
2277
2278 ret = -ERANGE;
2279 p = reply_buf;
2280 end = (char *) reply_buf + size;
2281 ceph_decode_64_safe(&p, end, seq, out);
2282 ceph_decode_32_safe(&p, end, snap_count, out);
2283
2284 /*
2285 * Make sure the reported number of snapshot ids wouldn't go
2286 * beyond the end of our buffer. But before checking that,
2287 * make sure the computed size of the snapshot context we
2288 * allocate is representable in a size_t.
2289 */
2290 if (snap_count > (SIZE_MAX - sizeof (struct ceph_snap_context))
2291 / sizeof (u64)) {
2292 ret = -EINVAL;
2293 goto out;
2081 } 2294 }
2082 return name + 1; 2295 if (!ceph_has_room(&p, end, snap_count * sizeof (__le64)))
2296 goto out;
2297
2298 size = sizeof (struct ceph_snap_context) +
2299 snap_count * sizeof (snapc->snaps[0]);
2300 snapc = kmalloc(size, GFP_KERNEL);
2301 if (!snapc) {
2302 ret = -ENOMEM;
2303 goto out;
2304 }
2305
2306 atomic_set(&snapc->nref, 1);
2307 snapc->seq = seq;
2308 snapc->num_snaps = snap_count;
2309 for (i = 0; i < snap_count; i++)
2310 snapc->snaps[i] = ceph_decode_64(&p);
2311
2312 rbd_dev->header.snapc = snapc;
2313
2314 dout(" snap context seq = %llu, snap_count = %u\n",
2315 (unsigned long long) seq, (unsigned int) snap_count);
2316
2317out:
2318 kfree(reply_buf);
2319
2320 return 0;
2083} 2321}
2084 2322
2085/* 2323static char *rbd_dev_v2_snap_name(struct rbd_device *rbd_dev, u32 which)
2086 * compare the old list of snapshots that we have to what's in the header
2087 * and update it accordingly. Note that the header holds the snapshots
2088 * in a reverse order (from newest to oldest) and we need to go from
2089 * older to new so that we don't get a duplicate snap name when
2090 * doing the process (e.g., removed snapshot and recreated a new
2091 * one with the same name.
2092 */
2093static int __rbd_init_snaps_header(struct rbd_device *rbd_dev)
2094{ 2324{
2095 const char *name, *first_name; 2325 size_t size;
2096 int i = rbd_dev->header.total_snaps; 2326 void *reply_buf;
2097 struct rbd_snap *snap, *old_snap = NULL; 2327 __le64 snap_id;
2098 struct list_head *p, *n; 2328 int ret;
2329 void *p;
2330 void *end;
2331 size_t snap_name_len;
2332 char *snap_name;
2333
2334 size = sizeof (__le32) + RBD_MAX_SNAP_NAME_LEN;
2335 reply_buf = kmalloc(size, GFP_KERNEL);
2336 if (!reply_buf)
2337 return ERR_PTR(-ENOMEM);
2099 2338
2100 first_name = rbd_dev->header.snap_names; 2339 snap_id = cpu_to_le64(rbd_dev->header.snapc->snaps[which]);
2101 name = first_name + rbd_dev->header.snap_names_len; 2340 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
2341 "rbd", "get_snapshot_name",
2342 (char *) &snap_id, sizeof (snap_id),
2343 reply_buf, size,
2344 CEPH_OSD_FLAG_READ, NULL);
2345 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2346 if (ret < 0)
2347 goto out;
2102 2348
2103 list_for_each_prev_safe(p, n, &rbd_dev->snaps) { 2349 p = reply_buf;
2104 u64 cur_id; 2350 end = (char *) reply_buf + size;
2351 snap_name_len = 0;
2352 snap_name = ceph_extract_encoded_string(&p, end, &snap_name_len,
2353 GFP_KERNEL);
2354 if (IS_ERR(snap_name)) {
2355 ret = PTR_ERR(snap_name);
2356 goto out;
2357 } else {
2358 dout(" snap_id 0x%016llx snap_name = %s\n",
2359 (unsigned long long) le64_to_cpu(snap_id), snap_name);
2360 }
2361 kfree(reply_buf);
2105 2362
2106 old_snap = list_entry(p, struct rbd_snap, node); 2363 return snap_name;
2364out:
2365 kfree(reply_buf);
2107 2366
2108 if (i) 2367 return ERR_PTR(ret);
2109 cur_id = rbd_dev->header.snapc->snaps[i - 1]; 2368}
2110 2369
2111 if (!i || old_snap->id < cur_id) { 2370static char *rbd_dev_v2_snap_info(struct rbd_device *rbd_dev, u32 which,
2112 /* 2371 u64 *snap_size, u64 *snap_features)
2113 * old_snap->id was skipped, thus was 2372{
2114 * removed. If this rbd_dev is mapped to 2373 __le64 snap_id;
2115 * the removed snapshot, record that it no 2374 u8 order;
2116 * longer exists, to prevent further I/O. 2375 int ret;
2117 */ 2376
2118 if (rbd_dev->snap_id == old_snap->id) 2377 snap_id = rbd_dev->header.snapc->snaps[which];
2119 rbd_dev->snap_exists = false; 2378 ret = _rbd_dev_v2_snap_size(rbd_dev, snap_id, &order, snap_size);
2120 __rbd_remove_snap_dev(old_snap); 2379 if (ret)
2121 continue; 2380 return ERR_PTR(ret);
2122 } 2381 ret = _rbd_dev_v2_snap_features(rbd_dev, snap_id, snap_features);
2123 if (old_snap->id == cur_id) { 2382 if (ret)
2124 /* we have this snapshot already */ 2383 return ERR_PTR(ret);
2125 i--; 2384
2126 name = rbd_prev_snap_name(name, first_name); 2385 return rbd_dev_v2_snap_name(rbd_dev, which);
2386}
2387
2388static char *rbd_dev_snap_info(struct rbd_device *rbd_dev, u32 which,
2389 u64 *snap_size, u64 *snap_features)
2390{
2391 if (rbd_dev->image_format == 1)
2392 return rbd_dev_v1_snap_info(rbd_dev, which,
2393 snap_size, snap_features);
2394 if (rbd_dev->image_format == 2)
2395 return rbd_dev_v2_snap_info(rbd_dev, which,
2396 snap_size, snap_features);
2397 return ERR_PTR(-EINVAL);
2398}
2399
2400/*
2401 * Scan the rbd device's current snapshot list and compare it to the
2402 * newly-received snapshot context. Remove any existing snapshots
2403 * not present in the new snapshot context. Add a new snapshot for
2404 * any snaphots in the snapshot context not in the current list.
2405 * And verify there are no changes to snapshots we already know
2406 * about.
2407 *
2408 * Assumes the snapshots in the snapshot context are sorted by
2409 * snapshot id, highest id first. (Snapshots in the rbd_dev's list
2410 * are also maintained in that order.)
2411 */
2412static int rbd_dev_snaps_update(struct rbd_device *rbd_dev)
2413{
2414 struct ceph_snap_context *snapc = rbd_dev->header.snapc;
2415 const u32 snap_count = snapc->num_snaps;
2416 struct list_head *head = &rbd_dev->snaps;
2417 struct list_head *links = head->next;
2418 u32 index = 0;
2419
2420 dout("%s: snap count is %u\n", __func__, (unsigned int) snap_count);
2421 while (index < snap_count || links != head) {
2422 u64 snap_id;
2423 struct rbd_snap *snap;
2424 char *snap_name;
2425 u64 snap_size = 0;
2426 u64 snap_features = 0;
2427
2428 snap_id = index < snap_count ? snapc->snaps[index]
2429 : CEPH_NOSNAP;
2430 snap = links != head ? list_entry(links, struct rbd_snap, node)
2431 : NULL;
2432 rbd_assert(!snap || snap->id != CEPH_NOSNAP);
2433
2434 if (snap_id == CEPH_NOSNAP || (snap && snap->id > snap_id)) {
2435 struct list_head *next = links->next;
2436
2437 /* Existing snapshot not in the new snap context */
2438
2439 if (rbd_dev->mapping.snap_id == snap->id)
2440 rbd_dev->mapping.snap_exists = false;
2441 __rbd_remove_snap_dev(snap);
2442 dout("%ssnap id %llu has been removed\n",
2443 rbd_dev->mapping.snap_id == snap->id ?
2444 "mapped " : "",
2445 (unsigned long long) snap->id);
2446
2447 /* Done with this list entry; advance */
2448
2449 links = next;
2127 continue; 2450 continue;
2128 } 2451 }
2129 for (; i > 0; 2452
2130 i--, name = rbd_prev_snap_name(name, first_name)) { 2453 snap_name = rbd_dev_snap_info(rbd_dev, index,
2131 if (!name) { 2454 &snap_size, &snap_features);
2132 WARN_ON(1); 2455 if (IS_ERR(snap_name))
2133 return -EINVAL; 2456 return PTR_ERR(snap_name);
2457
2458 dout("entry %u: snap_id = %llu\n", (unsigned int) snap_count,
2459 (unsigned long long) snap_id);
2460 if (!snap || (snap_id != CEPH_NOSNAP && snap->id < snap_id)) {
2461 struct rbd_snap *new_snap;
2462
2463 /* We haven't seen this snapshot before */
2464
2465 new_snap = __rbd_add_snap_dev(rbd_dev, snap_name,
2466 snap_id, snap_size, snap_features);
2467 if (IS_ERR(new_snap)) {
2468 int err = PTR_ERR(new_snap);
2469
2470 dout(" failed to add dev, error %d\n", err);
2471
2472 return err;
2134 } 2473 }
2135 cur_id = rbd_dev->header.snapc->snaps[i]; 2474
2136 /* snapshot removal? handle it above */ 2475 /* New goes before existing, or at end of list */
2137 if (cur_id >= old_snap->id) 2476
2138 break; 2477 dout(" added dev%s\n", snap ? "" : " at end\n");
2139 /* a new snapshot */ 2478 if (snap)
2140 snap = __rbd_add_snap_dev(rbd_dev, i - 1, name); 2479 list_add_tail(&new_snap->node, &snap->node);
2141 if (IS_ERR(snap)) 2480 else
2142 return PTR_ERR(snap); 2481 list_add_tail(&new_snap->node, head);
2143 2482 } else {
2144 /* note that we add it backward so using n and not p */ 2483 /* Already have this one */
2145 list_add(&snap->node, n); 2484
2146 p = &snap->node; 2485 dout(" already present\n");
2486
2487 rbd_assert(snap->size == snap_size);
2488 rbd_assert(!strcmp(snap->name, snap_name));
2489 rbd_assert(snap->features == snap_features);
2490
2491 /* Done with this list entry; advance */
2492
2493 links = links->next;
2147 } 2494 }
2495
2496 /* Advance to the next entry in the snapshot context */
2497
2498 index++;
2148 } 2499 }
2149 /* we're done going over the old snap list, just add what's left */ 2500 dout("%s: done\n", __func__);
2150 for (; i > 0; i--) { 2501
2151 name = rbd_prev_snap_name(name, first_name); 2502 return 0;
2152 if (!name) { 2503}
2153 WARN_ON(1); 2504
2154 return -EINVAL; 2505/*
2506 * Scan the list of snapshots and register the devices for any that
2507 * have not already been registered.
2508 */
2509static int rbd_dev_snaps_register(struct rbd_device *rbd_dev)
2510{
2511 struct rbd_snap *snap;
2512 int ret = 0;
2513
2514 dout("%s called\n", __func__);
2515 if (WARN_ON(!device_is_registered(&rbd_dev->dev)))
2516 return -EIO;
2517
2518 list_for_each_entry(snap, &rbd_dev->snaps, node) {
2519 if (!rbd_snap_registered(snap)) {
2520 ret = rbd_register_snap_dev(snap, &rbd_dev->dev);
2521 if (ret < 0)
2522 break;
2155 } 2523 }
2156 snap = __rbd_add_snap_dev(rbd_dev, i - 1, name);
2157 if (IS_ERR(snap))
2158 return PTR_ERR(snap);
2159 list_add(&snap->node, &rbd_dev->snaps);
2160 } 2524 }
2525 dout("%s: returning %d\n", __func__, ret);
2161 2526
2162 return 0; 2527 return ret;
2163} 2528}
2164 2529
2165static int rbd_bus_add_dev(struct rbd_device *rbd_dev) 2530static int rbd_bus_add_dev(struct rbd_device *rbd_dev)
2166{ 2531{
2167 int ret;
2168 struct device *dev; 2532 struct device *dev;
2169 struct rbd_snap *snap; 2533 int ret;
2170 2534
2171 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING); 2535 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
2172 dev = &rbd_dev->dev;
2173 2536
2537 dev = &rbd_dev->dev;
2174 dev->bus = &rbd_bus_type; 2538 dev->bus = &rbd_bus_type;
2175 dev->type = &rbd_device_type; 2539 dev->type = &rbd_device_type;
2176 dev->parent = &rbd_root_dev; 2540 dev->parent = &rbd_root_dev;
2177 dev->release = rbd_dev_release; 2541 dev->release = rbd_dev_release;
2178 dev_set_name(dev, "%d", rbd_dev->dev_id); 2542 dev_set_name(dev, "%d", rbd_dev->dev_id);
2179 ret = device_register(dev); 2543 ret = device_register(dev);
2180 if (ret < 0)
2181 goto out;
2182 2544
2183 list_for_each_entry(snap, &rbd_dev->snaps, node) {
2184 ret = rbd_register_snap_dev(snap, &rbd_dev->dev);
2185 if (ret < 0)
2186 break;
2187 }
2188out:
2189 mutex_unlock(&ctl_mutex); 2545 mutex_unlock(&ctl_mutex);
2546
2190 return ret; 2547 return ret;
2191} 2548}
2192 2549
@@ -2211,33 +2568,37 @@ static int rbd_init_watch_dev(struct rbd_device *rbd_dev)
2211 return ret; 2568 return ret;
2212} 2569}
2213 2570
2214static atomic64_t rbd_id_max = ATOMIC64_INIT(0); 2571static atomic64_t rbd_dev_id_max = ATOMIC64_INIT(0);
2215 2572
2216/* 2573/*
2217 * Get a unique rbd identifier for the given new rbd_dev, and add 2574 * Get a unique rbd identifier for the given new rbd_dev, and add
2218 * the rbd_dev to the global list. The minimum rbd id is 1. 2575 * the rbd_dev to the global list. The minimum rbd id is 1.
2219 */ 2576 */
2220static void rbd_id_get(struct rbd_device *rbd_dev) 2577static void rbd_dev_id_get(struct rbd_device *rbd_dev)
2221{ 2578{
2222 rbd_dev->dev_id = atomic64_inc_return(&rbd_id_max); 2579 rbd_dev->dev_id = atomic64_inc_return(&rbd_dev_id_max);
2223 2580
2224 spin_lock(&rbd_dev_list_lock); 2581 spin_lock(&rbd_dev_list_lock);
2225 list_add_tail(&rbd_dev->node, &rbd_dev_list); 2582 list_add_tail(&rbd_dev->node, &rbd_dev_list);
2226 spin_unlock(&rbd_dev_list_lock); 2583 spin_unlock(&rbd_dev_list_lock);
2584 dout("rbd_dev %p given dev id %llu\n", rbd_dev,
2585 (unsigned long long) rbd_dev->dev_id);
2227} 2586}
2228 2587
2229/* 2588/*
2230 * Remove an rbd_dev from the global list, and record that its 2589 * Remove an rbd_dev from the global list, and record that its
2231 * identifier is no longer in use. 2590 * identifier is no longer in use.
2232 */ 2591 */
2233static void rbd_id_put(struct rbd_device *rbd_dev) 2592static void rbd_dev_id_put(struct rbd_device *rbd_dev)
2234{ 2593{
2235 struct list_head *tmp; 2594 struct list_head *tmp;
2236 int rbd_id = rbd_dev->dev_id; 2595 int rbd_id = rbd_dev->dev_id;
2237 int max_id; 2596 int max_id;
2238 2597
2239 BUG_ON(rbd_id < 1); 2598 rbd_assert(rbd_id > 0);
2240 2599
2600 dout("rbd_dev %p released dev id %llu\n", rbd_dev,
2601 (unsigned long long) rbd_dev->dev_id);
2241 spin_lock(&rbd_dev_list_lock); 2602 spin_lock(&rbd_dev_list_lock);
2242 list_del_init(&rbd_dev->node); 2603 list_del_init(&rbd_dev->node);
2243 2604
@@ -2245,7 +2606,7 @@ static void rbd_id_put(struct rbd_device *rbd_dev)
2245 * If the id being "put" is not the current maximum, there 2606 * If the id being "put" is not the current maximum, there
2246 * is nothing special we need to do. 2607 * is nothing special we need to do.
2247 */ 2608 */
2248 if (rbd_id != atomic64_read(&rbd_id_max)) { 2609 if (rbd_id != atomic64_read(&rbd_dev_id_max)) {
2249 spin_unlock(&rbd_dev_list_lock); 2610 spin_unlock(&rbd_dev_list_lock);
2250 return; 2611 return;
2251 } 2612 }
@@ -2266,12 +2627,13 @@ static void rbd_id_put(struct rbd_device *rbd_dev)
2266 spin_unlock(&rbd_dev_list_lock); 2627 spin_unlock(&rbd_dev_list_lock);
2267 2628
2268 /* 2629 /*
2269 * The max id could have been updated by rbd_id_get(), in 2630 * The max id could have been updated by rbd_dev_id_get(), in
2270 * which case it now accurately reflects the new maximum. 2631 * which case it now accurately reflects the new maximum.
2271 * Be careful not to overwrite the maximum value in that 2632 * Be careful not to overwrite the maximum value in that
2272 * case. 2633 * case.
2273 */ 2634 */
2274 atomic64_cmpxchg(&rbd_id_max, rbd_id, max_id); 2635 atomic64_cmpxchg(&rbd_dev_id_max, rbd_id, max_id);
2636 dout(" max dev id has been reset\n");
2275} 2637}
2276 2638
2277/* 2639/*
@@ -2360,28 +2722,31 @@ static inline char *dup_token(const char **buf, size_t *lenp)
2360} 2722}
2361 2723
2362/* 2724/*
2363 * This fills in the pool_name, image_name, image_name_len, snap_name, 2725 * This fills in the pool_name, image_name, image_name_len, rbd_dev,
2364 * rbd_dev, rbd_md_name, and name fields of the given rbd_dev, based 2726 * rbd_md_name, and name fields of the given rbd_dev, based on the
2365 * on the list of monitor addresses and other options provided via 2727 * list of monitor addresses and other options provided via
2366 * /sys/bus/rbd/add. 2728 * /sys/bus/rbd/add. Returns a pointer to a dynamically-allocated
2729 * copy of the snapshot name to map if successful, or a
2730 * pointer-coded error otherwise.
2367 * 2731 *
2368 * Note: rbd_dev is assumed to have been initially zero-filled. 2732 * Note: rbd_dev is assumed to have been initially zero-filled.
2369 */ 2733 */
2370static int rbd_add_parse_args(struct rbd_device *rbd_dev, 2734static char *rbd_add_parse_args(struct rbd_device *rbd_dev,
2371 const char *buf, 2735 const char *buf,
2372 const char **mon_addrs, 2736 const char **mon_addrs,
2373 size_t *mon_addrs_size, 2737 size_t *mon_addrs_size,
2374 char *options, 2738 char *options,
2375 size_t options_size) 2739 size_t options_size)
2376{ 2740{
2377 size_t len; 2741 size_t len;
2378 int ret; 2742 char *err_ptr = ERR_PTR(-EINVAL);
2743 char *snap_name;
2379 2744
2380 /* The first four tokens are required */ 2745 /* The first four tokens are required */
2381 2746
2382 len = next_token(&buf); 2747 len = next_token(&buf);
2383 if (!len) 2748 if (!len)
2384 return -EINVAL; 2749 return err_ptr;
2385 *mon_addrs_size = len + 1; 2750 *mon_addrs_size = len + 1;
2386 *mon_addrs = buf; 2751 *mon_addrs = buf;
2387 2752
@@ -2389,9 +2754,9 @@ static int rbd_add_parse_args(struct rbd_device *rbd_dev,
2389 2754
2390 len = copy_token(&buf, options, options_size); 2755 len = copy_token(&buf, options, options_size);
2391 if (!len || len >= options_size) 2756 if (!len || len >= options_size)
2392 return -EINVAL; 2757 return err_ptr;
2393 2758
2394 ret = -ENOMEM; 2759 err_ptr = ERR_PTR(-ENOMEM);
2395 rbd_dev->pool_name = dup_token(&buf, NULL); 2760 rbd_dev->pool_name = dup_token(&buf, NULL);
2396 if (!rbd_dev->pool_name) 2761 if (!rbd_dev->pool_name)
2397 goto out_err; 2762 goto out_err;
@@ -2400,41 +2765,227 @@ static int rbd_add_parse_args(struct rbd_device *rbd_dev,
2400 if (!rbd_dev->image_name) 2765 if (!rbd_dev->image_name)
2401 goto out_err; 2766 goto out_err;
2402 2767
2403 /* Create the name of the header object */ 2768 /* Snapshot name is optional */
2769 len = next_token(&buf);
2770 if (!len) {
2771 buf = RBD_SNAP_HEAD_NAME; /* No snapshot supplied */
2772 len = sizeof (RBD_SNAP_HEAD_NAME) - 1;
2773 }
2774 snap_name = kmalloc(len + 1, GFP_KERNEL);
2775 if (!snap_name)
2776 goto out_err;
2777 memcpy(snap_name, buf, len);
2778 *(snap_name + len) = '\0';
2404 2779
2405 rbd_dev->header_name = kmalloc(rbd_dev->image_name_len 2780dout(" SNAP_NAME is <%s>, len is %zd\n", snap_name, len);
2406 + sizeof (RBD_SUFFIX), 2781
2407 GFP_KERNEL); 2782 return snap_name;
2408 if (!rbd_dev->header_name) 2783
2784out_err:
2785 kfree(rbd_dev->image_name);
2786 rbd_dev->image_name = NULL;
2787 rbd_dev->image_name_len = 0;
2788 kfree(rbd_dev->pool_name);
2789 rbd_dev->pool_name = NULL;
2790
2791 return err_ptr;
2792}
2793
2794/*
2795 * An rbd format 2 image has a unique identifier, distinct from the
2796 * name given to it by the user. Internally, that identifier is
2797 * what's used to specify the names of objects related to the image.
2798 *
2799 * A special "rbd id" object is used to map an rbd image name to its
2800 * id. If that object doesn't exist, then there is no v2 rbd image
2801 * with the supplied name.
2802 *
2803 * This function will record the given rbd_dev's image_id field if
2804 * it can be determined, and in that case will return 0. If any
2805 * errors occur a negative errno will be returned and the rbd_dev's
2806 * image_id field will be unchanged (and should be NULL).
2807 */
2808static int rbd_dev_image_id(struct rbd_device *rbd_dev)
2809{
2810 int ret;
2811 size_t size;
2812 char *object_name;
2813 void *response;
2814 void *p;
2815
2816 /*
2817 * First, see if the format 2 image id file exists, and if
2818 * so, get the image's persistent id from it.
2819 */
2820 size = sizeof (RBD_ID_PREFIX) + rbd_dev->image_name_len;
2821 object_name = kmalloc(size, GFP_NOIO);
2822 if (!object_name)
2823 return -ENOMEM;
2824 sprintf(object_name, "%s%s", RBD_ID_PREFIX, rbd_dev->image_name);
2825 dout("rbd id object name is %s\n", object_name);
2826
2827 /* Response will be an encoded string, which includes a length */
2828
2829 size = sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX;
2830 response = kzalloc(size, GFP_NOIO);
2831 if (!response) {
2832 ret = -ENOMEM;
2833 goto out;
2834 }
2835
2836 ret = rbd_req_sync_exec(rbd_dev, object_name,
2837 "rbd", "get_id",
2838 NULL, 0,
2839 response, RBD_IMAGE_ID_LEN_MAX,
2840 CEPH_OSD_FLAG_READ, NULL);
2841 dout("%s: rbd_req_sync_exec returned %d\n", __func__, ret);
2842 if (ret < 0)
2843 goto out;
2844
2845 p = response;
2846 rbd_dev->image_id = ceph_extract_encoded_string(&p,
2847 p + RBD_IMAGE_ID_LEN_MAX,
2848 &rbd_dev->image_id_len,
2849 GFP_NOIO);
2850 if (IS_ERR(rbd_dev->image_id)) {
2851 ret = PTR_ERR(rbd_dev->image_id);
2852 rbd_dev->image_id = NULL;
2853 } else {
2854 dout("image_id is %s\n", rbd_dev->image_id);
2855 }
2856out:
2857 kfree(response);
2858 kfree(object_name);
2859
2860 return ret;
2861}
2862
2863static int rbd_dev_v1_probe(struct rbd_device *rbd_dev)
2864{
2865 int ret;
2866 size_t size;
2867
2868 /* Version 1 images have no id; empty string is used */
2869
2870 rbd_dev->image_id = kstrdup("", GFP_KERNEL);
2871 if (!rbd_dev->image_id)
2872 return -ENOMEM;
2873 rbd_dev->image_id_len = 0;
2874
2875 /* Record the header object name for this rbd image. */
2876
2877 size = rbd_dev->image_name_len + sizeof (RBD_SUFFIX);
2878 rbd_dev->header_name = kmalloc(size, GFP_KERNEL);
2879 if (!rbd_dev->header_name) {
2880 ret = -ENOMEM;
2409 goto out_err; 2881 goto out_err;
2882 }
2410 sprintf(rbd_dev->header_name, "%s%s", rbd_dev->image_name, RBD_SUFFIX); 2883 sprintf(rbd_dev->header_name, "%s%s", rbd_dev->image_name, RBD_SUFFIX);
2411 2884
2885 /* Populate rbd image metadata */
2886
2887 ret = rbd_read_header(rbd_dev, &rbd_dev->header);
2888 if (ret < 0)
2889 goto out_err;
2890 rbd_dev->image_format = 1;
2891
2892 dout("discovered version 1 image, header name is %s\n",
2893 rbd_dev->header_name);
2894
2895 return 0;
2896
2897out_err:
2898 kfree(rbd_dev->header_name);
2899 rbd_dev->header_name = NULL;
2900 kfree(rbd_dev->image_id);
2901 rbd_dev->image_id = NULL;
2902
2903 return ret;
2904}
2905
2906static int rbd_dev_v2_probe(struct rbd_device *rbd_dev)
2907{
2908 size_t size;
2909 int ret;
2910 u64 ver = 0;
2911
2412 /* 2912 /*
2413 * The snapshot name is optional. If none is is supplied, 2913 * Image id was filled in by the caller. Record the header
2414 * we use the default value. 2914 * object name for this rbd image.
2415 */ 2915 */
2416 rbd_dev->snap_name = dup_token(&buf, &len); 2916 size = sizeof (RBD_HEADER_PREFIX) + rbd_dev->image_id_len;
2417 if (!rbd_dev->snap_name) 2917 rbd_dev->header_name = kmalloc(size, GFP_KERNEL);
2918 if (!rbd_dev->header_name)
2919 return -ENOMEM;
2920 sprintf(rbd_dev->header_name, "%s%s",
2921 RBD_HEADER_PREFIX, rbd_dev->image_id);
2922
2923 /* Get the size and object order for the image */
2924
2925 ret = rbd_dev_v2_image_size(rbd_dev);
2926 if (ret < 0)
2418 goto out_err; 2927 goto out_err;
2419 if (!len) {
2420 /* Replace the empty name with the default */
2421 kfree(rbd_dev->snap_name);
2422 rbd_dev->snap_name
2423 = kmalloc(sizeof (RBD_SNAP_HEAD_NAME), GFP_KERNEL);
2424 if (!rbd_dev->snap_name)
2425 goto out_err;
2426 2928
2427 memcpy(rbd_dev->snap_name, RBD_SNAP_HEAD_NAME, 2929 /* Get the object prefix (a.k.a. block_name) for the image */
2428 sizeof (RBD_SNAP_HEAD_NAME));
2429 }
2430 2930
2431 return 0; 2931 ret = rbd_dev_v2_object_prefix(rbd_dev);
2932 if (ret < 0)
2933 goto out_err;
2934
2935 /* Get the features for the image */
2432 2936
2937 ret = rbd_dev_v2_features(rbd_dev);
2938 if (ret < 0)
2939 goto out_err;
2940
2941 /* crypto and compression type aren't (yet) supported for v2 images */
2942
2943 rbd_dev->header.crypt_type = 0;
2944 rbd_dev->header.comp_type = 0;
2945
2946 /* Get the snapshot context, plus the header version */
2947
2948 ret = rbd_dev_v2_snap_context(rbd_dev, &ver);
2949 if (ret)
2950 goto out_err;
2951 rbd_dev->header.obj_version = ver;
2952
2953 rbd_dev->image_format = 2;
2954
2955 dout("discovered version 2 image, header name is %s\n",
2956 rbd_dev->header_name);
2957
2958 return -ENOTSUPP;
2433out_err: 2959out_err:
2434 kfree(rbd_dev->header_name); 2960 kfree(rbd_dev->header_name);
2435 kfree(rbd_dev->image_name); 2961 rbd_dev->header_name = NULL;
2436 kfree(rbd_dev->pool_name); 2962 kfree(rbd_dev->header.object_prefix);
2437 rbd_dev->pool_name = NULL; 2963 rbd_dev->header.object_prefix = NULL;
2964
2965 return ret;
2966}
2967
2968/*
2969 * Probe for the existence of the header object for the given rbd
2970 * device. For format 2 images this includes determining the image
2971 * id.
2972 */
2973static int rbd_dev_probe(struct rbd_device *rbd_dev)
2974{
2975 int ret;
2976
2977 /*
2978 * Get the id from the image id object. If it's not a
2979 * format 2 image, we'll get ENOENT back, and we'll assume
2980 * it's a format 1 image.
2981 */
2982 ret = rbd_dev_image_id(rbd_dev);
2983 if (ret)
2984 ret = rbd_dev_v1_probe(rbd_dev);
2985 else
2986 ret = rbd_dev_v2_probe(rbd_dev);
2987 if (ret)
2988 dout("probe failed, returning %d\n", ret);
2438 2989
2439 return ret; 2990 return ret;
2440} 2991}
@@ -2449,16 +3000,17 @@ static ssize_t rbd_add(struct bus_type *bus,
2449 size_t mon_addrs_size = 0; 3000 size_t mon_addrs_size = 0;
2450 struct ceph_osd_client *osdc; 3001 struct ceph_osd_client *osdc;
2451 int rc = -ENOMEM; 3002 int rc = -ENOMEM;
3003 char *snap_name;
2452 3004
2453 if (!try_module_get(THIS_MODULE)) 3005 if (!try_module_get(THIS_MODULE))
2454 return -ENODEV; 3006 return -ENODEV;
2455 3007
2456 options = kmalloc(count, GFP_KERNEL); 3008 options = kmalloc(count, GFP_KERNEL);
2457 if (!options) 3009 if (!options)
2458 goto err_nomem; 3010 goto err_out_mem;
2459 rbd_dev = kzalloc(sizeof(*rbd_dev), GFP_KERNEL); 3011 rbd_dev = kzalloc(sizeof(*rbd_dev), GFP_KERNEL);
2460 if (!rbd_dev) 3012 if (!rbd_dev)
2461 goto err_nomem; 3013 goto err_out_mem;
2462 3014
2463 /* static rbd_device initialization */ 3015 /* static rbd_device initialization */
2464 spin_lock_init(&rbd_dev->lock); 3016 spin_lock_init(&rbd_dev->lock);
@@ -2466,27 +3018,18 @@ static ssize_t rbd_add(struct bus_type *bus,
2466 INIT_LIST_HEAD(&rbd_dev->snaps); 3018 INIT_LIST_HEAD(&rbd_dev->snaps);
2467 init_rwsem(&rbd_dev->header_rwsem); 3019 init_rwsem(&rbd_dev->header_rwsem);
2468 3020
2469 /* generate unique id: find highest unique id, add one */
2470 rbd_id_get(rbd_dev);
2471
2472 /* Fill in the device name, now that we have its id. */
2473 BUILD_BUG_ON(DEV_NAME_LEN
2474 < sizeof (RBD_DRV_NAME) + MAX_INT_FORMAT_WIDTH);
2475 sprintf(rbd_dev->name, "%s%d", RBD_DRV_NAME, rbd_dev->dev_id);
2476
2477 /* parse add command */ 3021 /* parse add command */
2478 rc = rbd_add_parse_args(rbd_dev, buf, &mon_addrs, &mon_addrs_size, 3022 snap_name = rbd_add_parse_args(rbd_dev, buf,
2479 options, count); 3023 &mon_addrs, &mon_addrs_size, options, count);
2480 if (rc) 3024 if (IS_ERR(snap_name)) {
2481 goto err_put_id; 3025 rc = PTR_ERR(snap_name);
2482 3026 goto err_out_mem;
2483 rbd_dev->rbd_client = rbd_get_client(mon_addrs, mon_addrs_size - 1,
2484 options);
2485 if (IS_ERR(rbd_dev->rbd_client)) {
2486 rc = PTR_ERR(rbd_dev->rbd_client);
2487 goto err_put_id;
2488 } 3027 }
2489 3028
3029 rc = rbd_get_client(rbd_dev, mon_addrs, mon_addrs_size - 1, options);
3030 if (rc < 0)
3031 goto err_out_args;
3032
2490 /* pick the pool */ 3033 /* pick the pool */
2491 osdc = &rbd_dev->rbd_client->client->osdc; 3034 osdc = &rbd_dev->rbd_client->client->osdc;
2492 rc = ceph_pg_poolid_by_name(osdc->osdmap, rbd_dev->pool_name); 3035 rc = ceph_pg_poolid_by_name(osdc->osdmap, rbd_dev->pool_name);
@@ -2494,23 +3037,53 @@ static ssize_t rbd_add(struct bus_type *bus,
2494 goto err_out_client; 3037 goto err_out_client;
2495 rbd_dev->pool_id = rc; 3038 rbd_dev->pool_id = rc;
2496 3039
2497 /* register our block device */ 3040 rc = rbd_dev_probe(rbd_dev);
2498 rc = register_blkdev(0, rbd_dev->name);
2499 if (rc < 0) 3041 if (rc < 0)
2500 goto err_out_client; 3042 goto err_out_client;
3043 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
3044
3045 /* no need to lock here, as rbd_dev is not registered yet */
3046 rc = rbd_dev_snaps_update(rbd_dev);
3047 if (rc)
3048 goto err_out_header;
3049
3050 rc = rbd_dev_set_mapping(rbd_dev, snap_name);
3051 if (rc)
3052 goto err_out_header;
3053
3054 /* generate unique id: find highest unique id, add one */
3055 rbd_dev_id_get(rbd_dev);
3056
3057 /* Fill in the device name, now that we have its id. */
3058 BUILD_BUG_ON(DEV_NAME_LEN
3059 < sizeof (RBD_DRV_NAME) + MAX_INT_FORMAT_WIDTH);
3060 sprintf(rbd_dev->name, "%s%d", RBD_DRV_NAME, rbd_dev->dev_id);
3061
3062 /* Get our block major device number. */
3063
3064 rc = register_blkdev(0, rbd_dev->name);
3065 if (rc < 0)
3066 goto err_out_id;
2501 rbd_dev->major = rc; 3067 rbd_dev->major = rc;
2502 3068
2503 rc = rbd_bus_add_dev(rbd_dev); 3069 /* Set up the blkdev mapping. */
3070
3071 rc = rbd_init_disk(rbd_dev);
2504 if (rc) 3072 if (rc)
2505 goto err_out_blkdev; 3073 goto err_out_blkdev;
2506 3074
3075 rc = rbd_bus_add_dev(rbd_dev);
3076 if (rc)
3077 goto err_out_disk;
3078
2507 /* 3079 /*
2508 * At this point cleanup in the event of an error is the job 3080 * At this point cleanup in the event of an error is the job
2509 * of the sysfs code (initiated by rbd_bus_del_dev()). 3081 * of the sysfs code (initiated by rbd_bus_del_dev()).
2510 *
2511 * Set up and announce blkdev mapping.
2512 */ 3082 */
2513 rc = rbd_init_disk(rbd_dev); 3083
3084 down_write(&rbd_dev->header_rwsem);
3085 rc = rbd_dev_snaps_register(rbd_dev);
3086 up_write(&rbd_dev->header_rwsem);
2514 if (rc) 3087 if (rc)
2515 goto err_out_bus; 3088 goto err_out_bus;
2516 3089
@@ -2518,6 +3091,13 @@ static ssize_t rbd_add(struct bus_type *bus,
2518 if (rc) 3091 if (rc)
2519 goto err_out_bus; 3092 goto err_out_bus;
2520 3093
3094 /* Everything's ready. Announce the disk to the world. */
3095
3096 add_disk(rbd_dev->disk);
3097
3098 pr_info("%s: added with size 0x%llx\n", rbd_dev->disk->disk_name,
3099 (unsigned long long) rbd_dev->mapping.size);
3100
2521 return count; 3101 return count;
2522 3102
2523err_out_bus: 3103err_out_bus:
@@ -2527,19 +3107,23 @@ err_out_bus:
2527 kfree(options); 3107 kfree(options);
2528 return rc; 3108 return rc;
2529 3109
3110err_out_disk:
3111 rbd_free_disk(rbd_dev);
2530err_out_blkdev: 3112err_out_blkdev:
2531 unregister_blkdev(rbd_dev->major, rbd_dev->name); 3113 unregister_blkdev(rbd_dev->major, rbd_dev->name);
3114err_out_id:
3115 rbd_dev_id_put(rbd_dev);
3116err_out_header:
3117 rbd_header_free(&rbd_dev->header);
2532err_out_client: 3118err_out_client:
3119 kfree(rbd_dev->header_name);
2533 rbd_put_client(rbd_dev); 3120 rbd_put_client(rbd_dev);
2534err_put_id: 3121 kfree(rbd_dev->image_id);
2535 if (rbd_dev->pool_name) { 3122err_out_args:
2536 kfree(rbd_dev->snap_name); 3123 kfree(rbd_dev->mapping.snap_name);
2537 kfree(rbd_dev->header_name); 3124 kfree(rbd_dev->image_name);
2538 kfree(rbd_dev->image_name); 3125 kfree(rbd_dev->pool_name);
2539 kfree(rbd_dev->pool_name); 3126err_out_mem:
2540 }
2541 rbd_id_put(rbd_dev);
2542err_nomem:
2543 kfree(rbd_dev); 3127 kfree(rbd_dev);
2544 kfree(options); 3128 kfree(options);
2545 3129
@@ -2585,12 +3169,16 @@ static void rbd_dev_release(struct device *dev)
2585 rbd_free_disk(rbd_dev); 3169 rbd_free_disk(rbd_dev);
2586 unregister_blkdev(rbd_dev->major, rbd_dev->name); 3170 unregister_blkdev(rbd_dev->major, rbd_dev->name);
2587 3171
3172 /* release allocated disk header fields */
3173 rbd_header_free(&rbd_dev->header);
3174
2588 /* done with the id, and with the rbd_dev */ 3175 /* done with the id, and with the rbd_dev */
2589 kfree(rbd_dev->snap_name); 3176 kfree(rbd_dev->mapping.snap_name);
3177 kfree(rbd_dev->image_id);
2590 kfree(rbd_dev->header_name); 3178 kfree(rbd_dev->header_name);
2591 kfree(rbd_dev->pool_name); 3179 kfree(rbd_dev->pool_name);
2592 kfree(rbd_dev->image_name); 3180 kfree(rbd_dev->image_name);
2593 rbd_id_put(rbd_dev); 3181 rbd_dev_id_put(rbd_dev);
2594 kfree(rbd_dev); 3182 kfree(rbd_dev);
2595 3183
2596 /* release module ref */ 3184 /* release module ref */
@@ -2628,47 +3216,7 @@ static ssize_t rbd_remove(struct bus_type *bus,
2628 3216
2629done: 3217done:
2630 mutex_unlock(&ctl_mutex); 3218 mutex_unlock(&ctl_mutex);
2631 return ret;
2632}
2633 3219
2634static ssize_t rbd_snap_add(struct device *dev,
2635 struct device_attribute *attr,
2636 const char *buf,
2637 size_t count)
2638{
2639 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
2640 int ret;
2641 char *name = kmalloc(count + 1, GFP_KERNEL);
2642 if (!name)
2643 return -ENOMEM;
2644
2645 snprintf(name, count, "%s", buf);
2646
2647 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
2648
2649 ret = rbd_header_add_snap(rbd_dev,
2650 name, GFP_KERNEL);
2651 if (ret < 0)
2652 goto err_unlock;
2653
2654 ret = __rbd_refresh_header(rbd_dev, NULL);
2655 if (ret < 0)
2656 goto err_unlock;
2657
2658 /* shouldn't hold ctl_mutex when notifying.. notify might
2659 trigger a watch callback that would need to get that mutex */
2660 mutex_unlock(&ctl_mutex);
2661
2662 /* make a best effort, don't error if failed */
2663 rbd_req_sync_notify(rbd_dev);
2664
2665 ret = count;
2666 kfree(name);
2667 return ret;
2668
2669err_unlock:
2670 mutex_unlock(&ctl_mutex);
2671 kfree(name);
2672 return ret; 3220 return ret;
2673} 3221}
2674 3222
diff --git a/drivers/block/rbd_types.h b/drivers/block/rbd_types.h
index 0924e9e41a60..cbe77fa105ba 100644
--- a/drivers/block/rbd_types.h
+++ b/drivers/block/rbd_types.h
@@ -15,15 +15,30 @@
15 15
16#include <linux/types.h> 16#include <linux/types.h>
17 17
18/* For format version 2, rbd image 'foo' consists of objects
19 * rbd_id.foo - id of image
20 * rbd_header.<id> - image metadata
21 * rbd_data.<id>.0000000000000000
22 * rbd_data.<id>.0000000000000001
23 * ... - data
24 * Clients do not access header data directly in rbd format 2.
25 */
26
27#define RBD_HEADER_PREFIX "rbd_header."
28#define RBD_DATA_PREFIX "rbd_data."
29#define RBD_ID_PREFIX "rbd_id."
30
18/* 31/*
19 * rbd image 'foo' consists of objects 32 * For format version 1, rbd image 'foo' consists of objects
20 * foo.rbd - image metadata 33 * foo.rbd - image metadata
21 * foo.00000000 34 * rb.<idhi>.<idlo>.00000000
22 * foo.00000001 35 * rb.<idhi>.<idlo>.00000001
23 * ... - data 36 * ... - data
37 * There is no notion of a persistent image id in rbd format 1.
24 */ 38 */
25 39
26#define RBD_SUFFIX ".rbd" 40#define RBD_SUFFIX ".rbd"
41
27#define RBD_DIRECTORY "rbd_directory" 42#define RBD_DIRECTORY "rbd_directory"
28#define RBD_INFO "rbd_info" 43#define RBD_INFO "rbd_info"
29 44
@@ -47,7 +62,7 @@ struct rbd_image_snap_ondisk {
47 62
48struct rbd_image_header_ondisk { 63struct rbd_image_header_ondisk {
49 char text[40]; 64 char text[40];
50 char block_name[24]; 65 char object_prefix[24];
51 char signature[4]; 66 char signature[4];
52 char version[8]; 67 char version[8];
53 struct { 68 struct {
diff --git a/fs/ceph/addr.c b/fs/ceph/addr.c
index 452e71a1b753..22b6e4583faa 100644
--- a/fs/ceph/addr.c
+++ b/fs/ceph/addr.c
@@ -205,7 +205,7 @@ static int readpage_nounlock(struct file *filp, struct page *page)
205 dout("readpage inode %p file %p page %p index %lu\n", 205 dout("readpage inode %p file %p page %p index %lu\n",
206 inode, filp, page, page->index); 206 inode, filp, page, page->index);
207 err = ceph_osdc_readpages(osdc, ceph_vino(inode), &ci->i_layout, 207 err = ceph_osdc_readpages(osdc, ceph_vino(inode), &ci->i_layout,
208 page->index << PAGE_CACHE_SHIFT, &len, 208 (u64) page_offset(page), &len,
209 ci->i_truncate_seq, ci->i_truncate_size, 209 ci->i_truncate_seq, ci->i_truncate_size,
210 &page, 1, 0); 210 &page, 1, 0);
211 if (err == -ENOENT) 211 if (err == -ENOENT)
@@ -286,7 +286,7 @@ static int start_read(struct inode *inode, struct list_head *page_list, int max)
286 int nr_pages = 0; 286 int nr_pages = 0;
287 int ret; 287 int ret;
288 288
289 off = page->index << PAGE_CACHE_SHIFT; 289 off = (u64) page_offset(page);
290 290
291 /* count pages */ 291 /* count pages */
292 next_index = page->index; 292 next_index = page->index;
@@ -308,8 +308,8 @@ static int start_read(struct inode *inode, struct list_head *page_list, int max)
308 NULL, 0, 308 NULL, 0,
309 ci->i_truncate_seq, ci->i_truncate_size, 309 ci->i_truncate_seq, ci->i_truncate_size,
310 NULL, false, 1, 0); 310 NULL, false, 1, 0);
311 if (!req) 311 if (IS_ERR(req))
312 return -ENOMEM; 312 return PTR_ERR(req);
313 313
314 /* build page vector */ 314 /* build page vector */
315 nr_pages = len >> PAGE_CACHE_SHIFT; 315 nr_pages = len >> PAGE_CACHE_SHIFT;
@@ -426,7 +426,7 @@ static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
426 struct ceph_inode_info *ci; 426 struct ceph_inode_info *ci;
427 struct ceph_fs_client *fsc; 427 struct ceph_fs_client *fsc;
428 struct ceph_osd_client *osdc; 428 struct ceph_osd_client *osdc;
429 loff_t page_off = page->index << PAGE_CACHE_SHIFT; 429 loff_t page_off = page_offset(page);
430 int len = PAGE_CACHE_SIZE; 430 int len = PAGE_CACHE_SIZE;
431 loff_t i_size; 431 loff_t i_size;
432 int err = 0; 432 int err = 0;
@@ -817,8 +817,7 @@ get_more_pages:
817 /* ok */ 817 /* ok */
818 if (locked_pages == 0) { 818 if (locked_pages == 0) {
819 /* prepare async write request */ 819 /* prepare async write request */
820 offset = (unsigned long long)page->index 820 offset = (u64) page_offset(page);
821 << PAGE_CACHE_SHIFT;
822 len = wsize; 821 len = wsize;
823 req = ceph_osdc_new_request(&fsc->client->osdc, 822 req = ceph_osdc_new_request(&fsc->client->osdc,
824 &ci->i_layout, 823 &ci->i_layout,
@@ -832,8 +831,8 @@ get_more_pages:
832 ci->i_truncate_size, 831 ci->i_truncate_size,
833 &inode->i_mtime, true, 1, 0); 832 &inode->i_mtime, true, 1, 0);
834 833
835 if (!req) { 834 if (IS_ERR(req)) {
836 rc = -ENOMEM; 835 rc = PTR_ERR(req);
837 unlock_page(page); 836 unlock_page(page);
838 break; 837 break;
839 } 838 }
@@ -1180,7 +1179,7 @@ static int ceph_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
1180 struct inode *inode = vma->vm_file->f_dentry->d_inode; 1179 struct inode *inode = vma->vm_file->f_dentry->d_inode;
1181 struct page *page = vmf->page; 1180 struct page *page = vmf->page;
1182 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc; 1181 struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
1183 loff_t off = page->index << PAGE_CACHE_SHIFT; 1182 loff_t off = page_offset(page);
1184 loff_t size, len; 1183 loff_t size, len;
1185 int ret; 1184 int ret;
1186 1185
diff --git a/fs/ceph/caps.c b/fs/ceph/caps.c
index 620daad201db..3251e9cc6401 100644
--- a/fs/ceph/caps.c
+++ b/fs/ceph/caps.c
@@ -1005,7 +1005,7 @@ static void __queue_cap_release(struct ceph_mds_session *session,
1005 1005
1006 BUG_ON(msg->front.iov_len + sizeof(*item) > PAGE_CACHE_SIZE); 1006 BUG_ON(msg->front.iov_len + sizeof(*item) > PAGE_CACHE_SIZE);
1007 head = msg->front.iov_base; 1007 head = msg->front.iov_base;
1008 head->num = cpu_to_le32(le32_to_cpu(head->num) + 1); 1008 le32_add_cpu(&head->num, 1);
1009 item = msg->front.iov_base + msg->front.iov_len; 1009 item = msg->front.iov_base + msg->front.iov_len;
1010 item->ino = cpu_to_le64(ino); 1010 item->ino = cpu_to_le64(ino);
1011 item->cap_id = cpu_to_le64(cap_id); 1011 item->cap_id = cpu_to_le64(cap_id);
diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index ecebbc09bfc7..5840d2aaed15 100644
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -536,8 +536,8 @@ more:
536 do_sync, 536 do_sync,
537 ci->i_truncate_seq, ci->i_truncate_size, 537 ci->i_truncate_seq, ci->i_truncate_size,
538 &mtime, false, 2, page_align); 538 &mtime, false, 2, page_align);
539 if (!req) 539 if (IS_ERR(req))
540 return -ENOMEM; 540 return PTR_ERR(req);
541 541
542 if (file->f_flags & O_DIRECT) { 542 if (file->f_flags & O_DIRECT) {
543 pages = ceph_get_direct_page_vector(data, num_pages, false); 543 pages = ceph_get_direct_page_vector(data, num_pages, false);
diff --git a/fs/ceph/ioctl.c b/fs/ceph/ioctl.c
index 1396ceb46797..36549a46e311 100644
--- a/fs/ceph/ioctl.c
+++ b/fs/ceph/ioctl.c
@@ -187,14 +187,18 @@ static long ceph_ioctl_get_dataloc(struct file *file, void __user *arg)
187 u64 tmp; 187 u64 tmp;
188 struct ceph_object_layout ol; 188 struct ceph_object_layout ol;
189 struct ceph_pg pgid; 189 struct ceph_pg pgid;
190 int r;
190 191
191 /* copy and validate */ 192 /* copy and validate */
192 if (copy_from_user(&dl, arg, sizeof(dl))) 193 if (copy_from_user(&dl, arg, sizeof(dl)))
193 return -EFAULT; 194 return -EFAULT;
194 195
195 down_read(&osdc->map_sem); 196 down_read(&osdc->map_sem);
196 ceph_calc_file_object_mapping(&ci->i_layout, dl.file_offset, &len, 197 r = ceph_calc_file_object_mapping(&ci->i_layout, dl.file_offset, &len,
197 &dl.object_no, &dl.object_offset, &olen); 198 &dl.object_no, &dl.object_offset,
199 &olen);
200 if (r < 0)
201 return -EIO;
198 dl.file_offset -= dl.object_offset; 202 dl.file_offset -= dl.object_offset;
199 dl.object_size = ceph_file_layout_object_size(ci->i_layout); 203 dl.object_size = ceph_file_layout_object_size(ci->i_layout);
200 dl.block_size = ceph_file_layout_su(ci->i_layout); 204 dl.block_size = ceph_file_layout_su(ci->i_layout);
diff --git a/fs/ceph/mds_client.c b/fs/ceph/mds_client.c
index a5a735422aa7..1bcf712655d9 100644
--- a/fs/ceph/mds_client.c
+++ b/fs/ceph/mds_client.c
@@ -2625,7 +2625,8 @@ static void check_new_map(struct ceph_mds_client *mdsc,
2625 ceph_mdsmap_is_laggy(newmap, i) ? " (laggy)" : "", 2625 ceph_mdsmap_is_laggy(newmap, i) ? " (laggy)" : "",
2626 session_state_name(s->s_state)); 2626 session_state_name(s->s_state));
2627 2627
2628 if (memcmp(ceph_mdsmap_get_addr(oldmap, i), 2628 if (i >= newmap->m_max_mds ||
2629 memcmp(ceph_mdsmap_get_addr(oldmap, i),
2629 ceph_mdsmap_get_addr(newmap, i), 2630 ceph_mdsmap_get_addr(newmap, i),
2630 sizeof(struct ceph_entity_addr))) { 2631 sizeof(struct ceph_entity_addr))) {
2631 if (s->s_state == CEPH_MDS_SESSION_OPENING) { 2632 if (s->s_state == CEPH_MDS_SESSION_OPENING) {
diff --git a/fs/ceph/super.c b/fs/ceph/super.c
index 3a42d9326378..2eb43f211325 100644
--- a/fs/ceph/super.c
+++ b/fs/ceph/super.c
@@ -307,7 +307,10 @@ static int parse_mount_options(struct ceph_mount_options **pfsopt,
307{ 307{
308 struct ceph_mount_options *fsopt; 308 struct ceph_mount_options *fsopt;
309 const char *dev_name_end; 309 const char *dev_name_end;
310 int err = -ENOMEM; 310 int err;
311
312 if (!dev_name || !*dev_name)
313 return -EINVAL;
311 314
312 fsopt = kzalloc(sizeof(*fsopt), GFP_KERNEL); 315 fsopt = kzalloc(sizeof(*fsopt), GFP_KERNEL);
313 if (!fsopt) 316 if (!fsopt)
@@ -328,21 +331,33 @@ static int parse_mount_options(struct ceph_mount_options **pfsopt,
328 fsopt->max_readdir_bytes = CEPH_MAX_READDIR_BYTES_DEFAULT; 331 fsopt->max_readdir_bytes = CEPH_MAX_READDIR_BYTES_DEFAULT;
329 fsopt->congestion_kb = default_congestion_kb(); 332 fsopt->congestion_kb = default_congestion_kb();
330 333
331 /* ip1[:port1][,ip2[:port2]...]:/subdir/in/fs */ 334 /*
335 * Distinguish the server list from the path in "dev_name".
336 * Internally we do not include the leading '/' in the path.
337 *
338 * "dev_name" will look like:
339 * <server_spec>[,<server_spec>...]:[<path>]
340 * where
341 * <server_spec> is <ip>[:<port>]
342 * <path> is optional, but if present must begin with '/'
343 */
344 dev_name_end = strchr(dev_name, '/');
345 if (dev_name_end) {
346 /* skip over leading '/' for path */
347 *path = dev_name_end + 1;
348 } else {
349 /* path is empty */
350 dev_name_end = dev_name + strlen(dev_name);
351 *path = dev_name_end;
352 }
332 err = -EINVAL; 353 err = -EINVAL;
333 if (!dev_name) 354 dev_name_end--; /* back up to ':' separator */
334 goto out; 355 if (*dev_name_end != ':') {
335 *path = strstr(dev_name, ":/"); 356 pr_err("device name is missing path (no : separator in %s)\n",
336 if (*path == NULL) {
337 pr_err("device name is missing path (no :/ in %s)\n",
338 dev_name); 357 dev_name);
339 goto out; 358 goto out;
340 } 359 }
341 dev_name_end = *path;
342 dout("device name '%.*s'\n", (int)(dev_name_end - dev_name), dev_name); 360 dout("device name '%.*s'\n", (int)(dev_name_end - dev_name), dev_name);
343
344 /* path on server */
345 *path += 2;
346 dout("server path '%s'\n", *path); 361 dout("server path '%s'\n", *path);
347 362
348 *popt = ceph_parse_options(options, dev_name, dev_name_end, 363 *popt = ceph_parse_options(options, dev_name, dev_name_end,
diff --git a/include/linux/ceph/mon_client.h b/include/linux/ceph/mon_client.h
index 1fb93e9080b0..a486f390dfbe 100644
--- a/include/linux/ceph/mon_client.h
+++ b/include/linux/ceph/mon_client.h
@@ -71,7 +71,6 @@ struct ceph_mon_client {
71 int cur_mon; /* last monitor i contacted */ 71 int cur_mon; /* last monitor i contacted */
72 unsigned long sub_sent, sub_renew_after; 72 unsigned long sub_sent, sub_renew_after;
73 struct ceph_connection con; 73 struct ceph_connection con;
74 bool have_fsid;
75 74
76 /* pending generic requests */ 75 /* pending generic requests */
77 struct rb_root generic_request_tree; 76 struct rb_root generic_request_tree;
diff --git a/include/linux/ceph/osd_client.h b/include/linux/ceph/osd_client.h
index cedfb1a8434a..d9b880e977e6 100644
--- a/include/linux/ceph/osd_client.h
+++ b/include/linux/ceph/osd_client.h
@@ -207,7 +207,7 @@ extern void ceph_osdc_handle_reply(struct ceph_osd_client *osdc,
207extern void ceph_osdc_handle_map(struct ceph_osd_client *osdc, 207extern void ceph_osdc_handle_map(struct ceph_osd_client *osdc,
208 struct ceph_msg *msg); 208 struct ceph_msg *msg);
209 209
210extern void ceph_calc_raw_layout(struct ceph_osd_client *osdc, 210extern int ceph_calc_raw_layout(struct ceph_osd_client *osdc,
211 struct ceph_file_layout *layout, 211 struct ceph_file_layout *layout,
212 u64 snapid, 212 u64 snapid,
213 u64 off, u64 *plen, u64 *bno, 213 u64 off, u64 *plen, u64 *bno,
diff --git a/include/linux/ceph/osdmap.h b/include/linux/ceph/osdmap.h
index 25b930bffea6..e37acbe989a9 100644
--- a/include/linux/ceph/osdmap.h
+++ b/include/linux/ceph/osdmap.h
@@ -109,9 +109,9 @@ extern struct ceph_osdmap *osdmap_apply_incremental(void **p, void *end,
109extern void ceph_osdmap_destroy(struct ceph_osdmap *map); 109extern void ceph_osdmap_destroy(struct ceph_osdmap *map);
110 110
111/* calculate mapping of a file extent to an object */ 111/* calculate mapping of a file extent to an object */
112extern void ceph_calc_file_object_mapping(struct ceph_file_layout *layout, 112extern int ceph_calc_file_object_mapping(struct ceph_file_layout *layout,
113 u64 off, u64 *plen, 113 u64 off, u64 *plen,
114 u64 *bno, u64 *oxoff, u64 *oxlen); 114 u64 *bno, u64 *oxoff, u64 *oxlen);
115 115
116/* calculate mapping of object to a placement group */ 116/* calculate mapping of object to a placement group */
117extern int ceph_calc_object_layout(struct ceph_object_layout *ol, 117extern int ceph_calc_object_layout(struct ceph_object_layout *ol,
diff --git a/net/ceph/mon_client.c b/net/ceph/mon_client.c
index 900ea0f043fc..812eb3b46c1f 100644
--- a/net/ceph/mon_client.c
+++ b/net/ceph/mon_client.c
@@ -637,7 +637,7 @@ bad:
637/* 637/*
638 * Do a synchronous pool op. 638 * Do a synchronous pool op.
639 */ 639 */
640int ceph_monc_do_poolop(struct ceph_mon_client *monc, u32 op, 640static int do_poolop(struct ceph_mon_client *monc, u32 op,
641 u32 pool, u64 snapid, 641 u32 pool, u64 snapid,
642 char *buf, int len) 642 char *buf, int len)
643{ 643{
@@ -687,7 +687,7 @@ out:
687int ceph_monc_create_snapid(struct ceph_mon_client *monc, 687int ceph_monc_create_snapid(struct ceph_mon_client *monc,
688 u32 pool, u64 *snapid) 688 u32 pool, u64 *snapid)
689{ 689{
690 return ceph_monc_do_poolop(monc, POOL_OP_CREATE_UNMANAGED_SNAP, 690 return do_poolop(monc, POOL_OP_CREATE_UNMANAGED_SNAP,
691 pool, 0, (char *)snapid, sizeof(*snapid)); 691 pool, 0, (char *)snapid, sizeof(*snapid));
692 692
693} 693}
@@ -696,7 +696,7 @@ EXPORT_SYMBOL(ceph_monc_create_snapid);
696int ceph_monc_delete_snapid(struct ceph_mon_client *monc, 696int ceph_monc_delete_snapid(struct ceph_mon_client *monc,
697 u32 pool, u64 snapid) 697 u32 pool, u64 snapid)
698{ 698{
699 return ceph_monc_do_poolop(monc, POOL_OP_CREATE_UNMANAGED_SNAP, 699 return do_poolop(monc, POOL_OP_CREATE_UNMANAGED_SNAP,
700 pool, snapid, 0, 0); 700 pool, snapid, 0, 0);
701 701
702} 702}
@@ -769,7 +769,6 @@ static int build_initial_monmap(struct ceph_mon_client *monc)
769 monc->monmap->mon_inst[i].name.num = cpu_to_le64(i); 769 monc->monmap->mon_inst[i].name.num = cpu_to_le64(i);
770 } 770 }
771 monc->monmap->num_mon = num_mon; 771 monc->monmap->num_mon = num_mon;
772 monc->have_fsid = false;
773 return 0; 772 return 0;
774} 773}
775 774
diff --git a/net/ceph/osd_client.c b/net/ceph/osd_client.c
index 42119c05e82c..ccbdfbba9e53 100644
--- a/net/ceph/osd_client.c
+++ b/net/ceph/osd_client.c
@@ -52,7 +52,7 @@ static int op_has_extent(int op)
52 op == CEPH_OSD_OP_WRITE); 52 op == CEPH_OSD_OP_WRITE);
53} 53}
54 54
55void ceph_calc_raw_layout(struct ceph_osd_client *osdc, 55int ceph_calc_raw_layout(struct ceph_osd_client *osdc,
56 struct ceph_file_layout *layout, 56 struct ceph_file_layout *layout,
57 u64 snapid, 57 u64 snapid,
58 u64 off, u64 *plen, u64 *bno, 58 u64 off, u64 *plen, u64 *bno,
@@ -62,12 +62,15 @@ void ceph_calc_raw_layout(struct ceph_osd_client *osdc,
62 struct ceph_osd_request_head *reqhead = req->r_request->front.iov_base; 62 struct ceph_osd_request_head *reqhead = req->r_request->front.iov_base;
63 u64 orig_len = *plen; 63 u64 orig_len = *plen;
64 u64 objoff, objlen; /* extent in object */ 64 u64 objoff, objlen; /* extent in object */
65 int r;
65 66
66 reqhead->snapid = cpu_to_le64(snapid); 67 reqhead->snapid = cpu_to_le64(snapid);
67 68
68 /* object extent? */ 69 /* object extent? */
69 ceph_calc_file_object_mapping(layout, off, plen, bno, 70 r = ceph_calc_file_object_mapping(layout, off, plen, bno,
70 &objoff, &objlen); 71 &objoff, &objlen);
72 if (r < 0)
73 return r;
71 if (*plen < orig_len) 74 if (*plen < orig_len)
72 dout(" skipping last %llu, final file extent %llu~%llu\n", 75 dout(" skipping last %llu, final file extent %llu~%llu\n",
73 orig_len - *plen, off, *plen); 76 orig_len - *plen, off, *plen);
@@ -83,7 +86,7 @@ void ceph_calc_raw_layout(struct ceph_osd_client *osdc,
83 86
84 dout("calc_layout bno=%llx %llu~%llu (%d pages)\n", 87 dout("calc_layout bno=%llx %llu~%llu (%d pages)\n",
85 *bno, objoff, objlen, req->r_num_pages); 88 *bno, objoff, objlen, req->r_num_pages);
86 89 return 0;
87} 90}
88EXPORT_SYMBOL(ceph_calc_raw_layout); 91EXPORT_SYMBOL(ceph_calc_raw_layout);
89 92
@@ -112,20 +115,25 @@ EXPORT_SYMBOL(ceph_calc_raw_layout);
112 * 115 *
113 * fill osd op in request message. 116 * fill osd op in request message.
114 */ 117 */
115static void calc_layout(struct ceph_osd_client *osdc, 118static int calc_layout(struct ceph_osd_client *osdc,
116 struct ceph_vino vino, 119 struct ceph_vino vino,
117 struct ceph_file_layout *layout, 120 struct ceph_file_layout *layout,
118 u64 off, u64 *plen, 121 u64 off, u64 *plen,
119 struct ceph_osd_request *req, 122 struct ceph_osd_request *req,
120 struct ceph_osd_req_op *op) 123 struct ceph_osd_req_op *op)
121{ 124{
122 u64 bno; 125 u64 bno;
126 int r;
123 127
124 ceph_calc_raw_layout(osdc, layout, vino.snap, off, 128 r = ceph_calc_raw_layout(osdc, layout, vino.snap, off,
125 plen, &bno, req, op); 129 plen, &bno, req, op);
130 if (r < 0)
131 return r;
126 132
127 snprintf(req->r_oid, sizeof(req->r_oid), "%llx.%08llx", vino.ino, bno); 133 snprintf(req->r_oid, sizeof(req->r_oid), "%llx.%08llx", vino.ino, bno);
128 req->r_oid_len = strlen(req->r_oid); 134 req->r_oid_len = strlen(req->r_oid);
135
136 return r;
129} 137}
130 138
131/* 139/*
@@ -456,6 +464,7 @@ struct ceph_osd_request *ceph_osdc_new_request(struct ceph_osd_client *osdc,
456{ 464{
457 struct ceph_osd_req_op ops[3]; 465 struct ceph_osd_req_op ops[3];
458 struct ceph_osd_request *req; 466 struct ceph_osd_request *req;
467 int r;
459 468
460 ops[0].op = opcode; 469 ops[0].op = opcode;
461 ops[0].extent.truncate_seq = truncate_seq; 470 ops[0].extent.truncate_seq = truncate_seq;
@@ -474,10 +483,12 @@ struct ceph_osd_request *ceph_osdc_new_request(struct ceph_osd_client *osdc,
474 use_mempool, 483 use_mempool,
475 GFP_NOFS, NULL, NULL); 484 GFP_NOFS, NULL, NULL);
476 if (!req) 485 if (!req)
477 return NULL; 486 return ERR_PTR(-ENOMEM);
478 487
479 /* calculate max write size */ 488 /* calculate max write size */
480 calc_layout(osdc, vino, layout, off, plen, req, ops); 489 r = calc_layout(osdc, vino, layout, off, plen, req, ops);
490 if (r < 0)
491 return ERR_PTR(r);
481 req->r_file_layout = *layout; /* keep a copy */ 492 req->r_file_layout = *layout; /* keep a copy */
482 493
483 /* in case it differs from natural (file) alignment that 494 /* in case it differs from natural (file) alignment that
@@ -1920,8 +1931,8 @@ int ceph_osdc_readpages(struct ceph_osd_client *osdc,
1920 CEPH_OSD_OP_READ, CEPH_OSD_FLAG_READ, 1931 CEPH_OSD_OP_READ, CEPH_OSD_FLAG_READ,
1921 NULL, 0, truncate_seq, truncate_size, NULL, 1932 NULL, 0, truncate_seq, truncate_size, NULL,
1922 false, 1, page_align); 1933 false, 1, page_align);
1923 if (!req) 1934 if (IS_ERR(req))
1924 return -ENOMEM; 1935 return PTR_ERR(req);
1925 1936
1926 /* it may be a short read due to an object boundary */ 1937 /* it may be a short read due to an object boundary */
1927 req->r_pages = pages; 1938 req->r_pages = pages;
@@ -1963,8 +1974,8 @@ int ceph_osdc_writepages(struct ceph_osd_client *osdc, struct ceph_vino vino,
1963 snapc, do_sync, 1974 snapc, do_sync,
1964 truncate_seq, truncate_size, mtime, 1975 truncate_seq, truncate_size, mtime,
1965 nofail, 1, page_align); 1976 nofail, 1, page_align);
1966 if (!req) 1977 if (IS_ERR(req))
1967 return -ENOMEM; 1978 return PTR_ERR(req);
1968 1979
1969 /* it may be a short write due to an object boundary */ 1980 /* it may be a short write due to an object boundary */
1970 req->r_pages = pages; 1981 req->r_pages = pages;
diff --git a/net/ceph/osdmap.c b/net/ceph/osdmap.c
index 3124b71a8883..5433fb0eb3c6 100644
--- a/net/ceph/osdmap.c
+++ b/net/ceph/osdmap.c
@@ -984,7 +984,7 @@ bad:
984 * for now, we write only a single su, until we can 984 * for now, we write only a single su, until we can
985 * pass a stride back to the caller. 985 * pass a stride back to the caller.
986 */ 986 */
987void ceph_calc_file_object_mapping(struct ceph_file_layout *layout, 987int ceph_calc_file_object_mapping(struct ceph_file_layout *layout,
988 u64 off, u64 *plen, 988 u64 off, u64 *plen,
989 u64 *ono, 989 u64 *ono,
990 u64 *oxoff, u64 *oxlen) 990 u64 *oxoff, u64 *oxlen)
@@ -998,11 +998,17 @@ void ceph_calc_file_object_mapping(struct ceph_file_layout *layout,
998 998
999 dout("mapping %llu~%llu osize %u fl_su %u\n", off, *plen, 999 dout("mapping %llu~%llu osize %u fl_su %u\n", off, *plen,
1000 osize, su); 1000 osize, su);
1001 if (su == 0 || sc == 0)
1002 goto invalid;
1001 su_per_object = osize / su; 1003 su_per_object = osize / su;
1004 if (su_per_object == 0)
1005 goto invalid;
1002 dout("osize %u / su %u = su_per_object %u\n", osize, su, 1006 dout("osize %u / su %u = su_per_object %u\n", osize, su,
1003 su_per_object); 1007 su_per_object);
1004 1008
1005 BUG_ON((su & ~PAGE_MASK) != 0); 1009 if ((su & ~PAGE_MASK) != 0)
1010 goto invalid;
1011
1006 /* bl = *off / su; */ 1012 /* bl = *off / su; */
1007 t = off; 1013 t = off;
1008 do_div(t, su); 1014 do_div(t, su);
@@ -1030,6 +1036,14 @@ void ceph_calc_file_object_mapping(struct ceph_file_layout *layout,
1030 *plen = *oxlen; 1036 *plen = *oxlen;
1031 1037
1032 dout(" obj extent %llu~%llu\n", *oxoff, *oxlen); 1038 dout(" obj extent %llu~%llu\n", *oxoff, *oxlen);
1039 return 0;
1040
1041invalid:
1042 dout(" invalid layout\n");
1043 *ono = 0;
1044 *oxoff = 0;
1045 *oxlen = 0;
1046 return -EINVAL;
1033} 1047}
1034EXPORT_SYMBOL(ceph_calc_file_object_mapping); 1048EXPORT_SYMBOL(ceph_calc_file_object_mapping);
1035 1049
diff --git a/net/ceph/pagelist.c b/net/ceph/pagelist.c
index 665cd23020ff..92866bebb65f 100644
--- a/net/ceph/pagelist.c
+++ b/net/ceph/pagelist.c
@@ -1,4 +1,3 @@
1
2#include <linux/module.h> 1#include <linux/module.h>
3#include <linux/gfp.h> 2#include <linux/gfp.h>
4#include <linux/pagemap.h> 3#include <linux/pagemap.h>
@@ -134,8 +133,8 @@ int ceph_pagelist_truncate(struct ceph_pagelist *pl,
134 ceph_pagelist_unmap_tail(pl); 133 ceph_pagelist_unmap_tail(pl);
135 while (pl->head.prev != c->page_lru) { 134 while (pl->head.prev != c->page_lru) {
136 page = list_entry(pl->head.prev, struct page, lru); 135 page = list_entry(pl->head.prev, struct page, lru);
137 list_del(&page->lru); /* remove from pagelist */ 136 /* move from pagelist to reserve */
138 list_add_tail(&page->lru, &pl->free_list); /* add to reserve */ 137 list_move_tail(&page->lru, &pl->free_list);
139 ++pl->num_pages_free; 138 ++pl->num_pages_free;
140 } 139 }
141 pl->room = c->room; 140 pl->room = c->room;
generated by cgit v1.2.2 (git 2.25.0) at 2025-12-31 15:15:38 -0500