blob: b8e557fbf73bea16028f199d45521fb8f6812365 [file] [log] [blame]
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001/*
2 rbd.c -- Export ceph rados objects as a Linux block device
3
4
5 based on drivers/block/osdblk.c:
6
7 Copyright 2009 Red Hat, Inc.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; see the file COPYING. If not, write to
20 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
21
22
23
Yehuda Sadehdfc56062010-11-19 14:51:04 -080024 For usage instructions, please refer to:
Yehuda Sadeh602adf42010-08-12 16:11:25 -070025
Yehuda Sadehdfc56062010-11-19 14:51:04 -080026 Documentation/ABI/testing/sysfs-bus-rbd
Yehuda Sadeh602adf42010-08-12 16:11:25 -070027
28 */
29
30#include <linux/ceph/libceph.h>
31#include <linux/ceph/osd_client.h>
32#include <linux/ceph/mon_client.h>
33#include <linux/ceph/decode.h>
Yehuda Sadeh59c2be12011-03-21 15:10:11 -070034#include <linux/parser.h>
Yehuda Sadeh602adf42010-08-12 16:11:25 -070035
36#include <linux/kernel.h>
37#include <linux/device.h>
38#include <linux/module.h>
39#include <linux/fs.h>
40#include <linux/blkdev.h>
41
42#include "rbd_types.h"
43
Alex Elder593a9e72012-02-07 12:03:37 -060044/*
45 * 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
47 * universally 512 bytes. These symbols are just slightly more
48 * meaningful than the bare numbers they represent.
49 */
50#define SECTOR_SHIFT 9
51#define SECTOR_SIZE (1ULL << SECTOR_SHIFT)
52
Alex Elderf0f8cef2012-01-29 13:57:44 -060053#define RBD_DRV_NAME "rbd"
54#define RBD_DRV_NAME_LONG "rbd (rados block device)"
Yehuda Sadeh602adf42010-08-12 16:11:25 -070055
56#define RBD_MINORS_PER_MAJOR 256 /* max minors per blkdev */
57
Yehuda Sadeh602adf42010-08-12 16:11:25 -070058#define RBD_MAX_SNAP_NAME_LEN 32
59#define RBD_MAX_OPT_LEN 1024
60
61#define RBD_SNAP_HEAD_NAME "-"
62
Alex Elder81a89792012-02-02 08:13:30 -060063/*
64 * An RBD device name will be "rbd#", where the "rbd" comes from
65 * RBD_DRV_NAME above, and # is a unique integer identifier.
66 * MAX_INT_FORMAT_WIDTH is used in ensuring DEV_NAME_LEN is big
67 * enough to hold all possible device names.
68 */
Yehuda Sadeh602adf42010-08-12 16:11:25 -070069#define DEV_NAME_LEN 32
Alex Elder81a89792012-02-02 08:13:30 -060070#define MAX_INT_FORMAT_WIDTH ((5 * sizeof (int)) / 2 + 1)
Yehuda Sadeh602adf42010-08-12 16:11:25 -070071
Yehuda Sadeh59c2be12011-03-21 15:10:11 -070072#define RBD_NOTIFY_TIMEOUT_DEFAULT 10
73
Yehuda Sadeh602adf42010-08-12 16:11:25 -070074/*
75 * block device image metadata (in-memory version)
76 */
77struct rbd_image_header {
78 u64 image_size;
Alex Elder849b4262012-07-09 21:04:24 -050079 char *object_prefix;
Yehuda Sadeh602adf42010-08-12 16:11:25 -070080 __u8 obj_order;
81 __u8 crypt_type;
82 __u8 comp_type;
Yehuda Sadeh602adf42010-08-12 16:11:25 -070083 struct ceph_snap_context *snapc;
84 size_t snap_names_len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -070085 u32 total_snaps;
86
87 char *snap_names;
88 u64 *snap_sizes;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -070089
90 u64 obj_version;
91};
92
93struct rbd_options {
94 int notify_timeout;
Yehuda Sadeh602adf42010-08-12 16:11:25 -070095};
96
97/*
Alex Elderf0f8cef2012-01-29 13:57:44 -060098 * an instance of the client. multiple devices may share an rbd client.
Yehuda Sadeh602adf42010-08-12 16:11:25 -070099 */
100struct rbd_client {
101 struct ceph_client *client;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700102 struct rbd_options *rbd_opts;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700103 struct kref kref;
104 struct list_head node;
105};
106
107/*
Alex Elderf0f8cef2012-01-29 13:57:44 -0600108 * a request completion status
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700109 */
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700110struct rbd_req_status {
111 int done;
112 int rc;
113 u64 bytes;
114};
115
116/*
117 * a collection of requests
118 */
119struct rbd_req_coll {
120 int total;
121 int num_done;
122 struct kref kref;
123 struct rbd_req_status status[0];
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700124};
125
Alex Elderf0f8cef2012-01-29 13:57:44 -0600126/*
127 * a single io request
128 */
129struct rbd_request {
130 struct request *rq; /* blk layer request */
131 struct bio *bio; /* cloned bio */
132 struct page **pages; /* list of used pages */
133 u64 len;
134 int coll_index;
135 struct rbd_req_coll *coll;
136};
137
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800138struct rbd_snap {
139 struct device dev;
140 const char *name;
Josh Durgin35915382011-12-05 18:25:13 -0800141 u64 size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800142 struct list_head node;
143 u64 id;
144};
145
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700146/*
147 * a single device
148 */
149struct rbd_device {
Alex Elderde71a292012-07-03 16:01:19 -0500150 int dev_id; /* blkdev unique id */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700151
152 int major; /* blkdev assigned major */
153 struct gendisk *disk; /* blkdev's gendisk and rq */
154 struct request_queue *q;
155
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700156 struct rbd_client *rbd_client;
157
158 char name[DEV_NAME_LEN]; /* blkdev name, e.g. rbd3 */
159
160 spinlock_t lock; /* queue lock */
161
162 struct rbd_image_header header;
Alex Elder0bed54d2012-07-03 16:01:18 -0500163 char *image_name;
164 size_t image_name_len;
165 char *header_name;
Alex Elderd22f76e2012-07-12 10:46:35 -0500166 char *pool_name;
Alex Elder9bb2f332012-07-12 10:46:35 -0500167 int pool_id;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700168
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700169 struct ceph_osd_event *watch_event;
170 struct ceph_osd_request *watch_request;
171
Josh Durginc6666012011-11-21 17:11:12 -0800172 /* protects updating the header */
173 struct rw_semaphore header_rwsem;
Josh Durgine88a36e2011-11-21 18:14:25 -0800174 /* name of the snapshot this device reads from */
Alex Elder820a5f32012-07-09 21:04:24 -0500175 char *snap_name;
Josh Durgine88a36e2011-11-21 18:14:25 -0800176 /* id of the snapshot this device reads from */
Josh Durgin77dfe992011-11-21 13:04:42 -0800177 u64 snap_id; /* current snapshot id */
Josh Durgine88a36e2011-11-21 18:14:25 -0800178 /* whether the snap_id this device reads from still exists */
179 bool snap_exists;
180 int read_only;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700181
182 struct list_head node;
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800183
184 /* list of snapshots */
185 struct list_head snaps;
186
187 /* sysfs related */
188 struct device dev;
189};
190
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700191static DEFINE_MUTEX(ctl_mutex); /* Serialize open/close/setup/teardown */
Alex Eldere124a82f2012-01-29 13:57:44 -0600192
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700193static LIST_HEAD(rbd_dev_list); /* devices */
Alex Eldere124a82f2012-01-29 13:57:44 -0600194static DEFINE_SPINLOCK(rbd_dev_list_lock);
195
Alex Elder432b8582012-01-29 13:57:44 -0600196static LIST_HEAD(rbd_client_list); /* clients */
197static DEFINE_SPINLOCK(rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700198
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800199static int __rbd_init_snaps_header(struct rbd_device *rbd_dev);
200static void rbd_dev_release(struct device *dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800201static ssize_t rbd_snap_add(struct device *dev,
202 struct device_attribute *attr,
203 const char *buf,
204 size_t count);
Alex Elder14e70852012-07-19 09:09:27 -0500205static void __rbd_remove_snap_dev(struct rbd_snap *snap);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800206
Alex Elderf0f8cef2012-01-29 13:57:44 -0600207static ssize_t rbd_add(struct bus_type *bus, const char *buf,
208 size_t count);
209static ssize_t rbd_remove(struct bus_type *bus, const char *buf,
210 size_t count);
211
212static struct bus_attribute rbd_bus_attrs[] = {
213 __ATTR(add, S_IWUSR, NULL, rbd_add),
214 __ATTR(remove, S_IWUSR, NULL, rbd_remove),
215 __ATTR_NULL
216};
217
218static struct bus_type rbd_bus_type = {
219 .name = "rbd",
220 .bus_attrs = rbd_bus_attrs,
221};
222
223static void rbd_root_dev_release(struct device *dev)
224{
225}
226
227static struct device rbd_root_dev = {
228 .init_name = "rbd",
229 .release = rbd_root_dev_release,
230};
231
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800232
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800233static struct device *rbd_get_dev(struct rbd_device *rbd_dev)
234{
235 return get_device(&rbd_dev->dev);
236}
237
238static void rbd_put_dev(struct rbd_device *rbd_dev)
239{
240 put_device(&rbd_dev->dev);
241}
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700242
Josh Durgin263c6ca2011-12-05 10:43:42 -0800243static int __rbd_refresh_header(struct rbd_device *rbd_dev);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700244
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700245static int rbd_open(struct block_device *bdev, fmode_t mode)
246{
Alex Elderf0f8cef2012-01-29 13:57:44 -0600247 struct rbd_device *rbd_dev = bdev->bd_disk->private_data;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700248
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800249 rbd_get_dev(rbd_dev);
250
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700251 set_device_ro(bdev, rbd_dev->read_only);
252
253 if ((mode & FMODE_WRITE) && rbd_dev->read_only)
254 return -EROFS;
255
256 return 0;
257}
258
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800259static int rbd_release(struct gendisk *disk, fmode_t mode)
260{
261 struct rbd_device *rbd_dev = disk->private_data;
262
263 rbd_put_dev(rbd_dev);
264
265 return 0;
266}
267
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700268static const struct block_device_operations rbd_bd_ops = {
269 .owner = THIS_MODULE,
270 .open = rbd_open,
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800271 .release = rbd_release,
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700272};
273
274/*
275 * Initialize an rbd client instance.
Alex Elder43ae4702012-07-03 16:01:18 -0500276 * We own *ceph_opts.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700277 */
Alex Elder43ae4702012-07-03 16:01:18 -0500278static struct rbd_client *rbd_client_create(struct ceph_options *ceph_opts,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700279 struct rbd_options *rbd_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700280{
281 struct rbd_client *rbdc;
282 int ret = -ENOMEM;
283
284 dout("rbd_client_create\n");
285 rbdc = kmalloc(sizeof(struct rbd_client), GFP_KERNEL);
286 if (!rbdc)
287 goto out_opt;
288
289 kref_init(&rbdc->kref);
290 INIT_LIST_HEAD(&rbdc->node);
291
Alex Elderbc534d82012-01-29 13:57:44 -0600292 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
293
Alex Elder43ae4702012-07-03 16:01:18 -0500294 rbdc->client = ceph_create_client(ceph_opts, rbdc, 0, 0);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700295 if (IS_ERR(rbdc->client))
Alex Elderbc534d82012-01-29 13:57:44 -0600296 goto out_mutex;
Alex Elder43ae4702012-07-03 16:01:18 -0500297 ceph_opts = NULL; /* Now rbdc->client is responsible for ceph_opts */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700298
299 ret = ceph_open_session(rbdc->client);
300 if (ret < 0)
301 goto out_err;
302
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700303 rbdc->rbd_opts = rbd_opts;
304
Alex Elder432b8582012-01-29 13:57:44 -0600305 spin_lock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700306 list_add_tail(&rbdc->node, &rbd_client_list);
Alex Elder432b8582012-01-29 13:57:44 -0600307 spin_unlock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700308
Alex Elderbc534d82012-01-29 13:57:44 -0600309 mutex_unlock(&ctl_mutex);
310
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700311 dout("rbd_client_create created %p\n", rbdc);
312 return rbdc;
313
314out_err:
315 ceph_destroy_client(rbdc->client);
Alex Elderbc534d82012-01-29 13:57:44 -0600316out_mutex:
317 mutex_unlock(&ctl_mutex);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700318 kfree(rbdc);
319out_opt:
Alex Elder43ae4702012-07-03 16:01:18 -0500320 if (ceph_opts)
321 ceph_destroy_options(ceph_opts);
Vasiliy Kulikov28f259b2010-09-26 12:59:37 +0400322 return ERR_PTR(ret);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700323}
324
325/*
326 * Find a ceph client with specific addr and configuration.
327 */
Alex Elder43ae4702012-07-03 16:01:18 -0500328static struct rbd_client *__rbd_client_find(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700329{
330 struct rbd_client *client_node;
331
Alex Elder43ae4702012-07-03 16:01:18 -0500332 if (ceph_opts->flags & CEPH_OPT_NOSHARE)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700333 return NULL;
334
335 list_for_each_entry(client_node, &rbd_client_list, node)
Alex Elder43ae4702012-07-03 16:01:18 -0500336 if (!ceph_compare_options(ceph_opts, client_node->client))
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700337 return client_node;
338 return NULL;
339}
340
341/*
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700342 * mount options
343 */
344enum {
345 Opt_notify_timeout,
346 Opt_last_int,
347 /* int args above */
348 Opt_last_string,
349 /* string args above */
350};
351
Alex Elder43ae4702012-07-03 16:01:18 -0500352static match_table_t rbd_opts_tokens = {
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700353 {Opt_notify_timeout, "notify_timeout=%d"},
354 /* int args above */
355 /* string args above */
356 {-1, NULL}
357};
358
359static int parse_rbd_opts_token(char *c, void *private)
360{
Alex Elder43ae4702012-07-03 16:01:18 -0500361 struct rbd_options *rbd_opts = private;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700362 substring_t argstr[MAX_OPT_ARGS];
363 int token, intval, ret;
364
Alex Elder43ae4702012-07-03 16:01:18 -0500365 token = match_token(c, rbd_opts_tokens, argstr);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700366 if (token < 0)
367 return -EINVAL;
368
369 if (token < Opt_last_int) {
370 ret = match_int(&argstr[0], &intval);
371 if (ret < 0) {
372 pr_err("bad mount option arg (not int) "
373 "at '%s'\n", c);
374 return ret;
375 }
376 dout("got int token %d val %d\n", token, intval);
377 } else if (token > Opt_last_int && token < Opt_last_string) {
378 dout("got string token %d val %s\n", token,
379 argstr[0].from);
380 } else {
381 dout("got token %d\n", token);
382 }
383
384 switch (token) {
385 case Opt_notify_timeout:
Alex Elder43ae4702012-07-03 16:01:18 -0500386 rbd_opts->notify_timeout = intval;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700387 break;
388 default:
389 BUG_ON(token);
390 }
391 return 0;
392}
393
394/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700395 * Get a ceph client with specific addr and configuration, if one does
396 * not exist create it.
397 */
Alex Elder5214ecc2012-02-02 08:13:30 -0600398static struct rbd_client *rbd_get_client(const char *mon_addr,
399 size_t mon_addr_len,
400 char *options)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700401{
402 struct rbd_client *rbdc;
Alex Elder43ae4702012-07-03 16:01:18 -0500403 struct ceph_options *ceph_opts;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700404 struct rbd_options *rbd_opts;
405
406 rbd_opts = kzalloc(sizeof(*rbd_opts), GFP_KERNEL);
407 if (!rbd_opts)
Alex Elderd720bcb2012-02-02 08:13:30 -0600408 return ERR_PTR(-ENOMEM);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700409
410 rbd_opts->notify_timeout = RBD_NOTIFY_TIMEOUT_DEFAULT;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700411
Alex Elder43ae4702012-07-03 16:01:18 -0500412 ceph_opts = ceph_parse_options(options, mon_addr,
413 mon_addr + mon_addr_len,
414 parse_rbd_opts_token, rbd_opts);
415 if (IS_ERR(ceph_opts)) {
Alex Elderd720bcb2012-02-02 08:13:30 -0600416 kfree(rbd_opts);
Alex Elder43ae4702012-07-03 16:01:18 -0500417 return ERR_CAST(ceph_opts);
Alex Elderee577412012-01-24 10:08:36 -0600418 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700419
Alex Elder432b8582012-01-29 13:57:44 -0600420 spin_lock(&rbd_client_list_lock);
Alex Elder43ae4702012-07-03 16:01:18 -0500421 rbdc = __rbd_client_find(ceph_opts);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700422 if (rbdc) {
Alex Eldere6994d3d2012-01-29 13:57:44 -0600423 /* using an existing client */
424 kref_get(&rbdc->kref);
Alex Elder432b8582012-01-29 13:57:44 -0600425 spin_unlock(&rbd_client_list_lock);
Alex Eldere6994d3d2012-01-29 13:57:44 -0600426
Alex Elder43ae4702012-07-03 16:01:18 -0500427 ceph_destroy_options(ceph_opts);
Alex Elder97bb59a2012-01-24 10:08:36 -0600428 kfree(rbd_opts);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700429
Alex Elderd720bcb2012-02-02 08:13:30 -0600430 return rbdc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700431 }
Alex Elder432b8582012-01-29 13:57:44 -0600432 spin_unlock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700433
Alex Elder43ae4702012-07-03 16:01:18 -0500434 rbdc = rbd_client_create(ceph_opts, rbd_opts);
Alex Elderd97081b2012-01-29 13:57:44 -0600435
Alex Elderd720bcb2012-02-02 08:13:30 -0600436 if (IS_ERR(rbdc))
437 kfree(rbd_opts);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700438
Alex Elderd720bcb2012-02-02 08:13:30 -0600439 return rbdc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700440}
441
442/*
443 * Destroy ceph client
Alex Elderd23a4b32012-01-29 13:57:43 -0600444 *
Alex Elder432b8582012-01-29 13:57:44 -0600445 * Caller must hold rbd_client_list_lock.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700446 */
447static void rbd_client_release(struct kref *kref)
448{
449 struct rbd_client *rbdc = container_of(kref, struct rbd_client, kref);
450
451 dout("rbd_release_client %p\n", rbdc);
Alex Eldercd9d9f52012-04-04 13:35:44 -0500452 spin_lock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700453 list_del(&rbdc->node);
Alex Eldercd9d9f52012-04-04 13:35:44 -0500454 spin_unlock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700455
456 ceph_destroy_client(rbdc->client);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700457 kfree(rbdc->rbd_opts);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700458 kfree(rbdc);
459}
460
461/*
462 * Drop reference to ceph client node. If it's not referenced anymore, release
463 * it.
464 */
465static void rbd_put_client(struct rbd_device *rbd_dev)
466{
467 kref_put(&rbd_dev->rbd_client->kref, rbd_client_release);
468 rbd_dev->rbd_client = NULL;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700469}
470
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700471/*
472 * Destroy requests collection
473 */
474static void rbd_coll_release(struct kref *kref)
475{
476 struct rbd_req_coll *coll =
477 container_of(kref, struct rbd_req_coll, kref);
478
479 dout("rbd_coll_release %p\n", coll);
480 kfree(coll);
481}
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700482
Alex Elder8e94af82012-07-25 09:32:40 -0500483static bool rbd_dev_ondisk_valid(struct rbd_image_header_ondisk *ondisk)
484{
485 return !memcmp(&ondisk->text,
486 RBD_HEADER_TEXT, sizeof (RBD_HEADER_TEXT));
487}
488
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700489/*
490 * Create a new header structure, translate header format from the on-disk
491 * header.
492 */
493static int rbd_header_from_disk(struct rbd_image_header *header,
494 struct rbd_image_header_ondisk *ondisk,
Alex Eldered63f4f2012-07-19 09:09:27 -0500495 u32 allocated_snaps)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700496{
Xi Wang50f7c4c2012-04-20 15:49:44 -0500497 u32 i, snap_count;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700498
Alex Elder8e94af82012-07-25 09:32:40 -0500499 if (!rbd_dev_ondisk_valid(ondisk))
Josh Durgin81e759f2011-11-15 14:49:53 -0800500 return -ENXIO;
Josh Durgin81e759f2011-11-15 14:49:53 -0800501
Alex Elder00f1f362012-02-07 12:03:36 -0600502 snap_count = le32_to_cpu(ondisk->snap_count);
Xi Wang50f7c4c2012-04-20 15:49:44 -0500503 if (snap_count > (UINT_MAX - sizeof(struct ceph_snap_context))
504 / sizeof (*ondisk))
505 return -EINVAL;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700506 header->snapc = kmalloc(sizeof(struct ceph_snap_context) +
Yan, Zhengf9f9a192012-06-06 09:15:33 -0500507 snap_count * sizeof(u64),
Alex Eldered63f4f2012-07-19 09:09:27 -0500508 GFP_KERNEL);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700509 if (!header->snapc)
510 return -ENOMEM;
Alex Elder00f1f362012-02-07 12:03:36 -0600511
Alex Elder00f1f362012-02-07 12:03:36 -0600512 header->snap_names_len = le64_to_cpu(ondisk->snap_names_len);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700513 if (snap_count) {
514 header->snap_names = kmalloc(header->snap_names_len,
Alex Eldered63f4f2012-07-19 09:09:27 -0500515 GFP_KERNEL);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700516 if (!header->snap_names)
517 goto err_snapc;
518 header->snap_sizes = kmalloc(snap_count * sizeof(u64),
Alex Eldered63f4f2012-07-19 09:09:27 -0500519 GFP_KERNEL);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700520 if (!header->snap_sizes)
521 goto err_names;
522 } else {
523 header->snap_names = NULL;
524 header->snap_sizes = NULL;
525 }
Alex Elder849b4262012-07-09 21:04:24 -0500526
527 header->object_prefix = kmalloc(sizeof (ondisk->block_name) + 1,
Alex Eldered63f4f2012-07-19 09:09:27 -0500528 GFP_KERNEL);
Alex Elder849b4262012-07-09 21:04:24 -0500529 if (!header->object_prefix)
530 goto err_sizes;
531
Alex Elderca1e49a2012-07-10 20:30:09 -0500532 memcpy(header->object_prefix, ondisk->block_name,
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700533 sizeof(ondisk->block_name));
Alex Elder849b4262012-07-09 21:04:24 -0500534 header->object_prefix[sizeof (ondisk->block_name)] = '\0';
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700535
536 header->image_size = le64_to_cpu(ondisk->image_size);
537 header->obj_order = ondisk->options.order;
538 header->crypt_type = ondisk->options.crypt_type;
539 header->comp_type = ondisk->options.comp_type;
540
541 atomic_set(&header->snapc->nref, 1);
Alex Elder505cbb92012-07-19 08:49:18 -0500542 header->snapc->seq = le64_to_cpu(ondisk->snap_seq);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700543 header->snapc->num_snaps = snap_count;
544 header->total_snaps = snap_count;
545
Alex Elder21079782012-01-24 10:08:36 -0600546 if (snap_count && allocated_snaps == snap_count) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700547 for (i = 0; i < snap_count; i++) {
548 header->snapc->snaps[i] =
549 le64_to_cpu(ondisk->snaps[i].id);
550 header->snap_sizes[i] =
551 le64_to_cpu(ondisk->snaps[i].image_size);
552 }
553
554 /* copy snapshot names */
555 memcpy(header->snap_names, &ondisk->snaps[i],
556 header->snap_names_len);
557 }
558
559 return 0;
560
Alex Elder849b4262012-07-09 21:04:24 -0500561err_sizes:
562 kfree(header->snap_sizes);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700563err_names:
564 kfree(header->snap_names);
565err_snapc:
566 kfree(header->snapc);
Alex Elder00f1f362012-02-07 12:03:36 -0600567 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700568}
569
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700570static int snap_by_name(struct rbd_image_header *header, const char *snap_name,
571 u64 *seq, u64 *size)
572{
573 int i;
574 char *p = header->snap_names;
575
Alex Elder00f1f362012-02-07 12:03:36 -0600576 for (i = 0; i < header->total_snaps; i++) {
577 if (!strcmp(snap_name, p)) {
578
579 /* Found it. Pass back its id and/or size */
580
581 if (seq)
582 *seq = header->snapc->snaps[i];
583 if (size)
584 *size = header->snap_sizes[i];
585 return i;
586 }
587 p += strlen(p) + 1; /* Skip ahead to the next name */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700588 }
Alex Elder00f1f362012-02-07 12:03:36 -0600589 return -ENOENT;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700590}
591
Alex Elder0ce1a792012-07-03 16:01:18 -0500592static int rbd_header_set_snap(struct rbd_device *rbd_dev, u64 *size)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700593{
Alex Elder78dc4472012-07-19 08:49:18 -0500594 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700595
Alex Elder0ce1a792012-07-03 16:01:18 -0500596 down_write(&rbd_dev->header_rwsem);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700597
Alex Elder0ce1a792012-07-03 16:01:18 -0500598 if (!memcmp(rbd_dev->snap_name, RBD_SNAP_HEAD_NAME,
Josh Durgincc9d7342011-11-21 18:19:13 -0800599 sizeof (RBD_SNAP_HEAD_NAME))) {
Alex Elder0ce1a792012-07-03 16:01:18 -0500600 rbd_dev->snap_id = CEPH_NOSNAP;
Josh Durgine88a36e2011-11-21 18:14:25 -0800601 rbd_dev->snap_exists = false;
Alex Elder0ce1a792012-07-03 16:01:18 -0500602 rbd_dev->read_only = 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700603 if (size)
Alex Elder78dc4472012-07-19 08:49:18 -0500604 *size = rbd_dev->header.image_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700605 } else {
Alex Elder78dc4472012-07-19 08:49:18 -0500606 u64 snap_id = 0;
607
608 ret = snap_by_name(&rbd_dev->header, rbd_dev->snap_name,
609 &snap_id, size);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700610 if (ret < 0)
611 goto done;
Alex Elder78dc4472012-07-19 08:49:18 -0500612 rbd_dev->snap_id = snap_id;
Josh Durgine88a36e2011-11-21 18:14:25 -0800613 rbd_dev->snap_exists = true;
Alex Elder0ce1a792012-07-03 16:01:18 -0500614 rbd_dev->read_only = 1;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700615 }
616
617 ret = 0;
618done:
Alex Elder0ce1a792012-07-03 16:01:18 -0500619 up_write(&rbd_dev->header_rwsem);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700620 return ret;
621}
622
623static void rbd_header_free(struct rbd_image_header *header)
624{
Alex Elder849b4262012-07-09 21:04:24 -0500625 kfree(header->object_prefix);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700626 kfree(header->snap_sizes);
Alex Elder849b4262012-07-09 21:04:24 -0500627 kfree(header->snap_names);
Josh Durgind1d25642011-12-05 14:03:05 -0800628 ceph_put_snap_context(header->snapc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700629}
630
631/*
632 * get the actual striped segment name, offset and length
633 */
634static u64 rbd_get_segment(struct rbd_image_header *header,
Alex Elderca1e49a2012-07-10 20:30:09 -0500635 const char *object_prefix,
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700636 u64 ofs, u64 len,
637 char *seg_name, u64 *segofs)
638{
639 u64 seg = ofs >> header->obj_order;
640
641 if (seg_name)
642 snprintf(seg_name, RBD_MAX_SEG_NAME_LEN,
Alex Elderca1e49a2012-07-10 20:30:09 -0500643 "%s.%012llx", object_prefix, seg);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700644
645 ofs = ofs & ((1 << header->obj_order) - 1);
646 len = min_t(u64, len, (1 << header->obj_order) - ofs);
647
648 if (segofs)
649 *segofs = ofs;
650
651 return len;
652}
653
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700654static int rbd_get_num_segments(struct rbd_image_header *header,
655 u64 ofs, u64 len)
656{
657 u64 start_seg = ofs >> header->obj_order;
658 u64 end_seg = (ofs + len - 1) >> header->obj_order;
659 return end_seg - start_seg + 1;
660}
661
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700662/*
Josh Durgin029bcbd2011-07-22 11:35:23 -0700663 * returns the size of an object in the image
664 */
665static u64 rbd_obj_bytes(struct rbd_image_header *header)
666{
667 return 1 << header->obj_order;
668}
669
670/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700671 * bio helpers
672 */
673
674static void bio_chain_put(struct bio *chain)
675{
676 struct bio *tmp;
677
678 while (chain) {
679 tmp = chain;
680 chain = chain->bi_next;
681 bio_put(tmp);
682 }
683}
684
685/*
686 * zeros a bio chain, starting at specific offset
687 */
688static void zero_bio_chain(struct bio *chain, int start_ofs)
689{
690 struct bio_vec *bv;
691 unsigned long flags;
692 void *buf;
693 int i;
694 int pos = 0;
695
696 while (chain) {
697 bio_for_each_segment(bv, chain, i) {
698 if (pos + bv->bv_len > start_ofs) {
699 int remainder = max(start_ofs - pos, 0);
700 buf = bvec_kmap_irq(bv, &flags);
701 memset(buf + remainder, 0,
702 bv->bv_len - remainder);
Dan Carpenter85b5aaa2010-10-11 21:15:11 +0200703 bvec_kunmap_irq(buf, &flags);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700704 }
705 pos += bv->bv_len;
706 }
707
708 chain = chain->bi_next;
709 }
710}
711
712/*
713 * bio_chain_clone - clone a chain of bios up to a certain length.
714 * might return a bio_pair that will need to be released.
715 */
716static struct bio *bio_chain_clone(struct bio **old, struct bio **next,
717 struct bio_pair **bp,
718 int len, gfp_t gfpmask)
719{
720 struct bio *tmp, *old_chain = *old, *new_chain = NULL, *tail = NULL;
721 int total = 0;
722
723 if (*bp) {
724 bio_pair_release(*bp);
725 *bp = NULL;
726 }
727
728 while (old_chain && (total < len)) {
729 tmp = bio_kmalloc(gfpmask, old_chain->bi_max_vecs);
730 if (!tmp)
731 goto err_out;
732
733 if (total + old_chain->bi_size > len) {
734 struct bio_pair *bp;
735
736 /*
737 * this split can only happen with a single paged bio,
738 * split_bio will BUG_ON if this is not the case
739 */
740 dout("bio_chain_clone split! total=%d remaining=%d"
Alex Elderbd919d42012-07-13 20:35:11 -0500741 "bi_size=%u\n",
742 total, len - total, old_chain->bi_size);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700743
744 /* split the bio. We'll release it either in the next
745 call, or it will have to be released outside */
Alex Elder593a9e72012-02-07 12:03:37 -0600746 bp = bio_split(old_chain, (len - total) / SECTOR_SIZE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700747 if (!bp)
748 goto err_out;
749
750 __bio_clone(tmp, &bp->bio1);
751
752 *next = &bp->bio2;
753 } else {
754 __bio_clone(tmp, old_chain);
755 *next = old_chain->bi_next;
756 }
757
758 tmp->bi_bdev = NULL;
759 gfpmask &= ~__GFP_WAIT;
760 tmp->bi_next = NULL;
761
762 if (!new_chain) {
763 new_chain = tail = tmp;
764 } else {
765 tail->bi_next = tmp;
766 tail = tmp;
767 }
768 old_chain = old_chain->bi_next;
769
770 total += tmp->bi_size;
771 }
772
773 BUG_ON(total < len);
774
775 if (tail)
776 tail->bi_next = NULL;
777
778 *old = old_chain;
779
780 return new_chain;
781
782err_out:
783 dout("bio_chain_clone with err\n");
784 bio_chain_put(new_chain);
785 return NULL;
786}
787
788/*
789 * helpers for osd request op vectors.
790 */
791static int rbd_create_rw_ops(struct ceph_osd_req_op **ops,
792 int num_ops,
793 int opcode,
794 u32 payload_len)
795{
796 *ops = kzalloc(sizeof(struct ceph_osd_req_op) * (num_ops + 1),
797 GFP_NOIO);
798 if (!*ops)
799 return -ENOMEM;
800 (*ops)[0].op = opcode;
801 /*
802 * op extent offset and length will be set later on
803 * in calc_raw_layout()
804 */
805 (*ops)[0].payload_len = payload_len;
806 return 0;
807}
808
809static void rbd_destroy_ops(struct ceph_osd_req_op *ops)
810{
811 kfree(ops);
812}
813
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700814static void rbd_coll_end_req_index(struct request *rq,
815 struct rbd_req_coll *coll,
816 int index,
817 int ret, u64 len)
818{
819 struct request_queue *q;
820 int min, max, i;
821
Alex Elderbd919d42012-07-13 20:35:11 -0500822 dout("rbd_coll_end_req_index %p index %d ret %d len %llu\n",
823 coll, index, ret, (unsigned long long) len);
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700824
825 if (!rq)
826 return;
827
828 if (!coll) {
829 blk_end_request(rq, ret, len);
830 return;
831 }
832
833 q = rq->q;
834
835 spin_lock_irq(q->queue_lock);
836 coll->status[index].done = 1;
837 coll->status[index].rc = ret;
838 coll->status[index].bytes = len;
839 max = min = coll->num_done;
840 while (max < coll->total && coll->status[max].done)
841 max++;
842
843 for (i = min; i<max; i++) {
844 __blk_end_request(rq, coll->status[i].rc,
845 coll->status[i].bytes);
846 coll->num_done++;
847 kref_put(&coll->kref, rbd_coll_release);
848 }
849 spin_unlock_irq(q->queue_lock);
850}
851
852static void rbd_coll_end_req(struct rbd_request *req,
853 int ret, u64 len)
854{
855 rbd_coll_end_req_index(req->rq, req->coll, req->coll_index, ret, len);
856}
857
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700858/*
859 * Send ceph osd request
860 */
861static int rbd_do_request(struct request *rq,
Alex Elder0ce1a792012-07-03 16:01:18 -0500862 struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700863 struct ceph_snap_context *snapc,
864 u64 snapid,
Alex Elderaded07e2012-07-03 16:01:18 -0500865 const char *object_name, u64 ofs, u64 len,
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700866 struct bio *bio,
867 struct page **pages,
868 int num_pages,
869 int flags,
870 struct ceph_osd_req_op *ops,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700871 struct rbd_req_coll *coll,
872 int coll_index,
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700873 void (*rbd_cb)(struct ceph_osd_request *req,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700874 struct ceph_msg *msg),
875 struct ceph_osd_request **linger_req,
876 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700877{
878 struct ceph_osd_request *req;
879 struct ceph_file_layout *layout;
880 int ret;
881 u64 bno;
882 struct timespec mtime = CURRENT_TIME;
883 struct rbd_request *req_data;
884 struct ceph_osd_request_head *reqhead;
Alex Elder1dbb4392012-01-24 10:08:37 -0600885 struct ceph_osd_client *osdc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700886
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700887 req_data = kzalloc(sizeof(*req_data), GFP_NOIO);
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700888 if (!req_data) {
889 if (coll)
890 rbd_coll_end_req_index(rq, coll, coll_index,
891 -ENOMEM, len);
892 return -ENOMEM;
893 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700894
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700895 if (coll) {
896 req_data->coll = coll;
897 req_data->coll_index = coll_index;
898 }
899
Alex Elderbd919d42012-07-13 20:35:11 -0500900 dout("rbd_do_request object_name=%s ofs=%llu len=%llu\n", object_name,
901 (unsigned long long) ofs, (unsigned long long) len);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700902
Alex Elder0ce1a792012-07-03 16:01:18 -0500903 osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elder1dbb4392012-01-24 10:08:37 -0600904 req = ceph_osdc_alloc_request(osdc, flags, snapc, ops,
905 false, GFP_NOIO, pages, bio);
Sage Weil4ad12622011-05-03 09:23:36 -0700906 if (!req) {
Sage Weil4ad12622011-05-03 09:23:36 -0700907 ret = -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700908 goto done_pages;
909 }
910
911 req->r_callback = rbd_cb;
912
913 req_data->rq = rq;
914 req_data->bio = bio;
915 req_data->pages = pages;
916 req_data->len = len;
917
918 req->r_priv = req_data;
919
920 reqhead = req->r_request->front.iov_base;
921 reqhead->snapid = cpu_to_le64(CEPH_NOSNAP);
922
Alex Elderaded07e2012-07-03 16:01:18 -0500923 strncpy(req->r_oid, object_name, sizeof(req->r_oid));
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700924 req->r_oid_len = strlen(req->r_oid);
925
926 layout = &req->r_file_layout;
927 memset(layout, 0, sizeof(*layout));
928 layout->fl_stripe_unit = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
929 layout->fl_stripe_count = cpu_to_le32(1);
930 layout->fl_object_size = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
Alex Elder0ce1a792012-07-03 16:01:18 -0500931 layout->fl_pg_pool = cpu_to_le32(rbd_dev->pool_id);
Alex Elder1dbb4392012-01-24 10:08:37 -0600932 ceph_calc_raw_layout(osdc, layout, snapid, ofs, &len, &bno,
933 req, ops);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700934
935 ceph_osdc_build_request(req, ofs, &len,
936 ops,
937 snapc,
938 &mtime,
939 req->r_oid, req->r_oid_len);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700940
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700941 if (linger_req) {
Alex Elder1dbb4392012-01-24 10:08:37 -0600942 ceph_osdc_set_request_linger(osdc, req);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700943 *linger_req = req;
944 }
945
Alex Elder1dbb4392012-01-24 10:08:37 -0600946 ret = ceph_osdc_start_request(osdc, req, false);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700947 if (ret < 0)
948 goto done_err;
949
950 if (!rbd_cb) {
Alex Elder1dbb4392012-01-24 10:08:37 -0600951 ret = ceph_osdc_wait_request(osdc, req);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700952 if (ver)
953 *ver = le64_to_cpu(req->r_reassert_version.version);
Alex Elderbd919d42012-07-13 20:35:11 -0500954 dout("reassert_ver=%llu\n",
955 (unsigned long long)
956 le64_to_cpu(req->r_reassert_version.version));
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700957 ceph_osdc_put_request(req);
958 }
959 return ret;
960
961done_err:
962 bio_chain_put(req_data->bio);
963 ceph_osdc_put_request(req);
964done_pages:
Yehuda Sadeh1fec7092011-05-13 13:52:56 -0700965 rbd_coll_end_req(req_data, ret, len);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700966 kfree(req_data);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700967 return ret;
968}
969
970/*
971 * Ceph osd op callback
972 */
973static void rbd_req_cb(struct ceph_osd_request *req, struct ceph_msg *msg)
974{
975 struct rbd_request *req_data = req->r_priv;
976 struct ceph_osd_reply_head *replyhead;
977 struct ceph_osd_op *op;
978 __s32 rc;
979 u64 bytes;
980 int read_op;
981
982 /* parse reply */
983 replyhead = msg->front.iov_base;
984 WARN_ON(le32_to_cpu(replyhead->num_ops) == 0);
985 op = (void *)(replyhead + 1);
986 rc = le32_to_cpu(replyhead->result);
987 bytes = le64_to_cpu(op->extent.length);
Dan Carpenter895cfcc2012-06-06 09:15:33 -0500988 read_op = (le16_to_cpu(op->op) == CEPH_OSD_OP_READ);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700989
Alex Elderbd919d42012-07-13 20:35:11 -0500990 dout("rbd_req_cb bytes=%llu readop=%d rc=%d\n",
991 (unsigned long long) bytes, read_op, (int) rc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700992
993 if (rc == -ENOENT && read_op) {
994 zero_bio_chain(req_data->bio, 0);
995 rc = 0;
996 } else if (rc == 0 && read_op && bytes < req_data->len) {
997 zero_bio_chain(req_data->bio, bytes);
998 bytes = req_data->len;
999 }
1000
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001001 rbd_coll_end_req(req_data, rc, bytes);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001002
1003 if (req_data->bio)
1004 bio_chain_put(req_data->bio);
1005
1006 ceph_osdc_put_request(req);
1007 kfree(req_data);
1008}
1009
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001010static void rbd_simple_req_cb(struct ceph_osd_request *req, struct ceph_msg *msg)
1011{
1012 ceph_osdc_put_request(req);
1013}
1014
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001015/*
1016 * Do a synchronous ceph osd operation
1017 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001018static int rbd_req_sync_op(struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001019 struct ceph_snap_context *snapc,
1020 u64 snapid,
1021 int opcode,
1022 int flags,
1023 struct ceph_osd_req_op *orig_ops,
Alex Elderaded07e2012-07-03 16:01:18 -05001024 const char *object_name,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001025 u64 ofs, u64 len,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001026 char *buf,
1027 struct ceph_osd_request **linger_req,
1028 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001029{
1030 int ret;
1031 struct page **pages;
1032 int num_pages;
1033 struct ceph_osd_req_op *ops = orig_ops;
1034 u32 payload_len;
1035
1036 num_pages = calc_pages_for(ofs , len);
1037 pages = ceph_alloc_page_vector(num_pages, GFP_KERNEL);
Dan Carpenterb8d06382010-10-11 21:14:23 +02001038 if (IS_ERR(pages))
1039 return PTR_ERR(pages);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001040
1041 if (!orig_ops) {
1042 payload_len = (flags & CEPH_OSD_FLAG_WRITE ? len : 0);
1043 ret = rbd_create_rw_ops(&ops, 1, opcode, payload_len);
1044 if (ret < 0)
1045 goto done;
1046
1047 if ((flags & CEPH_OSD_FLAG_WRITE) && buf) {
1048 ret = ceph_copy_to_page_vector(pages, buf, ofs, len);
1049 if (ret < 0)
1050 goto done_ops;
1051 }
1052 }
1053
Alex Elder0ce1a792012-07-03 16:01:18 -05001054 ret = rbd_do_request(NULL, rbd_dev, snapc, snapid,
Alex Elderaded07e2012-07-03 16:01:18 -05001055 object_name, ofs, len, NULL,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001056 pages, num_pages,
1057 flags,
1058 ops,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001059 NULL, 0,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001060 NULL,
1061 linger_req, ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001062 if (ret < 0)
1063 goto done_ops;
1064
1065 if ((flags & CEPH_OSD_FLAG_READ) && buf)
1066 ret = ceph_copy_from_page_vector(pages, buf, ofs, ret);
1067
1068done_ops:
1069 if (!orig_ops)
1070 rbd_destroy_ops(ops);
1071done:
1072 ceph_release_page_vector(pages, num_pages);
1073 return ret;
1074}
1075
1076/*
1077 * Do an asynchronous ceph osd operation
1078 */
1079static int rbd_do_op(struct request *rq,
Alex Elder0ce1a792012-07-03 16:01:18 -05001080 struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001081 struct ceph_snap_context *snapc,
1082 u64 snapid,
Alex Elderd1f57ea2012-06-26 12:57:03 -07001083 int opcode, int flags,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001084 u64 ofs, u64 len,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001085 struct bio *bio,
1086 struct rbd_req_coll *coll,
1087 int coll_index)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001088{
1089 char *seg_name;
1090 u64 seg_ofs;
1091 u64 seg_len;
1092 int ret;
1093 struct ceph_osd_req_op *ops;
1094 u32 payload_len;
1095
1096 seg_name = kmalloc(RBD_MAX_SEG_NAME_LEN + 1, GFP_NOIO);
1097 if (!seg_name)
1098 return -ENOMEM;
1099
1100 seg_len = rbd_get_segment(&rbd_dev->header,
Alex Elderca1e49a2012-07-10 20:30:09 -05001101 rbd_dev->header.object_prefix,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001102 ofs, len,
1103 seg_name, &seg_ofs);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001104
1105 payload_len = (flags & CEPH_OSD_FLAG_WRITE ? seg_len : 0);
1106
1107 ret = rbd_create_rw_ops(&ops, 1, opcode, payload_len);
1108 if (ret < 0)
1109 goto done;
1110
1111 /* we've taken care of segment sizes earlier when we
1112 cloned the bios. We should never have a segment
1113 truncated at this point */
1114 BUG_ON(seg_len < len);
1115
1116 ret = rbd_do_request(rq, rbd_dev, snapc, snapid,
1117 seg_name, seg_ofs, seg_len,
1118 bio,
1119 NULL, 0,
1120 flags,
1121 ops,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001122 coll, coll_index,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001123 rbd_req_cb, 0, NULL);
Sage Weil11f77002011-05-12 16:13:54 -07001124
1125 rbd_destroy_ops(ops);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001126done:
1127 kfree(seg_name);
1128 return ret;
1129}
1130
1131/*
1132 * Request async osd write
1133 */
1134static int rbd_req_write(struct request *rq,
1135 struct rbd_device *rbd_dev,
1136 struct ceph_snap_context *snapc,
1137 u64 ofs, u64 len,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001138 struct bio *bio,
1139 struct rbd_req_coll *coll,
1140 int coll_index)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001141{
1142 return rbd_do_op(rq, rbd_dev, snapc, CEPH_NOSNAP,
1143 CEPH_OSD_OP_WRITE,
1144 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001145 ofs, len, bio, coll, coll_index);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001146}
1147
1148/*
1149 * Request async osd read
1150 */
1151static int rbd_req_read(struct request *rq,
1152 struct rbd_device *rbd_dev,
1153 u64 snapid,
1154 u64 ofs, u64 len,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001155 struct bio *bio,
1156 struct rbd_req_coll *coll,
1157 int coll_index)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001158{
1159 return rbd_do_op(rq, rbd_dev, NULL,
Josh Durginb06e6a62011-11-21 18:16:52 -08001160 snapid,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001161 CEPH_OSD_OP_READ,
1162 CEPH_OSD_FLAG_READ,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001163 ofs, len, bio, coll, coll_index);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001164}
1165
1166/*
1167 * Request sync osd read
1168 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001169static int rbd_req_sync_read(struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001170 u64 snapid,
Alex Elderaded07e2012-07-03 16:01:18 -05001171 const char *object_name,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001172 u64 ofs, u64 len,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001173 char *buf,
1174 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001175{
Alex Elder0ce1a792012-07-03 16:01:18 -05001176 return rbd_req_sync_op(rbd_dev, NULL,
Josh Durginb06e6a62011-11-21 18:16:52 -08001177 snapid,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001178 CEPH_OSD_OP_READ,
1179 CEPH_OSD_FLAG_READ,
1180 NULL,
Alex Elderd1f57ea2012-06-26 12:57:03 -07001181 object_name, ofs, len, buf, NULL, ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001182}
1183
1184/*
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001185 * Request sync osd watch
1186 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001187static int rbd_req_sync_notify_ack(struct rbd_device *rbd_dev,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001188 u64 ver,
1189 u64 notify_id,
Alex Elderaded07e2012-07-03 16:01:18 -05001190 const char *object_name)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001191{
1192 struct ceph_osd_req_op *ops;
Sage Weil11f77002011-05-12 16:13:54 -07001193 int ret;
1194
1195 ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_NOTIFY_ACK, 0);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001196 if (ret < 0)
1197 return ret;
1198
Josh Durgina71b8912011-12-05 18:10:44 -08001199 ops[0].watch.ver = cpu_to_le64(ver);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001200 ops[0].watch.cookie = notify_id;
1201 ops[0].watch.flag = 0;
1202
Alex Elder0ce1a792012-07-03 16:01:18 -05001203 ret = rbd_do_request(NULL, rbd_dev, NULL, CEPH_NOSNAP,
Alex Elderaded07e2012-07-03 16:01:18 -05001204 object_name, 0, 0, NULL,
Alex Elderad4f2322012-07-03 16:01:19 -05001205 NULL, 0,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001206 CEPH_OSD_FLAG_READ,
1207 ops,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001208 NULL, 0,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001209 rbd_simple_req_cb, 0, NULL);
1210
1211 rbd_destroy_ops(ops);
1212 return ret;
1213}
1214
1215static void rbd_watch_cb(u64 ver, u64 notify_id, u8 opcode, void *data)
1216{
Alex Elder0ce1a792012-07-03 16:01:18 -05001217 struct rbd_device *rbd_dev = (struct rbd_device *)data;
Josh Durgina71b8912011-12-05 18:10:44 -08001218 u64 hver;
Sage Weil13143d22011-05-12 16:08:30 -07001219 int rc;
1220
Alex Elder0ce1a792012-07-03 16:01:18 -05001221 if (!rbd_dev)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001222 return;
1223
Alex Elderbd919d42012-07-13 20:35:11 -05001224 dout("rbd_watch_cb %s notify_id=%llu opcode=%u\n",
1225 rbd_dev->header_name, (unsigned long long) notify_id,
1226 (unsigned int) opcode);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001227 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Alex Elder0ce1a792012-07-03 16:01:18 -05001228 rc = __rbd_refresh_header(rbd_dev);
Josh Durgina71b8912011-12-05 18:10:44 -08001229 hver = rbd_dev->header.obj_version;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001230 mutex_unlock(&ctl_mutex);
Sage Weil13143d22011-05-12 16:08:30 -07001231 if (rc)
Alex Elderf0f8cef2012-01-29 13:57:44 -06001232 pr_warning(RBD_DRV_NAME "%d got notification but failed to "
Alex Elder0ce1a792012-07-03 16:01:18 -05001233 " update snaps: %d\n", rbd_dev->major, rc);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001234
Josh Durgina71b8912011-12-05 18:10:44 -08001235 rbd_req_sync_notify_ack(rbd_dev, hver, notify_id, rbd_dev->header_name);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001236}
1237
1238/*
1239 * Request sync osd watch
1240 */
Alex Elder0e6f3222012-07-25 09:32:40 -05001241static int rbd_req_sync_watch(struct rbd_device *rbd_dev)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001242{
1243 struct ceph_osd_req_op *ops;
Alex Elder0ce1a792012-07-03 16:01:18 -05001244 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001245
1246 int ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_WATCH, 0);
1247 if (ret < 0)
1248 return ret;
1249
1250 ret = ceph_osdc_create_event(osdc, rbd_watch_cb, 0,
Alex Elder0ce1a792012-07-03 16:01:18 -05001251 (void *)rbd_dev, &rbd_dev->watch_event);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001252 if (ret < 0)
1253 goto fail;
1254
Alex Elder0e6f3222012-07-25 09:32:40 -05001255 ops[0].watch.ver = cpu_to_le64(rbd_dev->header.obj_version);
Alex Elder0ce1a792012-07-03 16:01:18 -05001256 ops[0].watch.cookie = cpu_to_le64(rbd_dev->watch_event->cookie);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001257 ops[0].watch.flag = 1;
1258
Alex Elder0ce1a792012-07-03 16:01:18 -05001259 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001260 CEPH_NOSNAP,
1261 0,
1262 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1263 ops,
Alex Elder0e6f3222012-07-25 09:32:40 -05001264 rbd_dev->header_name,
1265 0, 0, NULL,
Alex Elder0ce1a792012-07-03 16:01:18 -05001266 &rbd_dev->watch_request, NULL);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001267
1268 if (ret < 0)
1269 goto fail_event;
1270
1271 rbd_destroy_ops(ops);
1272 return 0;
1273
1274fail_event:
Alex Elder0ce1a792012-07-03 16:01:18 -05001275 ceph_osdc_cancel_event(rbd_dev->watch_event);
1276 rbd_dev->watch_event = NULL;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001277fail:
1278 rbd_destroy_ops(ops);
1279 return ret;
1280}
1281
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001282/*
1283 * Request sync osd unwatch
1284 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001285static int rbd_req_sync_unwatch(struct rbd_device *rbd_dev,
Alex Elderaded07e2012-07-03 16:01:18 -05001286 const char *object_name)
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001287{
1288 struct ceph_osd_req_op *ops;
1289
1290 int ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_WATCH, 0);
1291 if (ret < 0)
1292 return ret;
1293
1294 ops[0].watch.ver = 0;
Alex Elder0ce1a792012-07-03 16:01:18 -05001295 ops[0].watch.cookie = cpu_to_le64(rbd_dev->watch_event->cookie);
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001296 ops[0].watch.flag = 0;
1297
Alex Elder0ce1a792012-07-03 16:01:18 -05001298 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001299 CEPH_NOSNAP,
1300 0,
1301 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1302 ops,
Alex Elderd1f57ea2012-06-26 12:57:03 -07001303 object_name, 0, 0, NULL, NULL, NULL);
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001304
1305 rbd_destroy_ops(ops);
Alex Elder0ce1a792012-07-03 16:01:18 -05001306 ceph_osdc_cancel_event(rbd_dev->watch_event);
1307 rbd_dev->watch_event = NULL;
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001308 return ret;
1309}
1310
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001311struct rbd_notify_info {
Alex Elder0ce1a792012-07-03 16:01:18 -05001312 struct rbd_device *rbd_dev;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001313};
1314
1315static void rbd_notify_cb(u64 ver, u64 notify_id, u8 opcode, void *data)
1316{
Alex Elder0ce1a792012-07-03 16:01:18 -05001317 struct rbd_device *rbd_dev = (struct rbd_device *)data;
1318 if (!rbd_dev)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001319 return;
1320
Alex Elderbd919d42012-07-13 20:35:11 -05001321 dout("rbd_notify_cb %s notify_id=%llu opcode=%u\n",
1322 rbd_dev->header_name, (unsigned long long) notify_id,
1323 (unsigned int) opcode);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001324}
1325
1326/*
1327 * Request sync osd notify
1328 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001329static int rbd_req_sync_notify(struct rbd_device *rbd_dev,
Alex Elderaded07e2012-07-03 16:01:18 -05001330 const char *object_name)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001331{
1332 struct ceph_osd_req_op *ops;
Alex Elder0ce1a792012-07-03 16:01:18 -05001333 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001334 struct ceph_osd_event *event;
1335 struct rbd_notify_info info;
1336 int payload_len = sizeof(u32) + sizeof(u32);
1337 int ret;
1338
1339 ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_NOTIFY, payload_len);
1340 if (ret < 0)
1341 return ret;
1342
Alex Elder0ce1a792012-07-03 16:01:18 -05001343 info.rbd_dev = rbd_dev;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001344
1345 ret = ceph_osdc_create_event(osdc, rbd_notify_cb, 1,
1346 (void *)&info, &event);
1347 if (ret < 0)
1348 goto fail;
1349
1350 ops[0].watch.ver = 1;
1351 ops[0].watch.flag = 1;
1352 ops[0].watch.cookie = event->cookie;
1353 ops[0].watch.prot_ver = RADOS_NOTIFY_VER;
1354 ops[0].watch.timeout = 12;
1355
Alex Elder0ce1a792012-07-03 16:01:18 -05001356 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001357 CEPH_NOSNAP,
1358 0,
1359 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1360 ops,
Alex Elderd1f57ea2012-06-26 12:57:03 -07001361 object_name, 0, 0, NULL, NULL, NULL);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001362 if (ret < 0)
1363 goto fail_event;
1364
1365 ret = ceph_osdc_wait_event(event, CEPH_OSD_TIMEOUT_DEFAULT);
1366 dout("ceph_osdc_wait_event returned %d\n", ret);
1367 rbd_destroy_ops(ops);
1368 return 0;
1369
1370fail_event:
1371 ceph_osdc_cancel_event(event);
1372fail:
1373 rbd_destroy_ops(ops);
1374 return ret;
1375}
1376
1377/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001378 * Request sync osd read
1379 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001380static int rbd_req_sync_exec(struct rbd_device *rbd_dev,
Alex Elderaded07e2012-07-03 16:01:18 -05001381 const char *object_name,
1382 const char *class_name,
1383 const char *method_name,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001384 const char *data,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001385 int len,
1386 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001387{
1388 struct ceph_osd_req_op *ops;
Alex Elderaded07e2012-07-03 16:01:18 -05001389 int class_name_len = strlen(class_name);
1390 int method_name_len = strlen(method_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001391 int ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_CALL,
Alex Elderaded07e2012-07-03 16:01:18 -05001392 class_name_len + method_name_len + len);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001393 if (ret < 0)
1394 return ret;
1395
Alex Elderaded07e2012-07-03 16:01:18 -05001396 ops[0].cls.class_name = class_name;
1397 ops[0].cls.class_len = (__u8) class_name_len;
1398 ops[0].cls.method_name = method_name;
1399 ops[0].cls.method_len = (__u8) method_name_len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001400 ops[0].cls.argc = 0;
1401 ops[0].cls.indata = data;
1402 ops[0].cls.indata_len = len;
1403
Alex Elder0ce1a792012-07-03 16:01:18 -05001404 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001405 CEPH_NOSNAP,
1406 0,
1407 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1408 ops,
Alex Elderd1f57ea2012-06-26 12:57:03 -07001409 object_name, 0, 0, NULL, NULL, ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001410
1411 rbd_destroy_ops(ops);
1412
1413 dout("cls_exec returned %d\n", ret);
1414 return ret;
1415}
1416
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001417static struct rbd_req_coll *rbd_alloc_coll(int num_reqs)
1418{
1419 struct rbd_req_coll *coll =
1420 kzalloc(sizeof(struct rbd_req_coll) +
1421 sizeof(struct rbd_req_status) * num_reqs,
1422 GFP_ATOMIC);
1423
1424 if (!coll)
1425 return NULL;
1426 coll->total = num_reqs;
1427 kref_init(&coll->kref);
1428 return coll;
1429}
1430
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001431/*
1432 * block device queue callback
1433 */
1434static void rbd_rq_fn(struct request_queue *q)
1435{
1436 struct rbd_device *rbd_dev = q->queuedata;
1437 struct request *rq;
1438 struct bio_pair *bp = NULL;
1439
Alex Elder00f1f362012-02-07 12:03:36 -06001440 while ((rq = blk_fetch_request(q))) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001441 struct bio *bio;
1442 struct bio *rq_bio, *next_bio = NULL;
1443 bool do_write;
Alex Elderbd919d42012-07-13 20:35:11 -05001444 unsigned int size;
1445 u64 op_size = 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001446 u64 ofs;
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001447 int num_segs, cur_seg = 0;
1448 struct rbd_req_coll *coll;
Josh Durgind1d25642011-12-05 14:03:05 -08001449 struct ceph_snap_context *snapc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001450
1451 /* peek at request from block layer */
1452 if (!rq)
1453 break;
1454
1455 dout("fetched request\n");
1456
1457 /* filter out block requests we don't understand */
1458 if ((rq->cmd_type != REQ_TYPE_FS)) {
1459 __blk_end_request_all(rq, 0);
Alex Elder00f1f362012-02-07 12:03:36 -06001460 continue;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001461 }
1462
1463 /* deduce our operation (read, write) */
1464 do_write = (rq_data_dir(rq) == WRITE);
1465
1466 size = blk_rq_bytes(rq);
Alex Elder593a9e72012-02-07 12:03:37 -06001467 ofs = blk_rq_pos(rq) * SECTOR_SIZE;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001468 rq_bio = rq->bio;
1469 if (do_write && rbd_dev->read_only) {
1470 __blk_end_request_all(rq, -EROFS);
Alex Elder00f1f362012-02-07 12:03:36 -06001471 continue;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001472 }
1473
1474 spin_unlock_irq(q->queue_lock);
1475
Josh Durgind1d25642011-12-05 14:03:05 -08001476 down_read(&rbd_dev->header_rwsem);
Josh Durgine88a36e2011-11-21 18:14:25 -08001477
Josh Durgind1d25642011-12-05 14:03:05 -08001478 if (rbd_dev->snap_id != CEPH_NOSNAP && !rbd_dev->snap_exists) {
Josh Durgine88a36e2011-11-21 18:14:25 -08001479 up_read(&rbd_dev->header_rwsem);
Josh Durgind1d25642011-12-05 14:03:05 -08001480 dout("request for non-existent snapshot");
1481 spin_lock_irq(q->queue_lock);
1482 __blk_end_request_all(rq, -ENXIO);
1483 continue;
Josh Durgine88a36e2011-11-21 18:14:25 -08001484 }
1485
Josh Durgind1d25642011-12-05 14:03:05 -08001486 snapc = ceph_get_snap_context(rbd_dev->header.snapc);
1487
1488 up_read(&rbd_dev->header_rwsem);
1489
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001490 dout("%s 0x%x bytes at 0x%llx\n",
1491 do_write ? "write" : "read",
Alex Elderbd919d42012-07-13 20:35:11 -05001492 size, (unsigned long long) blk_rq_pos(rq) * SECTOR_SIZE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001493
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001494 num_segs = rbd_get_num_segments(&rbd_dev->header, ofs, size);
1495 coll = rbd_alloc_coll(num_segs);
1496 if (!coll) {
1497 spin_lock_irq(q->queue_lock);
1498 __blk_end_request_all(rq, -ENOMEM);
Josh Durgind1d25642011-12-05 14:03:05 -08001499 ceph_put_snap_context(snapc);
Alex Elder00f1f362012-02-07 12:03:36 -06001500 continue;
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001501 }
1502
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001503 do {
1504 /* a bio clone to be passed down to OSD req */
Alex Elderbd919d42012-07-13 20:35:11 -05001505 dout("rq->bio->bi_vcnt=%hu\n", rq->bio->bi_vcnt);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001506 op_size = rbd_get_segment(&rbd_dev->header,
Alex Elderca1e49a2012-07-10 20:30:09 -05001507 rbd_dev->header.object_prefix,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001508 ofs, size,
1509 NULL, NULL);
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001510 kref_get(&coll->kref);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001511 bio = bio_chain_clone(&rq_bio, &next_bio, &bp,
1512 op_size, GFP_ATOMIC);
1513 if (!bio) {
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001514 rbd_coll_end_req_index(rq, coll, cur_seg,
1515 -ENOMEM, op_size);
1516 goto next_seg;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001517 }
1518
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001519
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001520 /* init OSD command: write or read */
1521 if (do_write)
1522 rbd_req_write(rq, rbd_dev,
Josh Durgind1d25642011-12-05 14:03:05 -08001523 snapc,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001524 ofs,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001525 op_size, bio,
1526 coll, cur_seg);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001527 else
1528 rbd_req_read(rq, rbd_dev,
Josh Durgin77dfe992011-11-21 13:04:42 -08001529 rbd_dev->snap_id,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001530 ofs,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001531 op_size, bio,
1532 coll, cur_seg);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001533
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001534next_seg:
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001535 size -= op_size;
1536 ofs += op_size;
1537
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001538 cur_seg++;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001539 rq_bio = next_bio;
1540 } while (size > 0);
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001541 kref_put(&coll->kref, rbd_coll_release);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001542
1543 if (bp)
1544 bio_pair_release(bp);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001545 spin_lock_irq(q->queue_lock);
Josh Durgind1d25642011-12-05 14:03:05 -08001546
1547 ceph_put_snap_context(snapc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001548 }
1549}
1550
1551/*
1552 * a queue callback. Makes sure that we don't create a bio that spans across
1553 * multiple osd objects. One exception would be with a single page bios,
1554 * which we handle later at bio_chain_clone
1555 */
1556static int rbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bmd,
1557 struct bio_vec *bvec)
1558{
1559 struct rbd_device *rbd_dev = q->queuedata;
Alex Elder593a9e72012-02-07 12:03:37 -06001560 unsigned int chunk_sectors;
1561 sector_t sector;
1562 unsigned int bio_sectors;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001563 int max;
1564
Alex Elder593a9e72012-02-07 12:03:37 -06001565 chunk_sectors = 1 << (rbd_dev->header.obj_order - SECTOR_SHIFT);
1566 sector = bmd->bi_sector + get_start_sect(bmd->bi_bdev);
1567 bio_sectors = bmd->bi_size >> SECTOR_SHIFT;
1568
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001569 max = (chunk_sectors - ((sector & (chunk_sectors - 1))
Alex Elder593a9e72012-02-07 12:03:37 -06001570 + bio_sectors)) << SECTOR_SHIFT;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001571 if (max < 0)
1572 max = 0; /* bio_add cannot handle a negative return */
1573 if (max <= bvec->bv_len && bio_sectors == 0)
1574 return bvec->bv_len;
1575 return max;
1576}
1577
1578static void rbd_free_disk(struct rbd_device *rbd_dev)
1579{
1580 struct gendisk *disk = rbd_dev->disk;
1581
1582 if (!disk)
1583 return;
1584
1585 rbd_header_free(&rbd_dev->header);
1586
1587 if (disk->flags & GENHD_FL_UP)
1588 del_gendisk(disk);
1589 if (disk->queue)
1590 blk_cleanup_queue(disk->queue);
1591 put_disk(disk);
1592}
1593
1594/*
1595 * reload the ondisk the header
1596 */
1597static int rbd_read_header(struct rbd_device *rbd_dev,
1598 struct rbd_image_header *header)
1599{
1600 ssize_t rc;
1601 struct rbd_image_header_ondisk *dh;
Xi Wang50f7c4c2012-04-20 15:49:44 -05001602 u32 snap_count = 0;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001603 u64 ver;
Alex Elder00f1f362012-02-07 12:03:36 -06001604 size_t len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001605
Alex Elder00f1f362012-02-07 12:03:36 -06001606 /*
1607 * First reads the fixed-size header to determine the number
1608 * of snapshots, then re-reads it, along with all snapshot
1609 * records as well as their stored names.
1610 */
1611 len = sizeof (*dh);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001612 while (1) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001613 dh = kmalloc(len, GFP_KERNEL);
1614 if (!dh)
1615 return -ENOMEM;
1616
1617 rc = rbd_req_sync_read(rbd_dev,
Alex Elder9a5d6902012-07-19 09:09:27 -05001618 CEPH_NOSNAP,
Alex Elder0bed54d2012-07-03 16:01:18 -05001619 rbd_dev->header_name,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001620 0, len,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001621 (char *)dh, &ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001622 if (rc < 0)
1623 goto out_dh;
1624
Alex Eldered63f4f2012-07-19 09:09:27 -05001625 rc = rbd_header_from_disk(header, dh, snap_count);
Josh Durgin81e759f2011-11-15 14:49:53 -08001626 if (rc < 0) {
Alex Elder00f1f362012-02-07 12:03:36 -06001627 if (rc == -ENXIO)
Josh Durgin81e759f2011-11-15 14:49:53 -08001628 pr_warning("unrecognized header format"
Alex Elder0bed54d2012-07-03 16:01:18 -05001629 " for image %s\n",
1630 rbd_dev->image_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001631 goto out_dh;
Josh Durgin81e759f2011-11-15 14:49:53 -08001632 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001633
Alex Elder00f1f362012-02-07 12:03:36 -06001634 if (snap_count == header->total_snaps)
1635 break;
1636
1637 snap_count = header->total_snaps;
1638 len = sizeof (*dh) +
1639 snap_count * sizeof(struct rbd_image_snap_ondisk) +
1640 header->snap_names_len;
1641
1642 rbd_header_free(header);
1643 kfree(dh);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001644 }
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001645 header->obj_version = ver;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001646
1647out_dh:
1648 kfree(dh);
1649 return rc;
1650}
1651
1652/*
1653 * create a snapshot
1654 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001655static int rbd_header_add_snap(struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001656 const char *snap_name,
1657 gfp_t gfp_flags)
1658{
1659 int name_len = strlen(snap_name);
1660 u64 new_snapid;
1661 int ret;
Sage Weil916d4d62011-05-12 16:10:50 -07001662 void *data, *p, *e;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001663 u64 ver;
Alex Elder1dbb4392012-01-24 10:08:37 -06001664 struct ceph_mon_client *monc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001665
1666 /* we should create a snapshot only if we're pointing at the head */
Alex Elder0ce1a792012-07-03 16:01:18 -05001667 if (rbd_dev->snap_id != CEPH_NOSNAP)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001668 return -EINVAL;
1669
Alex Elder0ce1a792012-07-03 16:01:18 -05001670 monc = &rbd_dev->rbd_client->client->monc;
1671 ret = ceph_monc_create_snapid(monc, rbd_dev->pool_id, &new_snapid);
Alex Elderbd919d42012-07-13 20:35:11 -05001672 dout("created snapid=%llu\n", (unsigned long long) new_snapid);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001673 if (ret < 0)
1674 return ret;
1675
1676 data = kmalloc(name_len + 16, gfp_flags);
1677 if (!data)
1678 return -ENOMEM;
1679
Sage Weil916d4d62011-05-12 16:10:50 -07001680 p = data;
1681 e = data + name_len + 16;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001682
Sage Weil916d4d62011-05-12 16:10:50 -07001683 ceph_encode_string_safe(&p, e, snap_name, name_len, bad);
1684 ceph_encode_64_safe(&p, e, new_snapid, bad);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001685
Alex Elder0bed54d2012-07-03 16:01:18 -05001686 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
Alex Elder0ce1a792012-07-03 16:01:18 -05001687 "rbd", "snap_add",
Sage Weil916d4d62011-05-12 16:10:50 -07001688 data, p - data, &ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001689
Sage Weil916d4d62011-05-12 16:10:50 -07001690 kfree(data);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001691
Alex Elder505cbb92012-07-19 08:49:18 -05001692 return ret < 0 ? ret : 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001693bad:
1694 return -ERANGE;
1695}
1696
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001697static void __rbd_remove_all_snaps(struct rbd_device *rbd_dev)
1698{
1699 struct rbd_snap *snap;
Alex Eldera0593292012-07-19 09:09:27 -05001700 struct rbd_snap *next;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001701
Alex Eldera0593292012-07-19 09:09:27 -05001702 list_for_each_entry_safe(snap, next, &rbd_dev->snaps, node)
Alex Elder14e70852012-07-19 09:09:27 -05001703 __rbd_remove_snap_dev(snap);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001704}
1705
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001706/*
1707 * only read the first part of the ondisk header, without the snaps info
1708 */
Josh Durgin263c6ca2011-12-05 10:43:42 -08001709static int __rbd_refresh_header(struct rbd_device *rbd_dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001710{
1711 int ret;
1712 struct rbd_image_header h;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001713
1714 ret = rbd_read_header(rbd_dev, &h);
1715 if (ret < 0)
1716 return ret;
1717
Josh Durgina51aa0c2011-12-05 10:35:04 -08001718 down_write(&rbd_dev->header_rwsem);
1719
Sage Weil9db4b3e2011-04-19 22:49:06 -07001720 /* resized? */
Josh Durgin474ef7c2011-11-21 17:13:54 -08001721 if (rbd_dev->snap_id == CEPH_NOSNAP) {
1722 sector_t size = (sector_t) h.image_size / SECTOR_SIZE;
1723
1724 dout("setting size to %llu sectors", (unsigned long long) size);
1725 set_capacity(rbd_dev->disk, size);
1726 }
Sage Weil9db4b3e2011-04-19 22:49:06 -07001727
Alex Elder849b4262012-07-09 21:04:24 -05001728 /* rbd_dev->header.object_prefix shouldn't change */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001729 kfree(rbd_dev->header.snap_sizes);
Alex Elder849b4262012-07-09 21:04:24 -05001730 kfree(rbd_dev->header.snap_names);
Josh Durgind1d25642011-12-05 14:03:05 -08001731 /* osd requests may still refer to snapc */
1732 ceph_put_snap_context(rbd_dev->header.snapc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001733
Josh Durgina71b8912011-12-05 18:10:44 -08001734 rbd_dev->header.obj_version = h.obj_version;
Josh Durgin93a24e02011-12-05 10:41:28 -08001735 rbd_dev->header.image_size = h.image_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001736 rbd_dev->header.total_snaps = h.total_snaps;
1737 rbd_dev->header.snapc = h.snapc;
1738 rbd_dev->header.snap_names = h.snap_names;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001739 rbd_dev->header.snap_names_len = h.snap_names_len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001740 rbd_dev->header.snap_sizes = h.snap_sizes;
Alex Elder849b4262012-07-09 21:04:24 -05001741 /* Free the extra copy of the object prefix */
1742 WARN_ON(strcmp(rbd_dev->header.object_prefix, h.object_prefix));
1743 kfree(h.object_prefix);
1744
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001745 ret = __rbd_init_snaps_header(rbd_dev);
1746
Josh Durginc6666012011-11-21 17:11:12 -08001747 up_write(&rbd_dev->header_rwsem);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001748
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001749 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001750}
1751
1752static int rbd_init_disk(struct rbd_device *rbd_dev)
1753{
1754 struct gendisk *disk;
1755 struct request_queue *q;
1756 int rc;
Alex Elder593a9e72012-02-07 12:03:37 -06001757 u64 segment_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001758 u64 total_size = 0;
1759
1760 /* contact OSD, request size info about the object being mapped */
1761 rc = rbd_read_header(rbd_dev, &rbd_dev->header);
1762 if (rc)
1763 return rc;
1764
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001765 /* no need to lock here, as rbd_dev is not registered yet */
1766 rc = __rbd_init_snaps_header(rbd_dev);
1767 if (rc)
1768 return rc;
1769
Josh Durgincc9d7342011-11-21 18:19:13 -08001770 rc = rbd_header_set_snap(rbd_dev, &total_size);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001771 if (rc)
1772 return rc;
1773
1774 /* create gendisk info */
1775 rc = -ENOMEM;
1776 disk = alloc_disk(RBD_MINORS_PER_MAJOR);
1777 if (!disk)
1778 goto out;
1779
Alex Elderf0f8cef2012-01-29 13:57:44 -06001780 snprintf(disk->disk_name, sizeof(disk->disk_name), RBD_DRV_NAME "%d",
Alex Elderde71a292012-07-03 16:01:19 -05001781 rbd_dev->dev_id);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001782 disk->major = rbd_dev->major;
1783 disk->first_minor = 0;
1784 disk->fops = &rbd_bd_ops;
1785 disk->private_data = rbd_dev;
1786
1787 /* init rq */
1788 rc = -ENOMEM;
1789 q = blk_init_queue(rbd_rq_fn, &rbd_dev->lock);
1790 if (!q)
1791 goto out_disk;
Josh Durgin029bcbd2011-07-22 11:35:23 -07001792
Alex Elder593a9e72012-02-07 12:03:37 -06001793 /* We use the default size, but let's be explicit about it. */
1794 blk_queue_physical_block_size(q, SECTOR_SIZE);
1795
Josh Durgin029bcbd2011-07-22 11:35:23 -07001796 /* set io sizes to object size */
Alex Elder593a9e72012-02-07 12:03:37 -06001797 segment_size = rbd_obj_bytes(&rbd_dev->header);
1798 blk_queue_max_hw_sectors(q, segment_size / SECTOR_SIZE);
1799 blk_queue_max_segment_size(q, segment_size);
1800 blk_queue_io_min(q, segment_size);
1801 blk_queue_io_opt(q, segment_size);
Josh Durgin029bcbd2011-07-22 11:35:23 -07001802
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001803 blk_queue_merge_bvec(q, rbd_merge_bvec);
1804 disk->queue = q;
1805
1806 q->queuedata = rbd_dev;
1807
1808 rbd_dev->disk = disk;
1809 rbd_dev->q = q;
1810
1811 /* finally, announce the disk to the world */
Alex Elder593a9e72012-02-07 12:03:37 -06001812 set_capacity(disk, total_size / SECTOR_SIZE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001813 add_disk(disk);
1814
1815 pr_info("%s: added with size 0x%llx\n",
1816 disk->disk_name, (unsigned long long)total_size);
1817 return 0;
1818
1819out_disk:
1820 put_disk(disk);
1821out:
1822 return rc;
1823}
1824
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001825/*
1826 sysfs
1827*/
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001828
Alex Elder593a9e72012-02-07 12:03:37 -06001829static struct rbd_device *dev_to_rbd_dev(struct device *dev)
1830{
1831 return container_of(dev, struct rbd_device, dev);
1832}
1833
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001834static ssize_t rbd_size_show(struct device *dev,
1835 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001836{
Alex Elder593a9e72012-02-07 12:03:37 -06001837 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Josh Durgina51aa0c2011-12-05 10:35:04 -08001838 sector_t size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001839
Josh Durgina51aa0c2011-12-05 10:35:04 -08001840 down_read(&rbd_dev->header_rwsem);
1841 size = get_capacity(rbd_dev->disk);
1842 up_read(&rbd_dev->header_rwsem);
1843
1844 return sprintf(buf, "%llu\n", (unsigned long long) size * SECTOR_SIZE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001845}
1846
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001847static ssize_t rbd_major_show(struct device *dev,
1848 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001849{
Alex Elder593a9e72012-02-07 12:03:37 -06001850 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001851
1852 return sprintf(buf, "%d\n", rbd_dev->major);
1853}
1854
1855static ssize_t rbd_client_id_show(struct device *dev,
1856 struct device_attribute *attr, char *buf)
1857{
Alex Elder593a9e72012-02-07 12:03:37 -06001858 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001859
Alex Elder1dbb4392012-01-24 10:08:37 -06001860 return sprintf(buf, "client%lld\n",
1861 ceph_client_id(rbd_dev->rbd_client->client));
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001862}
1863
1864static ssize_t rbd_pool_show(struct device *dev,
1865 struct device_attribute *attr, char *buf)
1866{
Alex Elder593a9e72012-02-07 12:03:37 -06001867 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001868
1869 return sprintf(buf, "%s\n", rbd_dev->pool_name);
1870}
1871
Alex Elder9bb2f332012-07-12 10:46:35 -05001872static ssize_t rbd_pool_id_show(struct device *dev,
1873 struct device_attribute *attr, char *buf)
1874{
1875 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
1876
1877 return sprintf(buf, "%d\n", rbd_dev->pool_id);
1878}
1879
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001880static ssize_t rbd_name_show(struct device *dev,
1881 struct device_attribute *attr, char *buf)
1882{
Alex Elder593a9e72012-02-07 12:03:37 -06001883 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001884
Alex Elder0bed54d2012-07-03 16:01:18 -05001885 return sprintf(buf, "%s\n", rbd_dev->image_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001886}
1887
1888static ssize_t rbd_snap_show(struct device *dev,
1889 struct device_attribute *attr,
1890 char *buf)
1891{
Alex Elder593a9e72012-02-07 12:03:37 -06001892 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001893
1894 return sprintf(buf, "%s\n", rbd_dev->snap_name);
1895}
1896
1897static ssize_t rbd_image_refresh(struct device *dev,
1898 struct device_attribute *attr,
1899 const char *buf,
1900 size_t size)
1901{
Alex Elder593a9e72012-02-07 12:03:37 -06001902 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001903 int rc;
1904 int ret = size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001905
1906 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
1907
Josh Durgin263c6ca2011-12-05 10:43:42 -08001908 rc = __rbd_refresh_header(rbd_dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001909 if (rc < 0)
1910 ret = rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001911
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001912 mutex_unlock(&ctl_mutex);
1913 return ret;
1914}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001915
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001916static DEVICE_ATTR(size, S_IRUGO, rbd_size_show, NULL);
1917static DEVICE_ATTR(major, S_IRUGO, rbd_major_show, NULL);
1918static DEVICE_ATTR(client_id, S_IRUGO, rbd_client_id_show, NULL);
1919static DEVICE_ATTR(pool, S_IRUGO, rbd_pool_show, NULL);
Alex Elder9bb2f332012-07-12 10:46:35 -05001920static DEVICE_ATTR(pool_id, S_IRUGO, rbd_pool_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001921static DEVICE_ATTR(name, S_IRUGO, rbd_name_show, NULL);
1922static DEVICE_ATTR(refresh, S_IWUSR, NULL, rbd_image_refresh);
1923static DEVICE_ATTR(current_snap, S_IRUGO, rbd_snap_show, NULL);
1924static DEVICE_ATTR(create_snap, S_IWUSR, NULL, rbd_snap_add);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001925
1926static struct attribute *rbd_attrs[] = {
1927 &dev_attr_size.attr,
1928 &dev_attr_major.attr,
1929 &dev_attr_client_id.attr,
1930 &dev_attr_pool.attr,
Alex Elder9bb2f332012-07-12 10:46:35 -05001931 &dev_attr_pool_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001932 &dev_attr_name.attr,
1933 &dev_attr_current_snap.attr,
1934 &dev_attr_refresh.attr,
1935 &dev_attr_create_snap.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001936 NULL
1937};
1938
1939static struct attribute_group rbd_attr_group = {
1940 .attrs = rbd_attrs,
1941};
1942
1943static const struct attribute_group *rbd_attr_groups[] = {
1944 &rbd_attr_group,
1945 NULL
1946};
1947
1948static void rbd_sysfs_dev_release(struct device *dev)
1949{
1950}
1951
1952static struct device_type rbd_device_type = {
1953 .name = "rbd",
1954 .groups = rbd_attr_groups,
1955 .release = rbd_sysfs_dev_release,
1956};
1957
1958
1959/*
1960 sysfs - snapshots
1961*/
1962
1963static ssize_t rbd_snap_size_show(struct device *dev,
1964 struct device_attribute *attr,
1965 char *buf)
1966{
1967 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
1968
Josh Durgin35915382011-12-05 18:25:13 -08001969 return sprintf(buf, "%llu\n", (unsigned long long)snap->size);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001970}
1971
1972static ssize_t rbd_snap_id_show(struct device *dev,
1973 struct device_attribute *attr,
1974 char *buf)
1975{
1976 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
1977
Josh Durgin35915382011-12-05 18:25:13 -08001978 return sprintf(buf, "%llu\n", (unsigned long long)snap->id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001979}
1980
1981static DEVICE_ATTR(snap_size, S_IRUGO, rbd_snap_size_show, NULL);
1982static DEVICE_ATTR(snap_id, S_IRUGO, rbd_snap_id_show, NULL);
1983
1984static struct attribute *rbd_snap_attrs[] = {
1985 &dev_attr_snap_size.attr,
1986 &dev_attr_snap_id.attr,
1987 NULL,
1988};
1989
1990static struct attribute_group rbd_snap_attr_group = {
1991 .attrs = rbd_snap_attrs,
1992};
1993
1994static void rbd_snap_dev_release(struct device *dev)
1995{
1996 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
1997 kfree(snap->name);
1998 kfree(snap);
1999}
2000
2001static const struct attribute_group *rbd_snap_attr_groups[] = {
2002 &rbd_snap_attr_group,
2003 NULL
2004};
2005
2006static struct device_type rbd_snap_device_type = {
2007 .groups = rbd_snap_attr_groups,
2008 .release = rbd_snap_dev_release,
2009};
2010
Alex Elder14e70852012-07-19 09:09:27 -05002011static void __rbd_remove_snap_dev(struct rbd_snap *snap)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002012{
2013 list_del(&snap->node);
2014 device_unregister(&snap->dev);
2015}
2016
Alex Elder14e70852012-07-19 09:09:27 -05002017static int rbd_register_snap_dev(struct rbd_snap *snap,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002018 struct device *parent)
2019{
2020 struct device *dev = &snap->dev;
2021 int ret;
2022
2023 dev->type = &rbd_snap_device_type;
2024 dev->parent = parent;
2025 dev->release = rbd_snap_dev_release;
2026 dev_set_name(dev, "snap_%s", snap->name);
2027 ret = device_register(dev);
2028
2029 return ret;
2030}
2031
2032static int __rbd_add_snap_dev(struct rbd_device *rbd_dev,
2033 int i, const char *name,
2034 struct rbd_snap **snapp)
2035{
2036 int ret;
2037 struct rbd_snap *snap = kzalloc(sizeof(*snap), GFP_KERNEL);
2038 if (!snap)
2039 return -ENOMEM;
2040 snap->name = kstrdup(name, GFP_KERNEL);
2041 snap->size = rbd_dev->header.snap_sizes[i];
2042 snap->id = rbd_dev->header.snapc->snaps[i];
2043 if (device_is_registered(&rbd_dev->dev)) {
Alex Elder14e70852012-07-19 09:09:27 -05002044 ret = rbd_register_snap_dev(snap, &rbd_dev->dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002045 if (ret < 0)
2046 goto err;
2047 }
2048 *snapp = snap;
2049 return 0;
2050err:
2051 kfree(snap->name);
2052 kfree(snap);
2053 return ret;
2054}
2055
2056/*
2057 * search for the previous snap in a null delimited string list
2058 */
2059const char *rbd_prev_snap_name(const char *name, const char *start)
2060{
2061 if (name < start + 2)
2062 return NULL;
2063
2064 name -= 2;
2065 while (*name) {
2066 if (name == start)
2067 return start;
2068 name--;
2069 }
2070 return name + 1;
2071}
2072
2073/*
2074 * compare the old list of snapshots that we have to what's in the header
2075 * and update it accordingly. Note that the header holds the snapshots
2076 * in a reverse order (from newest to oldest) and we need to go from
2077 * older to new so that we don't get a duplicate snap name when
2078 * doing the process (e.g., removed snapshot and recreated a new
2079 * one with the same name.
2080 */
2081static int __rbd_init_snaps_header(struct rbd_device *rbd_dev)
2082{
2083 const char *name, *first_name;
2084 int i = rbd_dev->header.total_snaps;
2085 struct rbd_snap *snap, *old_snap = NULL;
2086 int ret;
2087 struct list_head *p, *n;
2088
2089 first_name = rbd_dev->header.snap_names;
2090 name = first_name + rbd_dev->header.snap_names_len;
2091
2092 list_for_each_prev_safe(p, n, &rbd_dev->snaps) {
2093 u64 cur_id;
2094
2095 old_snap = list_entry(p, struct rbd_snap, node);
2096
2097 if (i)
2098 cur_id = rbd_dev->header.snapc->snaps[i - 1];
2099
2100 if (!i || old_snap->id < cur_id) {
Josh Durgine88a36e2011-11-21 18:14:25 -08002101 /*
2102 * old_snap->id was skipped, thus was
2103 * removed. If this rbd_dev is mapped to
2104 * the removed snapshot, record that it no
2105 * longer exists, to prevent further I/O.
2106 */
2107 if (rbd_dev->snap_id == old_snap->id)
2108 rbd_dev->snap_exists = false;
Alex Elder14e70852012-07-19 09:09:27 -05002109 __rbd_remove_snap_dev(old_snap);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002110 continue;
2111 }
2112 if (old_snap->id == cur_id) {
2113 /* we have this snapshot already */
2114 i--;
2115 name = rbd_prev_snap_name(name, first_name);
2116 continue;
2117 }
2118 for (; i > 0;
2119 i--, name = rbd_prev_snap_name(name, first_name)) {
2120 if (!name) {
2121 WARN_ON(1);
2122 return -EINVAL;
2123 }
2124 cur_id = rbd_dev->header.snapc->snaps[i];
2125 /* snapshot removal? handle it above */
2126 if (cur_id >= old_snap->id)
2127 break;
2128 /* a new snapshot */
2129 ret = __rbd_add_snap_dev(rbd_dev, i - 1, name, &snap);
2130 if (ret < 0)
2131 return ret;
2132
2133 /* note that we add it backward so using n and not p */
2134 list_add(&snap->node, n);
2135 p = &snap->node;
2136 }
2137 }
2138 /* we're done going over the old snap list, just add what's left */
2139 for (; i > 0; i--) {
2140 name = rbd_prev_snap_name(name, first_name);
2141 if (!name) {
2142 WARN_ON(1);
2143 return -EINVAL;
2144 }
2145 ret = __rbd_add_snap_dev(rbd_dev, i - 1, name, &snap);
2146 if (ret < 0)
2147 return ret;
2148 list_add(&snap->node, &rbd_dev->snaps);
2149 }
2150
2151 return 0;
2152}
2153
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002154static int rbd_bus_add_dev(struct rbd_device *rbd_dev)
2155{
Alex Elderf0f8cef2012-01-29 13:57:44 -06002156 int ret;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002157 struct device *dev;
2158 struct rbd_snap *snap;
2159
2160 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
2161 dev = &rbd_dev->dev;
2162
2163 dev->bus = &rbd_bus_type;
2164 dev->type = &rbd_device_type;
2165 dev->parent = &rbd_root_dev;
2166 dev->release = rbd_dev_release;
Alex Elderde71a292012-07-03 16:01:19 -05002167 dev_set_name(dev, "%d", rbd_dev->dev_id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002168 ret = device_register(dev);
2169 if (ret < 0)
Alex Elderf0f8cef2012-01-29 13:57:44 -06002170 goto out;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002171
2172 list_for_each_entry(snap, &rbd_dev->snaps, node) {
Alex Elder14e70852012-07-19 09:09:27 -05002173 ret = rbd_register_snap_dev(snap, &rbd_dev->dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002174 if (ret < 0)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002175 break;
2176 }
Alex Elderf0f8cef2012-01-29 13:57:44 -06002177out:
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002178 mutex_unlock(&ctl_mutex);
2179 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002180}
2181
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002182static void rbd_bus_del_dev(struct rbd_device *rbd_dev)
2183{
2184 device_unregister(&rbd_dev->dev);
2185}
2186
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002187static int rbd_init_watch_dev(struct rbd_device *rbd_dev)
2188{
2189 int ret, rc;
2190
2191 do {
Alex Elder0e6f3222012-07-25 09:32:40 -05002192 ret = rbd_req_sync_watch(rbd_dev);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002193 if (ret == -ERANGE) {
2194 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Josh Durgin263c6ca2011-12-05 10:43:42 -08002195 rc = __rbd_refresh_header(rbd_dev);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002196 mutex_unlock(&ctl_mutex);
2197 if (rc < 0)
2198 return rc;
2199 }
2200 } while (ret == -ERANGE);
2201
2202 return ret;
2203}
2204
Alex Elder1ddbe942012-01-29 13:57:44 -06002205static atomic64_t rbd_id_max = ATOMIC64_INIT(0);
2206
2207/*
Alex Elder499afd52012-02-02 08:13:29 -06002208 * Get a unique rbd identifier for the given new rbd_dev, and add
2209 * the rbd_dev to the global list. The minimum rbd id is 1.
Alex Elder1ddbe942012-01-29 13:57:44 -06002210 */
Alex Elder499afd52012-02-02 08:13:29 -06002211static void rbd_id_get(struct rbd_device *rbd_dev)
Alex Elderb7f23c32012-01-29 13:57:43 -06002212{
Alex Elderde71a292012-07-03 16:01:19 -05002213 rbd_dev->dev_id = atomic64_inc_return(&rbd_id_max);
Alex Elder499afd52012-02-02 08:13:29 -06002214
2215 spin_lock(&rbd_dev_list_lock);
2216 list_add_tail(&rbd_dev->node, &rbd_dev_list);
2217 spin_unlock(&rbd_dev_list_lock);
Alex Elder1ddbe942012-01-29 13:57:44 -06002218}
Alex Elderb7f23c32012-01-29 13:57:43 -06002219
Alex Elder1ddbe942012-01-29 13:57:44 -06002220/*
Alex Elder499afd52012-02-02 08:13:29 -06002221 * Remove an rbd_dev from the global list, and record that its
2222 * identifier is no longer in use.
Alex Elder1ddbe942012-01-29 13:57:44 -06002223 */
Alex Elder499afd52012-02-02 08:13:29 -06002224static void rbd_id_put(struct rbd_device *rbd_dev)
Alex Elder1ddbe942012-01-29 13:57:44 -06002225{
Alex Elderd184f6b2012-01-29 13:57:44 -06002226 struct list_head *tmp;
Alex Elderde71a292012-07-03 16:01:19 -05002227 int rbd_id = rbd_dev->dev_id;
Alex Elderd184f6b2012-01-29 13:57:44 -06002228 int max_id;
2229
2230 BUG_ON(rbd_id < 1);
Alex Elder499afd52012-02-02 08:13:29 -06002231
2232 spin_lock(&rbd_dev_list_lock);
2233 list_del_init(&rbd_dev->node);
Alex Elderd184f6b2012-01-29 13:57:44 -06002234
2235 /*
2236 * If the id being "put" is not the current maximum, there
2237 * is nothing special we need to do.
2238 */
2239 if (rbd_id != atomic64_read(&rbd_id_max)) {
2240 spin_unlock(&rbd_dev_list_lock);
2241 return;
2242 }
2243
2244 /*
2245 * We need to update the current maximum id. Search the
2246 * list to find out what it is. We're more likely to find
2247 * the maximum at the end, so search the list backward.
2248 */
2249 max_id = 0;
2250 list_for_each_prev(tmp, &rbd_dev_list) {
2251 struct rbd_device *rbd_dev;
2252
2253 rbd_dev = list_entry(tmp, struct rbd_device, node);
2254 if (rbd_id > max_id)
2255 max_id = rbd_id;
2256 }
Alex Elder499afd52012-02-02 08:13:29 -06002257 spin_unlock(&rbd_dev_list_lock);
Alex Elderb7f23c32012-01-29 13:57:43 -06002258
Alex Elder1ddbe942012-01-29 13:57:44 -06002259 /*
Alex Elderd184f6b2012-01-29 13:57:44 -06002260 * The max id could have been updated by rbd_id_get(), in
2261 * which case it now accurately reflects the new maximum.
2262 * Be careful not to overwrite the maximum value in that
2263 * case.
Alex Elder1ddbe942012-01-29 13:57:44 -06002264 */
Alex Elderd184f6b2012-01-29 13:57:44 -06002265 atomic64_cmpxchg(&rbd_id_max, rbd_id, max_id);
Alex Elderb7f23c32012-01-29 13:57:43 -06002266}
2267
Alex Eldera725f65e2012-02-02 08:13:30 -06002268/*
Alex Eldere28fff262012-02-02 08:13:30 -06002269 * Skips over white space at *buf, and updates *buf to point to the
2270 * first found non-space character (if any). Returns the length of
Alex Elder593a9e72012-02-07 12:03:37 -06002271 * the token (string of non-white space characters) found. Note
2272 * that *buf must be terminated with '\0'.
Alex Eldere28fff262012-02-02 08:13:30 -06002273 */
2274static inline size_t next_token(const char **buf)
2275{
2276 /*
2277 * These are the characters that produce nonzero for
2278 * isspace() in the "C" and "POSIX" locales.
2279 */
2280 const char *spaces = " \f\n\r\t\v";
2281
2282 *buf += strspn(*buf, spaces); /* Find start of token */
2283
2284 return strcspn(*buf, spaces); /* Return token length */
2285}
2286
2287/*
2288 * Finds the next token in *buf, and if the provided token buffer is
2289 * big enough, copies the found token into it. The result, if
Alex Elder593a9e72012-02-07 12:03:37 -06002290 * copied, is guaranteed to be terminated with '\0'. Note that *buf
2291 * must be terminated with '\0' on entry.
Alex Eldere28fff262012-02-02 08:13:30 -06002292 *
2293 * Returns the length of the token found (not including the '\0').
2294 * Return value will be 0 if no token is found, and it will be >=
2295 * token_size if the token would not fit.
2296 *
Alex Elder593a9e72012-02-07 12:03:37 -06002297 * The *buf pointer will be updated to point beyond the end of the
Alex Eldere28fff262012-02-02 08:13:30 -06002298 * found token. Note that this occurs even if the token buffer is
2299 * too small to hold it.
2300 */
2301static inline size_t copy_token(const char **buf,
2302 char *token,
2303 size_t token_size)
2304{
2305 size_t len;
2306
2307 len = next_token(buf);
2308 if (len < token_size) {
2309 memcpy(token, *buf, len);
2310 *(token + len) = '\0';
2311 }
2312 *buf += len;
2313
2314 return len;
2315}
2316
2317/*
Alex Elderea3352f2012-07-09 21:04:23 -05002318 * Finds the next token in *buf, dynamically allocates a buffer big
2319 * enough to hold a copy of it, and copies the token into the new
2320 * buffer. The copy is guaranteed to be terminated with '\0'. Note
2321 * that a duplicate buffer is created even for a zero-length token.
2322 *
2323 * Returns a pointer to the newly-allocated duplicate, or a null
2324 * pointer if memory for the duplicate was not available. If
2325 * the lenp argument is a non-null pointer, the length of the token
2326 * (not including the '\0') is returned in *lenp.
2327 *
2328 * If successful, the *buf pointer will be updated to point beyond
2329 * the end of the found token.
2330 *
2331 * Note: uses GFP_KERNEL for allocation.
2332 */
2333static inline char *dup_token(const char **buf, size_t *lenp)
2334{
2335 char *dup;
2336 size_t len;
2337
2338 len = next_token(buf);
2339 dup = kmalloc(len + 1, GFP_KERNEL);
2340 if (!dup)
2341 return NULL;
2342
2343 memcpy(dup, *buf, len);
2344 *(dup + len) = '\0';
2345 *buf += len;
2346
2347 if (lenp)
2348 *lenp = len;
2349
2350 return dup;
2351}
2352
2353/*
Alex Elder0bed54d2012-07-03 16:01:18 -05002354 * This fills in the pool_name, image_name, image_name_len, snap_name,
Alex Eldera725f65e2012-02-02 08:13:30 -06002355 * rbd_dev, rbd_md_name, and name fields of the given rbd_dev, based
2356 * on the list of monitor addresses and other options provided via
2357 * /sys/bus/rbd/add.
Alex Elderd22f76e2012-07-12 10:46:35 -05002358 *
2359 * Note: rbd_dev is assumed to have been initially zero-filled.
Alex Eldera725f65e2012-02-02 08:13:30 -06002360 */
2361static int rbd_add_parse_args(struct rbd_device *rbd_dev,
2362 const char *buf,
Alex Elder7ef32142012-02-02 08:13:30 -06002363 const char **mon_addrs,
Alex Elder5214ecc2012-02-02 08:13:30 -06002364 size_t *mon_addrs_size,
Alex Eldere28fff262012-02-02 08:13:30 -06002365 char *options,
Alex Elder0bed54d2012-07-03 16:01:18 -05002366 size_t options_size)
Alex Eldera725f65e2012-02-02 08:13:30 -06002367{
Alex Elderd22f76e2012-07-12 10:46:35 -05002368 size_t len;
2369 int ret;
Alex Eldere28fff262012-02-02 08:13:30 -06002370
2371 /* The first four tokens are required */
2372
Alex Elder7ef32142012-02-02 08:13:30 -06002373 len = next_token(&buf);
2374 if (!len)
Alex Eldera725f65e2012-02-02 08:13:30 -06002375 return -EINVAL;
Alex Elder5214ecc2012-02-02 08:13:30 -06002376 *mon_addrs_size = len + 1;
Alex Elder7ef32142012-02-02 08:13:30 -06002377 *mon_addrs = buf;
2378
2379 buf += len;
Alex Eldera725f65e2012-02-02 08:13:30 -06002380
Alex Eldere28fff262012-02-02 08:13:30 -06002381 len = copy_token(&buf, options, options_size);
2382 if (!len || len >= options_size)
2383 return -EINVAL;
Alex Eldera725f65e2012-02-02 08:13:30 -06002384
Alex Elderbf3e5ae2012-07-09 21:04:23 -05002385 ret = -ENOMEM;
Alex Elderd22f76e2012-07-12 10:46:35 -05002386 rbd_dev->pool_name = dup_token(&buf, NULL);
2387 if (!rbd_dev->pool_name)
Alex Elderd22f76e2012-07-12 10:46:35 -05002388 goto out_err;
Alex Eldere28fff262012-02-02 08:13:30 -06002389
Alex Elder0bed54d2012-07-03 16:01:18 -05002390 rbd_dev->image_name = dup_token(&buf, &rbd_dev->image_name_len);
2391 if (!rbd_dev->image_name)
Alex Elderbf3e5ae2012-07-09 21:04:23 -05002392 goto out_err;
Alex Eldere28fff262012-02-02 08:13:30 -06002393
Alex Eldercb8627c2012-07-09 21:04:23 -05002394 /* Create the name of the header object */
2395
Alex Elder0bed54d2012-07-03 16:01:18 -05002396 rbd_dev->header_name = kmalloc(rbd_dev->image_name_len
Alex Elderbf3e5ae2012-07-09 21:04:23 -05002397 + sizeof (RBD_SUFFIX),
2398 GFP_KERNEL);
Alex Elder0bed54d2012-07-03 16:01:18 -05002399 if (!rbd_dev->header_name)
Alex Eldercb8627c2012-07-09 21:04:23 -05002400 goto out_err;
Alex Elder0bed54d2012-07-03 16:01:18 -05002401 sprintf(rbd_dev->header_name, "%s%s", rbd_dev->image_name, RBD_SUFFIX);
Alex Eldera725f65e2012-02-02 08:13:30 -06002402
Alex Eldere28fff262012-02-02 08:13:30 -06002403 /*
Alex Elder820a5f32012-07-09 21:04:24 -05002404 * The snapshot name is optional. If none is is supplied,
2405 * we use the default value.
Alex Eldere28fff262012-02-02 08:13:30 -06002406 */
Alex Elder820a5f32012-07-09 21:04:24 -05002407 rbd_dev->snap_name = dup_token(&buf, &len);
2408 if (!rbd_dev->snap_name)
2409 goto out_err;
2410 if (!len) {
2411 /* Replace the empty name with the default */
2412 kfree(rbd_dev->snap_name);
2413 rbd_dev->snap_name
2414 = kmalloc(sizeof (RBD_SNAP_HEAD_NAME), GFP_KERNEL);
2415 if (!rbd_dev->snap_name)
2416 goto out_err;
2417
Alex Eldere28fff262012-02-02 08:13:30 -06002418 memcpy(rbd_dev->snap_name, RBD_SNAP_HEAD_NAME,
2419 sizeof (RBD_SNAP_HEAD_NAME));
Alex Elder849b4262012-07-09 21:04:24 -05002420 }
Alex Eldere28fff262012-02-02 08:13:30 -06002421
Alex Eldera725f65e2012-02-02 08:13:30 -06002422 return 0;
Alex Elderd22f76e2012-07-12 10:46:35 -05002423
2424out_err:
Alex Elder0bed54d2012-07-03 16:01:18 -05002425 kfree(rbd_dev->header_name);
2426 kfree(rbd_dev->image_name);
Alex Elderd22f76e2012-07-12 10:46:35 -05002427 kfree(rbd_dev->pool_name);
2428 rbd_dev->pool_name = NULL;
2429
2430 return ret;
Alex Eldera725f65e2012-02-02 08:13:30 -06002431}
2432
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002433static ssize_t rbd_add(struct bus_type *bus,
2434 const char *buf,
2435 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002436{
Alex Eldercb8627c2012-07-09 21:04:23 -05002437 char *options;
2438 struct rbd_device *rbd_dev = NULL;
Alex Elder7ef32142012-02-02 08:13:30 -06002439 const char *mon_addrs = NULL;
2440 size_t mon_addrs_size = 0;
Alex Elder27cc2592012-02-02 08:13:30 -06002441 struct ceph_osd_client *osdc;
2442 int rc = -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002443
2444 if (!try_module_get(THIS_MODULE))
2445 return -ENODEV;
2446
Alex Elder27cc2592012-02-02 08:13:30 -06002447 options = kmalloc(count, GFP_KERNEL);
2448 if (!options)
2449 goto err_nomem;
Alex Eldercb8627c2012-07-09 21:04:23 -05002450 rbd_dev = kzalloc(sizeof(*rbd_dev), GFP_KERNEL);
2451 if (!rbd_dev)
2452 goto err_nomem;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002453
2454 /* static rbd_device initialization */
2455 spin_lock_init(&rbd_dev->lock);
2456 INIT_LIST_HEAD(&rbd_dev->node);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002457 INIT_LIST_HEAD(&rbd_dev->snaps);
Josh Durginc6666012011-11-21 17:11:12 -08002458 init_rwsem(&rbd_dev->header_rwsem);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002459
Alex Elderd184f6b2012-01-29 13:57:44 -06002460 /* generate unique id: find highest unique id, add one */
Alex Elder499afd52012-02-02 08:13:29 -06002461 rbd_id_get(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002462
Alex Eldera725f65e2012-02-02 08:13:30 -06002463 /* Fill in the device name, now that we have its id. */
Alex Elder81a89792012-02-02 08:13:30 -06002464 BUILD_BUG_ON(DEV_NAME_LEN
2465 < sizeof (RBD_DRV_NAME) + MAX_INT_FORMAT_WIDTH);
Alex Elderde71a292012-07-03 16:01:19 -05002466 sprintf(rbd_dev->name, "%s%d", RBD_DRV_NAME, rbd_dev->dev_id);
Alex Eldere124a82f2012-01-29 13:57:44 -06002467
Alex Eldera725f65e2012-02-02 08:13:30 -06002468 /* parse add command */
Alex Elder7ef32142012-02-02 08:13:30 -06002469 rc = rbd_add_parse_args(rbd_dev, buf, &mon_addrs, &mon_addrs_size,
Alex Eldere28fff262012-02-02 08:13:30 -06002470 options, count);
Alex Eldera725f65e2012-02-02 08:13:30 -06002471 if (rc)
2472 goto err_put_id;
2473
Alex Elder5214ecc2012-02-02 08:13:30 -06002474 rbd_dev->rbd_client = rbd_get_client(mon_addrs, mon_addrs_size - 1,
2475 options);
Alex Elderd720bcb2012-02-02 08:13:30 -06002476 if (IS_ERR(rbd_dev->rbd_client)) {
2477 rc = PTR_ERR(rbd_dev->rbd_client);
Alex Elderf0f8cef2012-01-29 13:57:44 -06002478 goto err_put_id;
Alex Elderd720bcb2012-02-02 08:13:30 -06002479 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002480
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002481 /* pick the pool */
Alex Elder1dbb4392012-01-24 10:08:37 -06002482 osdc = &rbd_dev->rbd_client->client->osdc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002483 rc = ceph_pg_poolid_by_name(osdc->osdmap, rbd_dev->pool_name);
2484 if (rc < 0)
2485 goto err_out_client;
Alex Elder9bb2f332012-07-12 10:46:35 -05002486 rbd_dev->pool_id = rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002487
2488 /* register our block device */
Alex Elder27cc2592012-02-02 08:13:30 -06002489 rc = register_blkdev(0, rbd_dev->name);
2490 if (rc < 0)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002491 goto err_out_client;
Alex Elder27cc2592012-02-02 08:13:30 -06002492 rbd_dev->major = rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002493
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002494 rc = rbd_bus_add_dev(rbd_dev);
2495 if (rc)
Yehuda Sadeh766fc432011-01-07 14:58:42 -08002496 goto err_out_blkdev;
2497
Alex Elder32eec682012-02-08 16:11:14 -06002498 /*
2499 * At this point cleanup in the event of an error is the job
2500 * of the sysfs code (initiated by rbd_bus_del_dev()).
2501 *
2502 * Set up and announce blkdev mapping.
2503 */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002504 rc = rbd_init_disk(rbd_dev);
2505 if (rc)
Yehuda Sadeh766fc432011-01-07 14:58:42 -08002506 goto err_out_bus;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002507
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002508 rc = rbd_init_watch_dev(rbd_dev);
2509 if (rc)
2510 goto err_out_bus;
2511
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002512 return count;
2513
Yehuda Sadeh766fc432011-01-07 14:58:42 -08002514err_out_bus:
Yehuda Sadeh766fc432011-01-07 14:58:42 -08002515 /* this will also clean up rest of rbd_dev stuff */
2516
2517 rbd_bus_del_dev(rbd_dev);
2518 kfree(options);
Yehuda Sadeh766fc432011-01-07 14:58:42 -08002519 return rc;
2520
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002521err_out_blkdev:
2522 unregister_blkdev(rbd_dev->major, rbd_dev->name);
2523err_out_client:
2524 rbd_put_client(rbd_dev);
Alex Elderf0f8cef2012-01-29 13:57:44 -06002525err_put_id:
Alex Eldercb8627c2012-07-09 21:04:23 -05002526 if (rbd_dev->pool_name) {
Alex Elder820a5f32012-07-09 21:04:24 -05002527 kfree(rbd_dev->snap_name);
Alex Elder0bed54d2012-07-03 16:01:18 -05002528 kfree(rbd_dev->header_name);
2529 kfree(rbd_dev->image_name);
Alex Eldercb8627c2012-07-09 21:04:23 -05002530 kfree(rbd_dev->pool_name);
2531 }
Alex Elder499afd52012-02-02 08:13:29 -06002532 rbd_id_put(rbd_dev);
Alex Elder27cc2592012-02-02 08:13:30 -06002533err_nomem:
Alex Elder27cc2592012-02-02 08:13:30 -06002534 kfree(rbd_dev);
Alex Eldercb8627c2012-07-09 21:04:23 -05002535 kfree(options);
Alex Elder27cc2592012-02-02 08:13:30 -06002536
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002537 dout("Error adding device %s\n", buf);
2538 module_put(THIS_MODULE);
Alex Elder27cc2592012-02-02 08:13:30 -06002539
2540 return (ssize_t) rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002541}
2542
Alex Elderde71a292012-07-03 16:01:19 -05002543static struct rbd_device *__rbd_get_dev(unsigned long dev_id)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002544{
2545 struct list_head *tmp;
2546 struct rbd_device *rbd_dev;
2547
Alex Eldere124a82f2012-01-29 13:57:44 -06002548 spin_lock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002549 list_for_each(tmp, &rbd_dev_list) {
2550 rbd_dev = list_entry(tmp, struct rbd_device, node);
Alex Elderde71a292012-07-03 16:01:19 -05002551 if (rbd_dev->dev_id == dev_id) {
Alex Eldere124a82f2012-01-29 13:57:44 -06002552 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002553 return rbd_dev;
Alex Eldere124a82f2012-01-29 13:57:44 -06002554 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002555 }
Alex Eldere124a82f2012-01-29 13:57:44 -06002556 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002557 return NULL;
2558}
2559
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002560static void rbd_dev_release(struct device *dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002561{
Alex Elder593a9e72012-02-07 12:03:37 -06002562 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002563
Alex Elder1dbb4392012-01-24 10:08:37 -06002564 if (rbd_dev->watch_request) {
2565 struct ceph_client *client = rbd_dev->rbd_client->client;
2566
2567 ceph_osdc_unregister_linger_request(&client->osdc,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002568 rbd_dev->watch_request);
Alex Elder1dbb4392012-01-24 10:08:37 -06002569 }
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002570 if (rbd_dev->watch_event)
Alex Elder0bed54d2012-07-03 16:01:18 -05002571 rbd_req_sync_unwatch(rbd_dev, rbd_dev->header_name);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002572
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002573 rbd_put_client(rbd_dev);
2574
2575 /* clean up and free blkdev */
2576 rbd_free_disk(rbd_dev);
2577 unregister_blkdev(rbd_dev->major, rbd_dev->name);
Alex Elder32eec682012-02-08 16:11:14 -06002578
2579 /* done with the id, and with the rbd_dev */
Alex Elder820a5f32012-07-09 21:04:24 -05002580 kfree(rbd_dev->snap_name);
Alex Elder0bed54d2012-07-03 16:01:18 -05002581 kfree(rbd_dev->header_name);
Alex Elderd22f76e2012-07-12 10:46:35 -05002582 kfree(rbd_dev->pool_name);
Alex Elder0bed54d2012-07-03 16:01:18 -05002583 kfree(rbd_dev->image_name);
Alex Elder32eec682012-02-08 16:11:14 -06002584 rbd_id_put(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002585 kfree(rbd_dev);
2586
2587 /* release module ref */
2588 module_put(THIS_MODULE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002589}
2590
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002591static ssize_t rbd_remove(struct bus_type *bus,
2592 const char *buf,
2593 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002594{
2595 struct rbd_device *rbd_dev = NULL;
2596 int target_id, rc;
2597 unsigned long ul;
2598 int ret = count;
2599
2600 rc = strict_strtoul(buf, 10, &ul);
2601 if (rc)
2602 return rc;
2603
2604 /* convert to int; abort if we lost anything in the conversion */
2605 target_id = (int) ul;
2606 if (target_id != ul)
2607 return -EINVAL;
2608
2609 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
2610
2611 rbd_dev = __rbd_get_dev(target_id);
2612 if (!rbd_dev) {
2613 ret = -ENOENT;
2614 goto done;
2615 }
2616
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002617 __rbd_remove_all_snaps(rbd_dev);
2618 rbd_bus_del_dev(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002619
2620done:
2621 mutex_unlock(&ctl_mutex);
2622 return ret;
2623}
2624
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002625static ssize_t rbd_snap_add(struct device *dev,
2626 struct device_attribute *attr,
2627 const char *buf,
2628 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002629{
Alex Elder593a9e72012-02-07 12:03:37 -06002630 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002631 int ret;
2632 char *name = kmalloc(count + 1, GFP_KERNEL);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002633 if (!name)
2634 return -ENOMEM;
2635
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002636 snprintf(name, count, "%s", buf);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002637
2638 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
2639
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002640 ret = rbd_header_add_snap(rbd_dev,
2641 name, GFP_KERNEL);
2642 if (ret < 0)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002643 goto err_unlock;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002644
Josh Durgin263c6ca2011-12-05 10:43:42 -08002645 ret = __rbd_refresh_header(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002646 if (ret < 0)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002647 goto err_unlock;
2648
2649 /* shouldn't hold ctl_mutex when notifying.. notify might
2650 trigger a watch callback that would need to get that mutex */
2651 mutex_unlock(&ctl_mutex);
2652
2653 /* make a best effort, don't error if failed */
Alex Elder0bed54d2012-07-03 16:01:18 -05002654 rbd_req_sync_notify(rbd_dev, rbd_dev->header_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002655
2656 ret = count;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002657 kfree(name);
2658 return ret;
2659
2660err_unlock:
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002661 mutex_unlock(&ctl_mutex);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002662 kfree(name);
2663 return ret;
2664}
2665
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002666/*
2667 * create control files in sysfs
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002668 * /sys/bus/rbd/...
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002669 */
2670static int rbd_sysfs_init(void)
2671{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002672 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002673
Alex Elderfed4c142012-02-07 12:03:36 -06002674 ret = device_register(&rbd_root_dev);
Alex Elder21079782012-01-24 10:08:36 -06002675 if (ret < 0)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002676 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002677
Alex Elderfed4c142012-02-07 12:03:36 -06002678 ret = bus_register(&rbd_bus_type);
2679 if (ret < 0)
2680 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002681
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002682 return ret;
2683}
2684
2685static void rbd_sysfs_cleanup(void)
2686{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002687 bus_unregister(&rbd_bus_type);
Alex Elderfed4c142012-02-07 12:03:36 -06002688 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002689}
2690
2691int __init rbd_init(void)
2692{
2693 int rc;
2694
2695 rc = rbd_sysfs_init();
2696 if (rc)
2697 return rc;
Alex Elderf0f8cef2012-01-29 13:57:44 -06002698 pr_info("loaded " RBD_DRV_NAME_LONG "\n");
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002699 return 0;
2700}
2701
2702void __exit rbd_exit(void)
2703{
2704 rbd_sysfs_cleanup();
2705}
2706
2707module_init(rbd_init);
2708module_exit(rbd_exit);
2709
2710MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
2711MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
2712MODULE_DESCRIPTION("rados block device");
2713
2714/* following authorship retained from original osdblk.c */
2715MODULE_AUTHOR("Jeff Garzik <jeff@garzik.org>");
2716
2717MODULE_LICENSE("GPL");