blob: 9e960c3ce1c4601f50a593474da109cb4e8e7149 [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 Elder0ce1a792012-07-03 16:01:18 -05001241static int rbd_req_sync_watch(struct rbd_device *rbd_dev,
Alex Elderaded07e2012-07-03 16:01:18 -05001242 const char *object_name,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001243 u64 ver)
1244{
1245 struct ceph_osd_req_op *ops;
Alex Elder0ce1a792012-07-03 16:01:18 -05001246 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001247
1248 int ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_WATCH, 0);
1249 if (ret < 0)
1250 return ret;
1251
1252 ret = ceph_osdc_create_event(osdc, rbd_watch_cb, 0,
Alex Elder0ce1a792012-07-03 16:01:18 -05001253 (void *)rbd_dev, &rbd_dev->watch_event);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001254 if (ret < 0)
1255 goto fail;
1256
1257 ops[0].watch.ver = cpu_to_le64(ver);
Alex Elder0ce1a792012-07-03 16:01:18 -05001258 ops[0].watch.cookie = cpu_to_le64(rbd_dev->watch_event->cookie);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001259 ops[0].watch.flag = 1;
1260
Alex Elder0ce1a792012-07-03 16:01:18 -05001261 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001262 CEPH_NOSNAP,
1263 0,
1264 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1265 ops,
Alex Elderd1f57ea2012-06-26 12:57:03 -07001266 object_name, 0, 0, NULL,
Alex Elder0ce1a792012-07-03 16:01:18 -05001267 &rbd_dev->watch_request, NULL);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001268
1269 if (ret < 0)
1270 goto fail_event;
1271
1272 rbd_destroy_ops(ops);
1273 return 0;
1274
1275fail_event:
Alex Elder0ce1a792012-07-03 16:01:18 -05001276 ceph_osdc_cancel_event(rbd_dev->watch_event);
1277 rbd_dev->watch_event = NULL;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001278fail:
1279 rbd_destroy_ops(ops);
1280 return ret;
1281}
1282
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001283/*
1284 * Request sync osd unwatch
1285 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001286static int rbd_req_sync_unwatch(struct rbd_device *rbd_dev,
Alex Elderaded07e2012-07-03 16:01:18 -05001287 const char *object_name)
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001288{
1289 struct ceph_osd_req_op *ops;
1290
1291 int ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_WATCH, 0);
1292 if (ret < 0)
1293 return ret;
1294
1295 ops[0].watch.ver = 0;
Alex Elder0ce1a792012-07-03 16:01:18 -05001296 ops[0].watch.cookie = cpu_to_le64(rbd_dev->watch_event->cookie);
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001297 ops[0].watch.flag = 0;
1298
Alex Elder0ce1a792012-07-03 16:01:18 -05001299 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001300 CEPH_NOSNAP,
1301 0,
1302 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1303 ops,
Alex Elderd1f57ea2012-06-26 12:57:03 -07001304 object_name, 0, 0, NULL, NULL, NULL);
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001305
1306 rbd_destroy_ops(ops);
Alex Elder0ce1a792012-07-03 16:01:18 -05001307 ceph_osdc_cancel_event(rbd_dev->watch_event);
1308 rbd_dev->watch_event = NULL;
Yehuda Sadeh79e3057c2011-07-12 16:56:57 -07001309 return ret;
1310}
1311
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001312struct rbd_notify_info {
Alex Elder0ce1a792012-07-03 16:01:18 -05001313 struct rbd_device *rbd_dev;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001314};
1315
1316static void rbd_notify_cb(u64 ver, u64 notify_id, u8 opcode, void *data)
1317{
Alex Elder0ce1a792012-07-03 16:01:18 -05001318 struct rbd_device *rbd_dev = (struct rbd_device *)data;
1319 if (!rbd_dev)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001320 return;
1321
Alex Elderbd919d42012-07-13 20:35:11 -05001322 dout("rbd_notify_cb %s notify_id=%llu opcode=%u\n",
1323 rbd_dev->header_name, (unsigned long long) notify_id,
1324 (unsigned int) opcode);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001325}
1326
1327/*
1328 * Request sync osd notify
1329 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001330static int rbd_req_sync_notify(struct rbd_device *rbd_dev,
Alex Elderaded07e2012-07-03 16:01:18 -05001331 const char *object_name)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001332{
1333 struct ceph_osd_req_op *ops;
Alex Elder0ce1a792012-07-03 16:01:18 -05001334 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001335 struct ceph_osd_event *event;
1336 struct rbd_notify_info info;
1337 int payload_len = sizeof(u32) + sizeof(u32);
1338 int ret;
1339
1340 ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_NOTIFY, payload_len);
1341 if (ret < 0)
1342 return ret;
1343
Alex Elder0ce1a792012-07-03 16:01:18 -05001344 info.rbd_dev = rbd_dev;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001345
1346 ret = ceph_osdc_create_event(osdc, rbd_notify_cb, 1,
1347 (void *)&info, &event);
1348 if (ret < 0)
1349 goto fail;
1350
1351 ops[0].watch.ver = 1;
1352 ops[0].watch.flag = 1;
1353 ops[0].watch.cookie = event->cookie;
1354 ops[0].watch.prot_ver = RADOS_NOTIFY_VER;
1355 ops[0].watch.timeout = 12;
1356
Alex Elder0ce1a792012-07-03 16:01:18 -05001357 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001358 CEPH_NOSNAP,
1359 0,
1360 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1361 ops,
Alex Elderd1f57ea2012-06-26 12:57:03 -07001362 object_name, 0, 0, NULL, NULL, NULL);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001363 if (ret < 0)
1364 goto fail_event;
1365
1366 ret = ceph_osdc_wait_event(event, CEPH_OSD_TIMEOUT_DEFAULT);
1367 dout("ceph_osdc_wait_event returned %d\n", ret);
1368 rbd_destroy_ops(ops);
1369 return 0;
1370
1371fail_event:
1372 ceph_osdc_cancel_event(event);
1373fail:
1374 rbd_destroy_ops(ops);
1375 return ret;
1376}
1377
1378/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001379 * Request sync osd read
1380 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001381static int rbd_req_sync_exec(struct rbd_device *rbd_dev,
Alex Elderaded07e2012-07-03 16:01:18 -05001382 const char *object_name,
1383 const char *class_name,
1384 const char *method_name,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001385 const char *data,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001386 int len,
1387 u64 *ver)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001388{
1389 struct ceph_osd_req_op *ops;
Alex Elderaded07e2012-07-03 16:01:18 -05001390 int class_name_len = strlen(class_name);
1391 int method_name_len = strlen(method_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001392 int ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_CALL,
Alex Elderaded07e2012-07-03 16:01:18 -05001393 class_name_len + method_name_len + len);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001394 if (ret < 0)
1395 return ret;
1396
Alex Elderaded07e2012-07-03 16:01:18 -05001397 ops[0].cls.class_name = class_name;
1398 ops[0].cls.class_len = (__u8) class_name_len;
1399 ops[0].cls.method_name = method_name;
1400 ops[0].cls.method_len = (__u8) method_name_len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001401 ops[0].cls.argc = 0;
1402 ops[0].cls.indata = data;
1403 ops[0].cls.indata_len = len;
1404
Alex Elder0ce1a792012-07-03 16:01:18 -05001405 ret = rbd_req_sync_op(rbd_dev, NULL,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001406 CEPH_NOSNAP,
1407 0,
1408 CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
1409 ops,
Alex Elderd1f57ea2012-06-26 12:57:03 -07001410 object_name, 0, 0, NULL, NULL, ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001411
1412 rbd_destroy_ops(ops);
1413
1414 dout("cls_exec returned %d\n", ret);
1415 return ret;
1416}
1417
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001418static struct rbd_req_coll *rbd_alloc_coll(int num_reqs)
1419{
1420 struct rbd_req_coll *coll =
1421 kzalloc(sizeof(struct rbd_req_coll) +
1422 sizeof(struct rbd_req_status) * num_reqs,
1423 GFP_ATOMIC);
1424
1425 if (!coll)
1426 return NULL;
1427 coll->total = num_reqs;
1428 kref_init(&coll->kref);
1429 return coll;
1430}
1431
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001432/*
1433 * block device queue callback
1434 */
1435static void rbd_rq_fn(struct request_queue *q)
1436{
1437 struct rbd_device *rbd_dev = q->queuedata;
1438 struct request *rq;
1439 struct bio_pair *bp = NULL;
1440
Alex Elder00f1f362012-02-07 12:03:36 -06001441 while ((rq = blk_fetch_request(q))) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001442 struct bio *bio;
1443 struct bio *rq_bio, *next_bio = NULL;
1444 bool do_write;
Alex Elderbd919d42012-07-13 20:35:11 -05001445 unsigned int size;
1446 u64 op_size = 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001447 u64 ofs;
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001448 int num_segs, cur_seg = 0;
1449 struct rbd_req_coll *coll;
Josh Durgind1d25642011-12-05 14:03:05 -08001450 struct ceph_snap_context *snapc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001451
1452 /* peek at request from block layer */
1453 if (!rq)
1454 break;
1455
1456 dout("fetched request\n");
1457
1458 /* filter out block requests we don't understand */
1459 if ((rq->cmd_type != REQ_TYPE_FS)) {
1460 __blk_end_request_all(rq, 0);
Alex Elder00f1f362012-02-07 12:03:36 -06001461 continue;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001462 }
1463
1464 /* deduce our operation (read, write) */
1465 do_write = (rq_data_dir(rq) == WRITE);
1466
1467 size = blk_rq_bytes(rq);
Alex Elder593a9e72012-02-07 12:03:37 -06001468 ofs = blk_rq_pos(rq) * SECTOR_SIZE;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001469 rq_bio = rq->bio;
1470 if (do_write && rbd_dev->read_only) {
1471 __blk_end_request_all(rq, -EROFS);
Alex Elder00f1f362012-02-07 12:03:36 -06001472 continue;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001473 }
1474
1475 spin_unlock_irq(q->queue_lock);
1476
Josh Durgind1d25642011-12-05 14:03:05 -08001477 down_read(&rbd_dev->header_rwsem);
Josh Durgine88a36e2011-11-21 18:14:25 -08001478
Josh Durgind1d25642011-12-05 14:03:05 -08001479 if (rbd_dev->snap_id != CEPH_NOSNAP && !rbd_dev->snap_exists) {
Josh Durgine88a36e2011-11-21 18:14:25 -08001480 up_read(&rbd_dev->header_rwsem);
Josh Durgind1d25642011-12-05 14:03:05 -08001481 dout("request for non-existent snapshot");
1482 spin_lock_irq(q->queue_lock);
1483 __blk_end_request_all(rq, -ENXIO);
1484 continue;
Josh Durgine88a36e2011-11-21 18:14:25 -08001485 }
1486
Josh Durgind1d25642011-12-05 14:03:05 -08001487 snapc = ceph_get_snap_context(rbd_dev->header.snapc);
1488
1489 up_read(&rbd_dev->header_rwsem);
1490
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001491 dout("%s 0x%x bytes at 0x%llx\n",
1492 do_write ? "write" : "read",
Alex Elderbd919d42012-07-13 20:35:11 -05001493 size, (unsigned long long) blk_rq_pos(rq) * SECTOR_SIZE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001494
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001495 num_segs = rbd_get_num_segments(&rbd_dev->header, ofs, size);
1496 coll = rbd_alloc_coll(num_segs);
1497 if (!coll) {
1498 spin_lock_irq(q->queue_lock);
1499 __blk_end_request_all(rq, -ENOMEM);
Josh Durgind1d25642011-12-05 14:03:05 -08001500 ceph_put_snap_context(snapc);
Alex Elder00f1f362012-02-07 12:03:36 -06001501 continue;
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001502 }
1503
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001504 do {
1505 /* a bio clone to be passed down to OSD req */
Alex Elderbd919d42012-07-13 20:35:11 -05001506 dout("rq->bio->bi_vcnt=%hu\n", rq->bio->bi_vcnt);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001507 op_size = rbd_get_segment(&rbd_dev->header,
Alex Elderca1e49a2012-07-10 20:30:09 -05001508 rbd_dev->header.object_prefix,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001509 ofs, size,
1510 NULL, NULL);
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001511 kref_get(&coll->kref);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001512 bio = bio_chain_clone(&rq_bio, &next_bio, &bp,
1513 op_size, GFP_ATOMIC);
1514 if (!bio) {
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001515 rbd_coll_end_req_index(rq, coll, cur_seg,
1516 -ENOMEM, op_size);
1517 goto next_seg;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001518 }
1519
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001520
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001521 /* init OSD command: write or read */
1522 if (do_write)
1523 rbd_req_write(rq, rbd_dev,
Josh Durgind1d25642011-12-05 14:03:05 -08001524 snapc,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001525 ofs,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001526 op_size, bio,
1527 coll, cur_seg);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001528 else
1529 rbd_req_read(rq, rbd_dev,
Josh Durgin77dfe992011-11-21 13:04:42 -08001530 rbd_dev->snap_id,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001531 ofs,
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001532 op_size, bio,
1533 coll, cur_seg);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001534
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001535next_seg:
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001536 size -= op_size;
1537 ofs += op_size;
1538
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001539 cur_seg++;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001540 rq_bio = next_bio;
1541 } while (size > 0);
Yehuda Sadeh1fec7092011-05-13 13:52:56 -07001542 kref_put(&coll->kref, rbd_coll_release);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001543
1544 if (bp)
1545 bio_pair_release(bp);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001546 spin_lock_irq(q->queue_lock);
Josh Durgind1d25642011-12-05 14:03:05 -08001547
1548 ceph_put_snap_context(snapc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001549 }
1550}
1551
1552/*
1553 * a queue callback. Makes sure that we don't create a bio that spans across
1554 * multiple osd objects. One exception would be with a single page bios,
1555 * which we handle later at bio_chain_clone
1556 */
1557static int rbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bmd,
1558 struct bio_vec *bvec)
1559{
1560 struct rbd_device *rbd_dev = q->queuedata;
Alex Elder593a9e72012-02-07 12:03:37 -06001561 unsigned int chunk_sectors;
1562 sector_t sector;
1563 unsigned int bio_sectors;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001564 int max;
1565
Alex Elder593a9e72012-02-07 12:03:37 -06001566 chunk_sectors = 1 << (rbd_dev->header.obj_order - SECTOR_SHIFT);
1567 sector = bmd->bi_sector + get_start_sect(bmd->bi_bdev);
1568 bio_sectors = bmd->bi_size >> SECTOR_SHIFT;
1569
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001570 max = (chunk_sectors - ((sector & (chunk_sectors - 1))
Alex Elder593a9e72012-02-07 12:03:37 -06001571 + bio_sectors)) << SECTOR_SHIFT;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001572 if (max < 0)
1573 max = 0; /* bio_add cannot handle a negative return */
1574 if (max <= bvec->bv_len && bio_sectors == 0)
1575 return bvec->bv_len;
1576 return max;
1577}
1578
1579static void rbd_free_disk(struct rbd_device *rbd_dev)
1580{
1581 struct gendisk *disk = rbd_dev->disk;
1582
1583 if (!disk)
1584 return;
1585
1586 rbd_header_free(&rbd_dev->header);
1587
1588 if (disk->flags & GENHD_FL_UP)
1589 del_gendisk(disk);
1590 if (disk->queue)
1591 blk_cleanup_queue(disk->queue);
1592 put_disk(disk);
1593}
1594
1595/*
1596 * reload the ondisk the header
1597 */
1598static int rbd_read_header(struct rbd_device *rbd_dev,
1599 struct rbd_image_header *header)
1600{
1601 ssize_t rc;
1602 struct rbd_image_header_ondisk *dh;
Xi Wang50f7c4c2012-04-20 15:49:44 -05001603 u32 snap_count = 0;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001604 u64 ver;
Alex Elder00f1f362012-02-07 12:03:36 -06001605 size_t len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001606
Alex Elder00f1f362012-02-07 12:03:36 -06001607 /*
1608 * First reads the fixed-size header to determine the number
1609 * of snapshots, then re-reads it, along with all snapshot
1610 * records as well as their stored names.
1611 */
1612 len = sizeof (*dh);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001613 while (1) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001614 dh = kmalloc(len, GFP_KERNEL);
1615 if (!dh)
1616 return -ENOMEM;
1617
1618 rc = rbd_req_sync_read(rbd_dev,
Alex Elder9a5d6902012-07-19 09:09:27 -05001619 CEPH_NOSNAP,
Alex Elder0bed54d2012-07-03 16:01:18 -05001620 rbd_dev->header_name,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001621 0, len,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001622 (char *)dh, &ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001623 if (rc < 0)
1624 goto out_dh;
1625
Alex Eldered63f4f2012-07-19 09:09:27 -05001626 rc = rbd_header_from_disk(header, dh, snap_count);
Josh Durgin81e759f2011-11-15 14:49:53 -08001627 if (rc < 0) {
Alex Elder00f1f362012-02-07 12:03:36 -06001628 if (rc == -ENXIO)
Josh Durgin81e759f2011-11-15 14:49:53 -08001629 pr_warning("unrecognized header format"
Alex Elder0bed54d2012-07-03 16:01:18 -05001630 " for image %s\n",
1631 rbd_dev->image_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001632 goto out_dh;
Josh Durgin81e759f2011-11-15 14:49:53 -08001633 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001634
Alex Elder00f1f362012-02-07 12:03:36 -06001635 if (snap_count == header->total_snaps)
1636 break;
1637
1638 snap_count = header->total_snaps;
1639 len = sizeof (*dh) +
1640 snap_count * sizeof(struct rbd_image_snap_ondisk) +
1641 header->snap_names_len;
1642
1643 rbd_header_free(header);
1644 kfree(dh);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001645 }
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001646 header->obj_version = ver;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001647
1648out_dh:
1649 kfree(dh);
1650 return rc;
1651}
1652
1653/*
1654 * create a snapshot
1655 */
Alex Elder0ce1a792012-07-03 16:01:18 -05001656static int rbd_header_add_snap(struct rbd_device *rbd_dev,
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001657 const char *snap_name,
1658 gfp_t gfp_flags)
1659{
1660 int name_len = strlen(snap_name);
1661 u64 new_snapid;
1662 int ret;
Sage Weil916d4d62011-05-12 16:10:50 -07001663 void *data, *p, *e;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07001664 u64 ver;
Alex Elder1dbb4392012-01-24 10:08:37 -06001665 struct ceph_mon_client *monc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001666
1667 /* we should create a snapshot only if we're pointing at the head */
Alex Elder0ce1a792012-07-03 16:01:18 -05001668 if (rbd_dev->snap_id != CEPH_NOSNAP)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001669 return -EINVAL;
1670
Alex Elder0ce1a792012-07-03 16:01:18 -05001671 monc = &rbd_dev->rbd_client->client->monc;
1672 ret = ceph_monc_create_snapid(monc, rbd_dev->pool_id, &new_snapid);
Alex Elderbd919d42012-07-13 20:35:11 -05001673 dout("created snapid=%llu\n", (unsigned long long) new_snapid);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001674 if (ret < 0)
1675 return ret;
1676
1677 data = kmalloc(name_len + 16, gfp_flags);
1678 if (!data)
1679 return -ENOMEM;
1680
Sage Weil916d4d62011-05-12 16:10:50 -07001681 p = data;
1682 e = data + name_len + 16;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001683
Sage Weil916d4d62011-05-12 16:10:50 -07001684 ceph_encode_string_safe(&p, e, snap_name, name_len, bad);
1685 ceph_encode_64_safe(&p, e, new_snapid, bad);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001686
Alex Elder0bed54d2012-07-03 16:01:18 -05001687 ret = rbd_req_sync_exec(rbd_dev, rbd_dev->header_name,
Alex Elder0ce1a792012-07-03 16:01:18 -05001688 "rbd", "snap_add",
Sage Weil916d4d62011-05-12 16:10:50 -07001689 data, p - data, &ver);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001690
Sage Weil916d4d62011-05-12 16:10:50 -07001691 kfree(data);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001692
Alex Elder505cbb92012-07-19 08:49:18 -05001693 return ret < 0 ? ret : 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001694bad:
1695 return -ERANGE;
1696}
1697
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001698static void __rbd_remove_all_snaps(struct rbd_device *rbd_dev)
1699{
1700 struct rbd_snap *snap;
Alex Eldera0593292012-07-19 09:09:27 -05001701 struct rbd_snap *next;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001702
Alex Eldera0593292012-07-19 09:09:27 -05001703 list_for_each_entry_safe(snap, next, &rbd_dev->snaps, node)
Alex Elder14e70852012-07-19 09:09:27 -05001704 __rbd_remove_snap_dev(snap);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001705}
1706
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001707/*
1708 * only read the first part of the ondisk header, without the snaps info
1709 */
Josh Durgin263c6ca2011-12-05 10:43:42 -08001710static int __rbd_refresh_header(struct rbd_device *rbd_dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001711{
1712 int ret;
1713 struct rbd_image_header h;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001714
1715 ret = rbd_read_header(rbd_dev, &h);
1716 if (ret < 0)
1717 return ret;
1718
Josh Durgina51aa0c2011-12-05 10:35:04 -08001719 down_write(&rbd_dev->header_rwsem);
1720
Sage Weil9db4b3e2011-04-19 22:49:06 -07001721 /* resized? */
Josh Durgin474ef7c2011-11-21 17:13:54 -08001722 if (rbd_dev->snap_id == CEPH_NOSNAP) {
1723 sector_t size = (sector_t) h.image_size / SECTOR_SIZE;
1724
1725 dout("setting size to %llu sectors", (unsigned long long) size);
1726 set_capacity(rbd_dev->disk, size);
1727 }
Sage Weil9db4b3e2011-04-19 22:49:06 -07001728
Alex Elder849b4262012-07-09 21:04:24 -05001729 /* rbd_dev->header.object_prefix shouldn't change */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001730 kfree(rbd_dev->header.snap_sizes);
Alex Elder849b4262012-07-09 21:04:24 -05001731 kfree(rbd_dev->header.snap_names);
Josh Durgind1d25642011-12-05 14:03:05 -08001732 /* osd requests may still refer to snapc */
1733 ceph_put_snap_context(rbd_dev->header.snapc);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001734
Josh Durgina71b8912011-12-05 18:10:44 -08001735 rbd_dev->header.obj_version = h.obj_version;
Josh Durgin93a24e02011-12-05 10:41:28 -08001736 rbd_dev->header.image_size = h.image_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001737 rbd_dev->header.total_snaps = h.total_snaps;
1738 rbd_dev->header.snapc = h.snapc;
1739 rbd_dev->header.snap_names = h.snap_names;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001740 rbd_dev->header.snap_names_len = h.snap_names_len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001741 rbd_dev->header.snap_sizes = h.snap_sizes;
Alex Elder849b4262012-07-09 21:04:24 -05001742 /* Free the extra copy of the object prefix */
1743 WARN_ON(strcmp(rbd_dev->header.object_prefix, h.object_prefix));
1744 kfree(h.object_prefix);
1745
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001746 ret = __rbd_init_snaps_header(rbd_dev);
1747
Josh Durginc6666012011-11-21 17:11:12 -08001748 up_write(&rbd_dev->header_rwsem);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001749
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001750 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001751}
1752
1753static int rbd_init_disk(struct rbd_device *rbd_dev)
1754{
1755 struct gendisk *disk;
1756 struct request_queue *q;
1757 int rc;
Alex Elder593a9e72012-02-07 12:03:37 -06001758 u64 segment_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001759 u64 total_size = 0;
1760
1761 /* contact OSD, request size info about the object being mapped */
1762 rc = rbd_read_header(rbd_dev, &rbd_dev->header);
1763 if (rc)
1764 return rc;
1765
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001766 /* no need to lock here, as rbd_dev is not registered yet */
1767 rc = __rbd_init_snaps_header(rbd_dev);
1768 if (rc)
1769 return rc;
1770
Josh Durgincc9d7342011-11-21 18:19:13 -08001771 rc = rbd_header_set_snap(rbd_dev, &total_size);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001772 if (rc)
1773 return rc;
1774
1775 /* create gendisk info */
1776 rc = -ENOMEM;
1777 disk = alloc_disk(RBD_MINORS_PER_MAJOR);
1778 if (!disk)
1779 goto out;
1780
Alex Elderf0f8cef2012-01-29 13:57:44 -06001781 snprintf(disk->disk_name, sizeof(disk->disk_name), RBD_DRV_NAME "%d",
Alex Elderde71a292012-07-03 16:01:19 -05001782 rbd_dev->dev_id);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001783 disk->major = rbd_dev->major;
1784 disk->first_minor = 0;
1785 disk->fops = &rbd_bd_ops;
1786 disk->private_data = rbd_dev;
1787
1788 /* init rq */
1789 rc = -ENOMEM;
1790 q = blk_init_queue(rbd_rq_fn, &rbd_dev->lock);
1791 if (!q)
1792 goto out_disk;
Josh Durgin029bcbd2011-07-22 11:35:23 -07001793
Alex Elder593a9e72012-02-07 12:03:37 -06001794 /* We use the default size, but let's be explicit about it. */
1795 blk_queue_physical_block_size(q, SECTOR_SIZE);
1796
Josh Durgin029bcbd2011-07-22 11:35:23 -07001797 /* set io sizes to object size */
Alex Elder593a9e72012-02-07 12:03:37 -06001798 segment_size = rbd_obj_bytes(&rbd_dev->header);
1799 blk_queue_max_hw_sectors(q, segment_size / SECTOR_SIZE);
1800 blk_queue_max_segment_size(q, segment_size);
1801 blk_queue_io_min(q, segment_size);
1802 blk_queue_io_opt(q, segment_size);
Josh Durgin029bcbd2011-07-22 11:35:23 -07001803
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001804 blk_queue_merge_bvec(q, rbd_merge_bvec);
1805 disk->queue = q;
1806
1807 q->queuedata = rbd_dev;
1808
1809 rbd_dev->disk = disk;
1810 rbd_dev->q = q;
1811
1812 /* finally, announce the disk to the world */
Alex Elder593a9e72012-02-07 12:03:37 -06001813 set_capacity(disk, total_size / SECTOR_SIZE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001814 add_disk(disk);
1815
1816 pr_info("%s: added with size 0x%llx\n",
1817 disk->disk_name, (unsigned long long)total_size);
1818 return 0;
1819
1820out_disk:
1821 put_disk(disk);
1822out:
1823 return rc;
1824}
1825
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001826/*
1827 sysfs
1828*/
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001829
Alex Elder593a9e72012-02-07 12:03:37 -06001830static struct rbd_device *dev_to_rbd_dev(struct device *dev)
1831{
1832 return container_of(dev, struct rbd_device, dev);
1833}
1834
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001835static ssize_t rbd_size_show(struct device *dev,
1836 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001837{
Alex Elder593a9e72012-02-07 12:03:37 -06001838 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Josh Durgina51aa0c2011-12-05 10:35:04 -08001839 sector_t size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001840
Josh Durgina51aa0c2011-12-05 10:35:04 -08001841 down_read(&rbd_dev->header_rwsem);
1842 size = get_capacity(rbd_dev->disk);
1843 up_read(&rbd_dev->header_rwsem);
1844
1845 return sprintf(buf, "%llu\n", (unsigned long long) size * SECTOR_SIZE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001846}
1847
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001848static ssize_t rbd_major_show(struct device *dev,
1849 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001850{
Alex Elder593a9e72012-02-07 12:03:37 -06001851 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001852
1853 return sprintf(buf, "%d\n", rbd_dev->major);
1854}
1855
1856static ssize_t rbd_client_id_show(struct device *dev,
1857 struct device_attribute *attr, char *buf)
1858{
Alex Elder593a9e72012-02-07 12:03:37 -06001859 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001860
Alex Elder1dbb4392012-01-24 10:08:37 -06001861 return sprintf(buf, "client%lld\n",
1862 ceph_client_id(rbd_dev->rbd_client->client));
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001863}
1864
1865static ssize_t rbd_pool_show(struct device *dev,
1866 struct device_attribute *attr, char *buf)
1867{
Alex Elder593a9e72012-02-07 12:03:37 -06001868 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001869
1870 return sprintf(buf, "%s\n", rbd_dev->pool_name);
1871}
1872
Alex Elder9bb2f332012-07-12 10:46:35 -05001873static ssize_t rbd_pool_id_show(struct device *dev,
1874 struct device_attribute *attr, char *buf)
1875{
1876 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
1877
1878 return sprintf(buf, "%d\n", rbd_dev->pool_id);
1879}
1880
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001881static ssize_t rbd_name_show(struct device *dev,
1882 struct device_attribute *attr, char *buf)
1883{
Alex Elder593a9e72012-02-07 12:03:37 -06001884 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001885
Alex Elder0bed54d2012-07-03 16:01:18 -05001886 return sprintf(buf, "%s\n", rbd_dev->image_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001887}
1888
1889static ssize_t rbd_snap_show(struct device *dev,
1890 struct device_attribute *attr,
1891 char *buf)
1892{
Alex Elder593a9e72012-02-07 12:03:37 -06001893 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001894
1895 return sprintf(buf, "%s\n", rbd_dev->snap_name);
1896}
1897
1898static ssize_t rbd_image_refresh(struct device *dev,
1899 struct device_attribute *attr,
1900 const char *buf,
1901 size_t size)
1902{
Alex Elder593a9e72012-02-07 12:03:37 -06001903 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001904 int rc;
1905 int ret = size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001906
1907 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
1908
Josh Durgin263c6ca2011-12-05 10:43:42 -08001909 rc = __rbd_refresh_header(rbd_dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001910 if (rc < 0)
1911 ret = rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001912
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001913 mutex_unlock(&ctl_mutex);
1914 return ret;
1915}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001916
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001917static DEVICE_ATTR(size, S_IRUGO, rbd_size_show, NULL);
1918static DEVICE_ATTR(major, S_IRUGO, rbd_major_show, NULL);
1919static DEVICE_ATTR(client_id, S_IRUGO, rbd_client_id_show, NULL);
1920static DEVICE_ATTR(pool, S_IRUGO, rbd_pool_show, NULL);
Alex Elder9bb2f332012-07-12 10:46:35 -05001921static DEVICE_ATTR(pool_id, S_IRUGO, rbd_pool_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001922static DEVICE_ATTR(name, S_IRUGO, rbd_name_show, NULL);
1923static DEVICE_ATTR(refresh, S_IWUSR, NULL, rbd_image_refresh);
1924static DEVICE_ATTR(current_snap, S_IRUGO, rbd_snap_show, NULL);
1925static DEVICE_ATTR(create_snap, S_IWUSR, NULL, rbd_snap_add);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001926
1927static struct attribute *rbd_attrs[] = {
1928 &dev_attr_size.attr,
1929 &dev_attr_major.attr,
1930 &dev_attr_client_id.attr,
1931 &dev_attr_pool.attr,
Alex Elder9bb2f332012-07-12 10:46:35 -05001932 &dev_attr_pool_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001933 &dev_attr_name.attr,
1934 &dev_attr_current_snap.attr,
1935 &dev_attr_refresh.attr,
1936 &dev_attr_create_snap.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001937 NULL
1938};
1939
1940static struct attribute_group rbd_attr_group = {
1941 .attrs = rbd_attrs,
1942};
1943
1944static const struct attribute_group *rbd_attr_groups[] = {
1945 &rbd_attr_group,
1946 NULL
1947};
1948
1949static void rbd_sysfs_dev_release(struct device *dev)
1950{
1951}
1952
1953static struct device_type rbd_device_type = {
1954 .name = "rbd",
1955 .groups = rbd_attr_groups,
1956 .release = rbd_sysfs_dev_release,
1957};
1958
1959
1960/*
1961 sysfs - snapshots
1962*/
1963
1964static ssize_t rbd_snap_size_show(struct device *dev,
1965 struct device_attribute *attr,
1966 char *buf)
1967{
1968 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
1969
Josh Durgin35915382011-12-05 18:25:13 -08001970 return sprintf(buf, "%llu\n", (unsigned long long)snap->size);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001971}
1972
1973static ssize_t rbd_snap_id_show(struct device *dev,
1974 struct device_attribute *attr,
1975 char *buf)
1976{
1977 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
1978
Josh Durgin35915382011-12-05 18:25:13 -08001979 return sprintf(buf, "%llu\n", (unsigned long long)snap->id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08001980}
1981
1982static DEVICE_ATTR(snap_size, S_IRUGO, rbd_snap_size_show, NULL);
1983static DEVICE_ATTR(snap_id, S_IRUGO, rbd_snap_id_show, NULL);
1984
1985static struct attribute *rbd_snap_attrs[] = {
1986 &dev_attr_snap_size.attr,
1987 &dev_attr_snap_id.attr,
1988 NULL,
1989};
1990
1991static struct attribute_group rbd_snap_attr_group = {
1992 .attrs = rbd_snap_attrs,
1993};
1994
1995static void rbd_snap_dev_release(struct device *dev)
1996{
1997 struct rbd_snap *snap = container_of(dev, struct rbd_snap, dev);
1998 kfree(snap->name);
1999 kfree(snap);
2000}
2001
2002static const struct attribute_group *rbd_snap_attr_groups[] = {
2003 &rbd_snap_attr_group,
2004 NULL
2005};
2006
2007static struct device_type rbd_snap_device_type = {
2008 .groups = rbd_snap_attr_groups,
2009 .release = rbd_snap_dev_release,
2010};
2011
Alex Elder14e70852012-07-19 09:09:27 -05002012static void __rbd_remove_snap_dev(struct rbd_snap *snap)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002013{
2014 list_del(&snap->node);
2015 device_unregister(&snap->dev);
2016}
2017
Alex Elder14e70852012-07-19 09:09:27 -05002018static int rbd_register_snap_dev(struct rbd_snap *snap,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002019 struct device *parent)
2020{
2021 struct device *dev = &snap->dev;
2022 int ret;
2023
2024 dev->type = &rbd_snap_device_type;
2025 dev->parent = parent;
2026 dev->release = rbd_snap_dev_release;
2027 dev_set_name(dev, "snap_%s", snap->name);
2028 ret = device_register(dev);
2029
2030 return ret;
2031}
2032
2033static int __rbd_add_snap_dev(struct rbd_device *rbd_dev,
2034 int i, const char *name,
2035 struct rbd_snap **snapp)
2036{
2037 int ret;
2038 struct rbd_snap *snap = kzalloc(sizeof(*snap), GFP_KERNEL);
2039 if (!snap)
2040 return -ENOMEM;
2041 snap->name = kstrdup(name, GFP_KERNEL);
2042 snap->size = rbd_dev->header.snap_sizes[i];
2043 snap->id = rbd_dev->header.snapc->snaps[i];
2044 if (device_is_registered(&rbd_dev->dev)) {
Alex Elder14e70852012-07-19 09:09:27 -05002045 ret = rbd_register_snap_dev(snap, &rbd_dev->dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002046 if (ret < 0)
2047 goto err;
2048 }
2049 *snapp = snap;
2050 return 0;
2051err:
2052 kfree(snap->name);
2053 kfree(snap);
2054 return ret;
2055}
2056
2057/*
2058 * search for the previous snap in a null delimited string list
2059 */
2060const char *rbd_prev_snap_name(const char *name, const char *start)
2061{
2062 if (name < start + 2)
2063 return NULL;
2064
2065 name -= 2;
2066 while (*name) {
2067 if (name == start)
2068 return start;
2069 name--;
2070 }
2071 return name + 1;
2072}
2073
2074/*
2075 * compare the old list of snapshots that we have to what's in the header
2076 * and update it accordingly. Note that the header holds the snapshots
2077 * in a reverse order (from newest to oldest) and we need to go from
2078 * older to new so that we don't get a duplicate snap name when
2079 * doing the process (e.g., removed snapshot and recreated a new
2080 * one with the same name.
2081 */
2082static int __rbd_init_snaps_header(struct rbd_device *rbd_dev)
2083{
2084 const char *name, *first_name;
2085 int i = rbd_dev->header.total_snaps;
2086 struct rbd_snap *snap, *old_snap = NULL;
2087 int ret;
2088 struct list_head *p, *n;
2089
2090 first_name = rbd_dev->header.snap_names;
2091 name = first_name + rbd_dev->header.snap_names_len;
2092
2093 list_for_each_prev_safe(p, n, &rbd_dev->snaps) {
2094 u64 cur_id;
2095
2096 old_snap = list_entry(p, struct rbd_snap, node);
2097
2098 if (i)
2099 cur_id = rbd_dev->header.snapc->snaps[i - 1];
2100
2101 if (!i || old_snap->id < cur_id) {
Josh Durgine88a36e2011-11-21 18:14:25 -08002102 /*
2103 * old_snap->id was skipped, thus was
2104 * removed. If this rbd_dev is mapped to
2105 * the removed snapshot, record that it no
2106 * longer exists, to prevent further I/O.
2107 */
2108 if (rbd_dev->snap_id == old_snap->id)
2109 rbd_dev->snap_exists = false;
Alex Elder14e70852012-07-19 09:09:27 -05002110 __rbd_remove_snap_dev(old_snap);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002111 continue;
2112 }
2113 if (old_snap->id == cur_id) {
2114 /* we have this snapshot already */
2115 i--;
2116 name = rbd_prev_snap_name(name, first_name);
2117 continue;
2118 }
2119 for (; i > 0;
2120 i--, name = rbd_prev_snap_name(name, first_name)) {
2121 if (!name) {
2122 WARN_ON(1);
2123 return -EINVAL;
2124 }
2125 cur_id = rbd_dev->header.snapc->snaps[i];
2126 /* snapshot removal? handle it above */
2127 if (cur_id >= old_snap->id)
2128 break;
2129 /* a new snapshot */
2130 ret = __rbd_add_snap_dev(rbd_dev, i - 1, name, &snap);
2131 if (ret < 0)
2132 return ret;
2133
2134 /* note that we add it backward so using n and not p */
2135 list_add(&snap->node, n);
2136 p = &snap->node;
2137 }
2138 }
2139 /* we're done going over the old snap list, just add what's left */
2140 for (; i > 0; i--) {
2141 name = rbd_prev_snap_name(name, first_name);
2142 if (!name) {
2143 WARN_ON(1);
2144 return -EINVAL;
2145 }
2146 ret = __rbd_add_snap_dev(rbd_dev, i - 1, name, &snap);
2147 if (ret < 0)
2148 return ret;
2149 list_add(&snap->node, &rbd_dev->snaps);
2150 }
2151
2152 return 0;
2153}
2154
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002155static int rbd_bus_add_dev(struct rbd_device *rbd_dev)
2156{
Alex Elderf0f8cef2012-01-29 13:57:44 -06002157 int ret;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002158 struct device *dev;
2159 struct rbd_snap *snap;
2160
2161 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
2162 dev = &rbd_dev->dev;
2163
2164 dev->bus = &rbd_bus_type;
2165 dev->type = &rbd_device_type;
2166 dev->parent = &rbd_root_dev;
2167 dev->release = rbd_dev_release;
Alex Elderde71a292012-07-03 16:01:19 -05002168 dev_set_name(dev, "%d", rbd_dev->dev_id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002169 ret = device_register(dev);
2170 if (ret < 0)
Alex Elderf0f8cef2012-01-29 13:57:44 -06002171 goto out;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002172
2173 list_for_each_entry(snap, &rbd_dev->snaps, node) {
Alex Elder14e70852012-07-19 09:09:27 -05002174 ret = rbd_register_snap_dev(snap, &rbd_dev->dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002175 if (ret < 0)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002176 break;
2177 }
Alex Elderf0f8cef2012-01-29 13:57:44 -06002178out:
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002179 mutex_unlock(&ctl_mutex);
2180 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002181}
2182
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002183static void rbd_bus_del_dev(struct rbd_device *rbd_dev)
2184{
2185 device_unregister(&rbd_dev->dev);
2186}
2187
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002188static int rbd_init_watch_dev(struct rbd_device *rbd_dev)
2189{
2190 int ret, rc;
2191
2192 do {
Alex Elder0bed54d2012-07-03 16:01:18 -05002193 ret = rbd_req_sync_watch(rbd_dev, rbd_dev->header_name,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002194 rbd_dev->header.obj_version);
2195 if (ret == -ERANGE) {
2196 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
Josh Durgin263c6ca2011-12-05 10:43:42 -08002197 rc = __rbd_refresh_header(rbd_dev);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002198 mutex_unlock(&ctl_mutex);
2199 if (rc < 0)
2200 return rc;
2201 }
2202 } while (ret == -ERANGE);
2203
2204 return ret;
2205}
2206
Alex Elder1ddbe942012-01-29 13:57:44 -06002207static atomic64_t rbd_id_max = ATOMIC64_INIT(0);
2208
2209/*
Alex Elder499afd52012-02-02 08:13:29 -06002210 * Get a unique rbd identifier for the given new rbd_dev, and add
2211 * the rbd_dev to the global list. The minimum rbd id is 1.
Alex Elder1ddbe942012-01-29 13:57:44 -06002212 */
Alex Elder499afd52012-02-02 08:13:29 -06002213static void rbd_id_get(struct rbd_device *rbd_dev)
Alex Elderb7f23c32012-01-29 13:57:43 -06002214{
Alex Elderde71a292012-07-03 16:01:19 -05002215 rbd_dev->dev_id = atomic64_inc_return(&rbd_id_max);
Alex Elder499afd52012-02-02 08:13:29 -06002216
2217 spin_lock(&rbd_dev_list_lock);
2218 list_add_tail(&rbd_dev->node, &rbd_dev_list);
2219 spin_unlock(&rbd_dev_list_lock);
Alex Elder1ddbe942012-01-29 13:57:44 -06002220}
Alex Elderb7f23c32012-01-29 13:57:43 -06002221
Alex Elder1ddbe942012-01-29 13:57:44 -06002222/*
Alex Elder499afd52012-02-02 08:13:29 -06002223 * Remove an rbd_dev from the global list, and record that its
2224 * identifier is no longer in use.
Alex Elder1ddbe942012-01-29 13:57:44 -06002225 */
Alex Elder499afd52012-02-02 08:13:29 -06002226static void rbd_id_put(struct rbd_device *rbd_dev)
Alex Elder1ddbe942012-01-29 13:57:44 -06002227{
Alex Elderd184f6b2012-01-29 13:57:44 -06002228 struct list_head *tmp;
Alex Elderde71a292012-07-03 16:01:19 -05002229 int rbd_id = rbd_dev->dev_id;
Alex Elderd184f6b2012-01-29 13:57:44 -06002230 int max_id;
2231
2232 BUG_ON(rbd_id < 1);
Alex Elder499afd52012-02-02 08:13:29 -06002233
2234 spin_lock(&rbd_dev_list_lock);
2235 list_del_init(&rbd_dev->node);
Alex Elderd184f6b2012-01-29 13:57:44 -06002236
2237 /*
2238 * If the id being "put" is not the current maximum, there
2239 * is nothing special we need to do.
2240 */
2241 if (rbd_id != atomic64_read(&rbd_id_max)) {
2242 spin_unlock(&rbd_dev_list_lock);
2243 return;
2244 }
2245
2246 /*
2247 * We need to update the current maximum id. Search the
2248 * list to find out what it is. We're more likely to find
2249 * the maximum at the end, so search the list backward.
2250 */
2251 max_id = 0;
2252 list_for_each_prev(tmp, &rbd_dev_list) {
2253 struct rbd_device *rbd_dev;
2254
2255 rbd_dev = list_entry(tmp, struct rbd_device, node);
2256 if (rbd_id > max_id)
2257 max_id = rbd_id;
2258 }
Alex Elder499afd52012-02-02 08:13:29 -06002259 spin_unlock(&rbd_dev_list_lock);
Alex Elderb7f23c32012-01-29 13:57:43 -06002260
Alex Elder1ddbe942012-01-29 13:57:44 -06002261 /*
Alex Elderd184f6b2012-01-29 13:57:44 -06002262 * The max id could have been updated by rbd_id_get(), in
2263 * which case it now accurately reflects the new maximum.
2264 * Be careful not to overwrite the maximum value in that
2265 * case.
Alex Elder1ddbe942012-01-29 13:57:44 -06002266 */
Alex Elderd184f6b2012-01-29 13:57:44 -06002267 atomic64_cmpxchg(&rbd_id_max, rbd_id, max_id);
Alex Elderb7f23c32012-01-29 13:57:43 -06002268}
2269
Alex Eldera725f65e2012-02-02 08:13:30 -06002270/*
Alex Eldere28fff262012-02-02 08:13:30 -06002271 * Skips over white space at *buf, and updates *buf to point to the
2272 * first found non-space character (if any). Returns the length of
Alex Elder593a9e72012-02-07 12:03:37 -06002273 * the token (string of non-white space characters) found. Note
2274 * that *buf must be terminated with '\0'.
Alex Eldere28fff262012-02-02 08:13:30 -06002275 */
2276static inline size_t next_token(const char **buf)
2277{
2278 /*
2279 * These are the characters that produce nonzero for
2280 * isspace() in the "C" and "POSIX" locales.
2281 */
2282 const char *spaces = " \f\n\r\t\v";
2283
2284 *buf += strspn(*buf, spaces); /* Find start of token */
2285
2286 return strcspn(*buf, spaces); /* Return token length */
2287}
2288
2289/*
2290 * Finds the next token in *buf, and if the provided token buffer is
2291 * big enough, copies the found token into it. The result, if
Alex Elder593a9e72012-02-07 12:03:37 -06002292 * copied, is guaranteed to be terminated with '\0'. Note that *buf
2293 * must be terminated with '\0' on entry.
Alex Eldere28fff262012-02-02 08:13:30 -06002294 *
2295 * Returns the length of the token found (not including the '\0').
2296 * Return value will be 0 if no token is found, and it will be >=
2297 * token_size if the token would not fit.
2298 *
Alex Elder593a9e72012-02-07 12:03:37 -06002299 * The *buf pointer will be updated to point beyond the end of the
Alex Eldere28fff262012-02-02 08:13:30 -06002300 * found token. Note that this occurs even if the token buffer is
2301 * too small to hold it.
2302 */
2303static inline size_t copy_token(const char **buf,
2304 char *token,
2305 size_t token_size)
2306{
2307 size_t len;
2308
2309 len = next_token(buf);
2310 if (len < token_size) {
2311 memcpy(token, *buf, len);
2312 *(token + len) = '\0';
2313 }
2314 *buf += len;
2315
2316 return len;
2317}
2318
2319/*
Alex Elderea3352f2012-07-09 21:04:23 -05002320 * Finds the next token in *buf, dynamically allocates a buffer big
2321 * enough to hold a copy of it, and copies the token into the new
2322 * buffer. The copy is guaranteed to be terminated with '\0'. Note
2323 * that a duplicate buffer is created even for a zero-length token.
2324 *
2325 * Returns a pointer to the newly-allocated duplicate, or a null
2326 * pointer if memory for the duplicate was not available. If
2327 * the lenp argument is a non-null pointer, the length of the token
2328 * (not including the '\0') is returned in *lenp.
2329 *
2330 * If successful, the *buf pointer will be updated to point beyond
2331 * the end of the found token.
2332 *
2333 * Note: uses GFP_KERNEL for allocation.
2334 */
2335static inline char *dup_token(const char **buf, size_t *lenp)
2336{
2337 char *dup;
2338 size_t len;
2339
2340 len = next_token(buf);
2341 dup = kmalloc(len + 1, GFP_KERNEL);
2342 if (!dup)
2343 return NULL;
2344
2345 memcpy(dup, *buf, len);
2346 *(dup + len) = '\0';
2347 *buf += len;
2348
2349 if (lenp)
2350 *lenp = len;
2351
2352 return dup;
2353}
2354
2355/*
Alex Elder0bed54d2012-07-03 16:01:18 -05002356 * This fills in the pool_name, image_name, image_name_len, snap_name,
Alex Eldera725f65e2012-02-02 08:13:30 -06002357 * rbd_dev, rbd_md_name, and name fields of the given rbd_dev, based
2358 * on the list of monitor addresses and other options provided via
2359 * /sys/bus/rbd/add.
Alex Elderd22f76e2012-07-12 10:46:35 -05002360 *
2361 * Note: rbd_dev is assumed to have been initially zero-filled.
Alex Eldera725f65e2012-02-02 08:13:30 -06002362 */
2363static int rbd_add_parse_args(struct rbd_device *rbd_dev,
2364 const char *buf,
Alex Elder7ef32142012-02-02 08:13:30 -06002365 const char **mon_addrs,
Alex Elder5214ecc2012-02-02 08:13:30 -06002366 size_t *mon_addrs_size,
Alex Eldere28fff262012-02-02 08:13:30 -06002367 char *options,
Alex Elder0bed54d2012-07-03 16:01:18 -05002368 size_t options_size)
Alex Eldera725f65e2012-02-02 08:13:30 -06002369{
Alex Elderd22f76e2012-07-12 10:46:35 -05002370 size_t len;
2371 int ret;
Alex Eldere28fff262012-02-02 08:13:30 -06002372
2373 /* The first four tokens are required */
2374
Alex Elder7ef32142012-02-02 08:13:30 -06002375 len = next_token(&buf);
2376 if (!len)
Alex Eldera725f65e2012-02-02 08:13:30 -06002377 return -EINVAL;
Alex Elder5214ecc2012-02-02 08:13:30 -06002378 *mon_addrs_size = len + 1;
Alex Elder7ef32142012-02-02 08:13:30 -06002379 *mon_addrs = buf;
2380
2381 buf += len;
Alex Eldera725f65e2012-02-02 08:13:30 -06002382
Alex Eldere28fff262012-02-02 08:13:30 -06002383 len = copy_token(&buf, options, options_size);
2384 if (!len || len >= options_size)
2385 return -EINVAL;
Alex Eldera725f65e2012-02-02 08:13:30 -06002386
Alex Elderbf3e5ae2012-07-09 21:04:23 -05002387 ret = -ENOMEM;
Alex Elderd22f76e2012-07-12 10:46:35 -05002388 rbd_dev->pool_name = dup_token(&buf, NULL);
2389 if (!rbd_dev->pool_name)
Alex Elderd22f76e2012-07-12 10:46:35 -05002390 goto out_err;
Alex Eldere28fff262012-02-02 08:13:30 -06002391
Alex Elder0bed54d2012-07-03 16:01:18 -05002392 rbd_dev->image_name = dup_token(&buf, &rbd_dev->image_name_len);
2393 if (!rbd_dev->image_name)
Alex Elderbf3e5ae2012-07-09 21:04:23 -05002394 goto out_err;
Alex Eldere28fff262012-02-02 08:13:30 -06002395
Alex Eldercb8627c2012-07-09 21:04:23 -05002396 /* Create the name of the header object */
2397
Alex Elder0bed54d2012-07-03 16:01:18 -05002398 rbd_dev->header_name = kmalloc(rbd_dev->image_name_len
Alex Elderbf3e5ae2012-07-09 21:04:23 -05002399 + sizeof (RBD_SUFFIX),
2400 GFP_KERNEL);
Alex Elder0bed54d2012-07-03 16:01:18 -05002401 if (!rbd_dev->header_name)
Alex Eldercb8627c2012-07-09 21:04:23 -05002402 goto out_err;
Alex Elder0bed54d2012-07-03 16:01:18 -05002403 sprintf(rbd_dev->header_name, "%s%s", rbd_dev->image_name, RBD_SUFFIX);
Alex Eldera725f65e2012-02-02 08:13:30 -06002404
Alex Eldere28fff262012-02-02 08:13:30 -06002405 /*
Alex Elder820a5f32012-07-09 21:04:24 -05002406 * The snapshot name is optional. If none is is supplied,
2407 * we use the default value.
Alex Eldere28fff262012-02-02 08:13:30 -06002408 */
Alex Elder820a5f32012-07-09 21:04:24 -05002409 rbd_dev->snap_name = dup_token(&buf, &len);
2410 if (!rbd_dev->snap_name)
2411 goto out_err;
2412 if (!len) {
2413 /* Replace the empty name with the default */
2414 kfree(rbd_dev->snap_name);
2415 rbd_dev->snap_name
2416 = kmalloc(sizeof (RBD_SNAP_HEAD_NAME), GFP_KERNEL);
2417 if (!rbd_dev->snap_name)
2418 goto out_err;
2419
Alex Eldere28fff262012-02-02 08:13:30 -06002420 memcpy(rbd_dev->snap_name, RBD_SNAP_HEAD_NAME,
2421 sizeof (RBD_SNAP_HEAD_NAME));
Alex Elder849b4262012-07-09 21:04:24 -05002422 }
Alex Eldere28fff262012-02-02 08:13:30 -06002423
Alex Eldera725f65e2012-02-02 08:13:30 -06002424 return 0;
Alex Elderd22f76e2012-07-12 10:46:35 -05002425
2426out_err:
Alex Elder0bed54d2012-07-03 16:01:18 -05002427 kfree(rbd_dev->header_name);
2428 kfree(rbd_dev->image_name);
Alex Elderd22f76e2012-07-12 10:46:35 -05002429 kfree(rbd_dev->pool_name);
2430 rbd_dev->pool_name = NULL;
2431
2432 return ret;
Alex Eldera725f65e2012-02-02 08:13:30 -06002433}
2434
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002435static ssize_t rbd_add(struct bus_type *bus,
2436 const char *buf,
2437 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002438{
Alex Eldercb8627c2012-07-09 21:04:23 -05002439 char *options;
2440 struct rbd_device *rbd_dev = NULL;
Alex Elder7ef32142012-02-02 08:13:30 -06002441 const char *mon_addrs = NULL;
2442 size_t mon_addrs_size = 0;
Alex Elder27cc2592012-02-02 08:13:30 -06002443 struct ceph_osd_client *osdc;
2444 int rc = -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002445
2446 if (!try_module_get(THIS_MODULE))
2447 return -ENODEV;
2448
Alex Elder27cc2592012-02-02 08:13:30 -06002449 options = kmalloc(count, GFP_KERNEL);
2450 if (!options)
2451 goto err_nomem;
Alex Eldercb8627c2012-07-09 21:04:23 -05002452 rbd_dev = kzalloc(sizeof(*rbd_dev), GFP_KERNEL);
2453 if (!rbd_dev)
2454 goto err_nomem;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002455
2456 /* static rbd_device initialization */
2457 spin_lock_init(&rbd_dev->lock);
2458 INIT_LIST_HEAD(&rbd_dev->node);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002459 INIT_LIST_HEAD(&rbd_dev->snaps);
Josh Durginc6666012011-11-21 17:11:12 -08002460 init_rwsem(&rbd_dev->header_rwsem);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002461
Alex Elderd184f6b2012-01-29 13:57:44 -06002462 /* generate unique id: find highest unique id, add one */
Alex Elder499afd52012-02-02 08:13:29 -06002463 rbd_id_get(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002464
Alex Eldera725f65e2012-02-02 08:13:30 -06002465 /* Fill in the device name, now that we have its id. */
Alex Elder81a89792012-02-02 08:13:30 -06002466 BUILD_BUG_ON(DEV_NAME_LEN
2467 < sizeof (RBD_DRV_NAME) + MAX_INT_FORMAT_WIDTH);
Alex Elderde71a292012-07-03 16:01:19 -05002468 sprintf(rbd_dev->name, "%s%d", RBD_DRV_NAME, rbd_dev->dev_id);
Alex Eldere124a82f2012-01-29 13:57:44 -06002469
Alex Eldera725f65e2012-02-02 08:13:30 -06002470 /* parse add command */
Alex Elder7ef32142012-02-02 08:13:30 -06002471 rc = rbd_add_parse_args(rbd_dev, buf, &mon_addrs, &mon_addrs_size,
Alex Eldere28fff262012-02-02 08:13:30 -06002472 options, count);
Alex Eldera725f65e2012-02-02 08:13:30 -06002473 if (rc)
2474 goto err_put_id;
2475
Alex Elder5214ecc2012-02-02 08:13:30 -06002476 rbd_dev->rbd_client = rbd_get_client(mon_addrs, mon_addrs_size - 1,
2477 options);
Alex Elderd720bcb2012-02-02 08:13:30 -06002478 if (IS_ERR(rbd_dev->rbd_client)) {
2479 rc = PTR_ERR(rbd_dev->rbd_client);
Alex Elderf0f8cef2012-01-29 13:57:44 -06002480 goto err_put_id;
Alex Elderd720bcb2012-02-02 08:13:30 -06002481 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002482
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002483 /* pick the pool */
Alex Elder1dbb4392012-01-24 10:08:37 -06002484 osdc = &rbd_dev->rbd_client->client->osdc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002485 rc = ceph_pg_poolid_by_name(osdc->osdmap, rbd_dev->pool_name);
2486 if (rc < 0)
2487 goto err_out_client;
Alex Elder9bb2f332012-07-12 10:46:35 -05002488 rbd_dev->pool_id = rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002489
2490 /* register our block device */
Alex Elder27cc2592012-02-02 08:13:30 -06002491 rc = register_blkdev(0, rbd_dev->name);
2492 if (rc < 0)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002493 goto err_out_client;
Alex Elder27cc2592012-02-02 08:13:30 -06002494 rbd_dev->major = rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002495
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002496 rc = rbd_bus_add_dev(rbd_dev);
2497 if (rc)
Yehuda Sadeh766fc432011-01-07 14:58:42 -08002498 goto err_out_blkdev;
2499
Alex Elder32eec682012-02-08 16:11:14 -06002500 /*
2501 * At this point cleanup in the event of an error is the job
2502 * of the sysfs code (initiated by rbd_bus_del_dev()).
2503 *
2504 * Set up and announce blkdev mapping.
2505 */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002506 rc = rbd_init_disk(rbd_dev);
2507 if (rc)
Yehuda Sadeh766fc432011-01-07 14:58:42 -08002508 goto err_out_bus;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002509
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002510 rc = rbd_init_watch_dev(rbd_dev);
2511 if (rc)
2512 goto err_out_bus;
2513
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002514 return count;
2515
Yehuda Sadeh766fc432011-01-07 14:58:42 -08002516err_out_bus:
Yehuda Sadeh766fc432011-01-07 14:58:42 -08002517 /* this will also clean up rest of rbd_dev stuff */
2518
2519 rbd_bus_del_dev(rbd_dev);
2520 kfree(options);
Yehuda Sadeh766fc432011-01-07 14:58:42 -08002521 return rc;
2522
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002523err_out_blkdev:
2524 unregister_blkdev(rbd_dev->major, rbd_dev->name);
2525err_out_client:
2526 rbd_put_client(rbd_dev);
Alex Elderf0f8cef2012-01-29 13:57:44 -06002527err_put_id:
Alex Eldercb8627c2012-07-09 21:04:23 -05002528 if (rbd_dev->pool_name) {
Alex Elder820a5f32012-07-09 21:04:24 -05002529 kfree(rbd_dev->snap_name);
Alex Elder0bed54d2012-07-03 16:01:18 -05002530 kfree(rbd_dev->header_name);
2531 kfree(rbd_dev->image_name);
Alex Eldercb8627c2012-07-09 21:04:23 -05002532 kfree(rbd_dev->pool_name);
2533 }
Alex Elder499afd52012-02-02 08:13:29 -06002534 rbd_id_put(rbd_dev);
Alex Elder27cc2592012-02-02 08:13:30 -06002535err_nomem:
Alex Elder27cc2592012-02-02 08:13:30 -06002536 kfree(rbd_dev);
Alex Eldercb8627c2012-07-09 21:04:23 -05002537 kfree(options);
Alex Elder27cc2592012-02-02 08:13:30 -06002538
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002539 dout("Error adding device %s\n", buf);
2540 module_put(THIS_MODULE);
Alex Elder27cc2592012-02-02 08:13:30 -06002541
2542 return (ssize_t) rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002543}
2544
Alex Elderde71a292012-07-03 16:01:19 -05002545static struct rbd_device *__rbd_get_dev(unsigned long dev_id)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002546{
2547 struct list_head *tmp;
2548 struct rbd_device *rbd_dev;
2549
Alex Eldere124a82f2012-01-29 13:57:44 -06002550 spin_lock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002551 list_for_each(tmp, &rbd_dev_list) {
2552 rbd_dev = list_entry(tmp, struct rbd_device, node);
Alex Elderde71a292012-07-03 16:01:19 -05002553 if (rbd_dev->dev_id == dev_id) {
Alex Eldere124a82f2012-01-29 13:57:44 -06002554 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002555 return rbd_dev;
Alex Eldere124a82f2012-01-29 13:57:44 -06002556 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002557 }
Alex Eldere124a82f2012-01-29 13:57:44 -06002558 spin_unlock(&rbd_dev_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002559 return NULL;
2560}
2561
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002562static void rbd_dev_release(struct device *dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002563{
Alex Elder593a9e72012-02-07 12:03:37 -06002564 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002565
Alex Elder1dbb4392012-01-24 10:08:37 -06002566 if (rbd_dev->watch_request) {
2567 struct ceph_client *client = rbd_dev->rbd_client->client;
2568
2569 ceph_osdc_unregister_linger_request(&client->osdc,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002570 rbd_dev->watch_request);
Alex Elder1dbb4392012-01-24 10:08:37 -06002571 }
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002572 if (rbd_dev->watch_event)
Alex Elder0bed54d2012-07-03 16:01:18 -05002573 rbd_req_sync_unwatch(rbd_dev, rbd_dev->header_name);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002574
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002575 rbd_put_client(rbd_dev);
2576
2577 /* clean up and free blkdev */
2578 rbd_free_disk(rbd_dev);
2579 unregister_blkdev(rbd_dev->major, rbd_dev->name);
Alex Elder32eec682012-02-08 16:11:14 -06002580
2581 /* done with the id, and with the rbd_dev */
Alex Elder820a5f32012-07-09 21:04:24 -05002582 kfree(rbd_dev->snap_name);
Alex Elder0bed54d2012-07-03 16:01:18 -05002583 kfree(rbd_dev->header_name);
Alex Elderd22f76e2012-07-12 10:46:35 -05002584 kfree(rbd_dev->pool_name);
Alex Elder0bed54d2012-07-03 16:01:18 -05002585 kfree(rbd_dev->image_name);
Alex Elder32eec682012-02-08 16:11:14 -06002586 rbd_id_put(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002587 kfree(rbd_dev);
2588
2589 /* release module ref */
2590 module_put(THIS_MODULE);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002591}
2592
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002593static ssize_t rbd_remove(struct bus_type *bus,
2594 const char *buf,
2595 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002596{
2597 struct rbd_device *rbd_dev = NULL;
2598 int target_id, rc;
2599 unsigned long ul;
2600 int ret = count;
2601
2602 rc = strict_strtoul(buf, 10, &ul);
2603 if (rc)
2604 return rc;
2605
2606 /* convert to int; abort if we lost anything in the conversion */
2607 target_id = (int) ul;
2608 if (target_id != ul)
2609 return -EINVAL;
2610
2611 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
2612
2613 rbd_dev = __rbd_get_dev(target_id);
2614 if (!rbd_dev) {
2615 ret = -ENOENT;
2616 goto done;
2617 }
2618
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002619 __rbd_remove_all_snaps(rbd_dev);
2620 rbd_bus_del_dev(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002621
2622done:
2623 mutex_unlock(&ctl_mutex);
2624 return ret;
2625}
2626
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002627static ssize_t rbd_snap_add(struct device *dev,
2628 struct device_attribute *attr,
2629 const char *buf,
2630 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002631{
Alex Elder593a9e72012-02-07 12:03:37 -06002632 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002633 int ret;
2634 char *name = kmalloc(count + 1, GFP_KERNEL);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002635 if (!name)
2636 return -ENOMEM;
2637
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002638 snprintf(name, count, "%s", buf);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002639
2640 mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
2641
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002642 ret = rbd_header_add_snap(rbd_dev,
2643 name, GFP_KERNEL);
2644 if (ret < 0)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002645 goto err_unlock;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002646
Josh Durgin263c6ca2011-12-05 10:43:42 -08002647 ret = __rbd_refresh_header(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002648 if (ret < 0)
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002649 goto err_unlock;
2650
2651 /* shouldn't hold ctl_mutex when notifying.. notify might
2652 trigger a watch callback that would need to get that mutex */
2653 mutex_unlock(&ctl_mutex);
2654
2655 /* make a best effort, don't error if failed */
Alex Elder0bed54d2012-07-03 16:01:18 -05002656 rbd_req_sync_notify(rbd_dev, rbd_dev->header_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002657
2658 ret = count;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -07002659 kfree(name);
2660 return ret;
2661
2662err_unlock:
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002663 mutex_unlock(&ctl_mutex);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002664 kfree(name);
2665 return ret;
2666}
2667
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002668/*
2669 * create control files in sysfs
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002670 * /sys/bus/rbd/...
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002671 */
2672static int rbd_sysfs_init(void)
2673{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002674 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002675
Alex Elderfed4c142012-02-07 12:03:36 -06002676 ret = device_register(&rbd_root_dev);
Alex Elder21079782012-01-24 10:08:36 -06002677 if (ret < 0)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002678 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002679
Alex Elderfed4c142012-02-07 12:03:36 -06002680 ret = bus_register(&rbd_bus_type);
2681 if (ret < 0)
2682 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002683
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002684 return ret;
2685}
2686
2687static void rbd_sysfs_cleanup(void)
2688{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08002689 bus_unregister(&rbd_bus_type);
Alex Elderfed4c142012-02-07 12:03:36 -06002690 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002691}
2692
2693int __init rbd_init(void)
2694{
2695 int rc;
2696
2697 rc = rbd_sysfs_init();
2698 if (rc)
2699 return rc;
Alex Elderf0f8cef2012-01-29 13:57:44 -06002700 pr_info("loaded " RBD_DRV_NAME_LONG "\n");
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002701 return 0;
2702}
2703
2704void __exit rbd_exit(void)
2705{
2706 rbd_sysfs_cleanup();
2707}
2708
2709module_init(rbd_init);
2710module_exit(rbd_exit);
2711
2712MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
2713MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
2714MODULE_DESCRIPTION("rados block device");
2715
2716/* following authorship retained from original osdblk.c */
2717MODULE_AUTHOR("Jeff Garzik <jeff@garzik.org>");
2718
2719MODULE_LICENSE("GPL");