blob: 94747afc2e78f111fe750565381709f764f6c812 [file] [log] [blame]
Alex Eldere2a58ee2013-04-30 00:44:33 -05001
Yehuda Sadeh602adf42010-08-12 16:11:25 -07002/*
3 rbd.c -- Export ceph rados objects as a Linux block device
4
5
6 based on drivers/block/osdblk.c:
7
8 Copyright 2009 Red Hat, Inc.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; see the file COPYING. If not, write to
21 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
22
23
24
Yehuda Sadehdfc56062010-11-19 14:51:04 -080025 For usage instructions, please refer to:
Yehuda Sadeh602adf42010-08-12 16:11:25 -070026
Yehuda Sadehdfc56062010-11-19 14:51:04 -080027 Documentation/ABI/testing/sysfs-bus-rbd
Yehuda Sadeh602adf42010-08-12 16:11:25 -070028
29 */
30
31#include <linux/ceph/libceph.h>
32#include <linux/ceph/osd_client.h>
33#include <linux/ceph/mon_client.h>
34#include <linux/ceph/decode.h>
Yehuda Sadeh59c2be12011-03-21 15:10:11 -070035#include <linux/parser.h>
Alex Elder30d1cff2013-05-01 12:43:03 -050036#include <linux/bsearch.h>
Yehuda Sadeh602adf42010-08-12 16:11:25 -070037
38#include <linux/kernel.h>
39#include <linux/device.h>
40#include <linux/module.h>
41#include <linux/fs.h>
42#include <linux/blkdev.h>
Alex Elder1c2a9df2013-05-01 12:43:03 -050043#include <linux/slab.h>
Ilya Dryomovf8a22fc2013-12-13 15:28:57 +020044#include <linux/idr.h>
Yehuda Sadeh602adf42010-08-12 16:11:25 -070045
46#include "rbd_types.h"
47
Alex Elderaafb2302012-09-06 16:00:54 -050048#define RBD_DEBUG /* Activate rbd_assert() calls */
49
Alex Elder593a9e72012-02-07 12:03:37 -060050/*
51 * The basic unit of block I/O is a sector. It is interpreted in a
52 * number of contexts in Linux (blk, bio, genhd), but the default is
53 * universally 512 bytes. These symbols are just slightly more
54 * meaningful than the bare numbers they represent.
55 */
56#define SECTOR_SHIFT 9
57#define SECTOR_SIZE (1ULL << SECTOR_SHIFT)
58
Alex Eldera2acd002013-05-08 22:50:04 -050059/*
60 * Increment the given counter and return its updated value.
61 * If the counter is already 0 it will not be incremented.
62 * If the counter is already at its maximum value returns
63 * -EINVAL without updating it.
64 */
65static int atomic_inc_return_safe(atomic_t *v)
66{
67 unsigned int counter;
68
69 counter = (unsigned int)__atomic_add_unless(v, 1, 0);
70 if (counter <= (unsigned int)INT_MAX)
71 return (int)counter;
72
73 atomic_dec(v);
74
75 return -EINVAL;
76}
77
78/* Decrement the counter. Return the resulting value, or -EINVAL */
79static int atomic_dec_return_safe(atomic_t *v)
80{
81 int counter;
82
83 counter = atomic_dec_return(v);
84 if (counter >= 0)
85 return counter;
86
87 atomic_inc(v);
88
89 return -EINVAL;
90}
91
Alex Elderf0f8cef2012-01-29 13:57:44 -060092#define RBD_DRV_NAME "rbd"
Yehuda Sadeh602adf42010-08-12 16:11:25 -070093
Ilya Dryomov7e513d42013-12-16 19:26:32 +020094#define RBD_MINORS_PER_MAJOR 256
95#define RBD_SINGLE_MAJOR_PART_SHIFT 4
Yehuda Sadeh602adf42010-08-12 16:11:25 -070096
Alex Elderd4b125e2012-07-03 16:01:19 -050097#define RBD_SNAP_DEV_NAME_PREFIX "snap_"
98#define RBD_MAX_SNAP_NAME_LEN \
99 (NAME_MAX - (sizeof (RBD_SNAP_DEV_NAME_PREFIX) - 1))
100
Alex Elder35d489f2012-07-03 16:01:19 -0500101#define RBD_MAX_SNAP_COUNT 510 /* allows max snapc to fit in 4KB */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700102
103#define RBD_SNAP_HEAD_NAME "-"
104
Alex Elder9682fc62013-04-30 00:44:33 -0500105#define BAD_SNAP_INDEX U32_MAX /* invalid index into snap array */
106
Alex Elder9e15b772012-10-30 19:40:33 -0500107/* This allows a single page to hold an image name sent by OSD */
108#define RBD_IMAGE_NAME_LEN_MAX (PAGE_SIZE - sizeof (__le32) - 1)
Alex Elder1e130192012-07-03 16:01:19 -0500109#define RBD_IMAGE_ID_LEN_MAX 64
Alex Elder9e15b772012-10-30 19:40:33 -0500110
Alex Elder1e130192012-07-03 16:01:19 -0500111#define RBD_OBJ_PREFIX_LEN_MAX 64
Alex Elder589d30e2012-07-10 20:30:11 -0500112
Alex Elderd8891402012-10-09 13:50:17 -0700113/* Feature bits */
114
Alex Elder5cbf6f122013-04-11 09:29:48 -0500115#define RBD_FEATURE_LAYERING (1<<0)
116#define RBD_FEATURE_STRIPINGV2 (1<<1)
117#define RBD_FEATURES_ALL \
118 (RBD_FEATURE_LAYERING | RBD_FEATURE_STRIPINGV2)
Alex Elderd8891402012-10-09 13:50:17 -0700119
120/* Features supported by this (client software) implementation. */
121
Alex Elder770eba62012-10-25 23:34:40 -0500122#define RBD_FEATURES_SUPPORTED (RBD_FEATURES_ALL)
Alex Elderd8891402012-10-09 13:50:17 -0700123
Alex Elder81a89792012-02-02 08:13:30 -0600124/*
125 * An RBD device name will be "rbd#", where the "rbd" comes from
126 * RBD_DRV_NAME above, and # is a unique integer identifier.
127 * MAX_INT_FORMAT_WIDTH is used in ensuring DEV_NAME_LEN is big
128 * enough to hold all possible device names.
129 */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700130#define DEV_NAME_LEN 32
Alex Elder81a89792012-02-02 08:13:30 -0600131#define MAX_INT_FORMAT_WIDTH ((5 * sizeof (int)) / 2 + 1)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700132
133/*
134 * block device image metadata (in-memory version)
135 */
136struct rbd_image_header {
Alex Elderf35a4de2013-05-06 09:51:29 -0500137 /* These six fields never change for a given rbd image */
Alex Elder849b4262012-07-09 21:04:24 -0500138 char *object_prefix;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700139 __u8 obj_order;
140 __u8 crypt_type;
141 __u8 comp_type;
Alex Elderf35a4de2013-05-06 09:51:29 -0500142 u64 stripe_unit;
143 u64 stripe_count;
144 u64 features; /* Might be changeable someday? */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700145
Alex Elderf84344f2012-08-31 17:29:51 -0500146 /* The remaining fields need to be updated occasionally */
147 u64 image_size;
148 struct ceph_snap_context *snapc;
Alex Elderf35a4de2013-05-06 09:51:29 -0500149 char *snap_names; /* format 1 only */
150 u64 *snap_sizes; /* format 1 only */
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700151};
152
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500153/*
154 * An rbd image specification.
155 *
156 * The tuple (pool_id, image_id, snap_id) is sufficient to uniquely
Alex Elderc66c6e02012-11-01 08:39:26 -0500157 * identify an image. Each rbd_dev structure includes a pointer to
158 * an rbd_spec structure that encapsulates this identity.
159 *
160 * Each of the id's in an rbd_spec has an associated name. For a
161 * user-mapped image, the names are supplied and the id's associated
162 * with them are looked up. For a layered image, a parent image is
163 * defined by the tuple, and the names are looked up.
164 *
165 * An rbd_dev structure contains a parent_spec pointer which is
166 * non-null if the image it represents is a child in a layered
167 * image. This pointer will refer to the rbd_spec structure used
168 * by the parent rbd_dev for its own identity (i.e., the structure
169 * is shared between the parent and child).
170 *
171 * Since these structures are populated once, during the discovery
172 * phase of image construction, they are effectively immutable so
173 * we make no effort to synchronize access to them.
174 *
175 * Note that code herein does not assume the image name is known (it
176 * could be a null pointer).
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500177 */
178struct rbd_spec {
179 u64 pool_id;
Alex Elderecb4dc222013-04-26 09:43:47 -0500180 const char *pool_name;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500181
Alex Elderecb4dc222013-04-26 09:43:47 -0500182 const char *image_id;
183 const char *image_name;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500184
185 u64 snap_id;
Alex Elderecb4dc222013-04-26 09:43:47 -0500186 const char *snap_name;
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500187
188 struct kref kref;
189};
190
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700191/*
Alex Elderf0f8cef2012-01-29 13:57:44 -0600192 * an instance of the client. multiple devices may share an rbd client.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700193 */
194struct rbd_client {
195 struct ceph_client *client;
196 struct kref kref;
197 struct list_head node;
198};
199
Alex Elderbf0d5f502012-11-22 00:00:08 -0600200struct rbd_img_request;
201typedef void (*rbd_img_callback_t)(struct rbd_img_request *);
202
203#define BAD_WHICH U32_MAX /* Good which or bad which, which? */
204
205struct rbd_obj_request;
206typedef void (*rbd_obj_callback_t)(struct rbd_obj_request *);
207
Alex Elder9969ebc2013-01-18 12:31:10 -0600208enum obj_request_type {
209 OBJ_REQUEST_NODATA, OBJ_REQUEST_BIO, OBJ_REQUEST_PAGES
210};
Alex Elderbf0d5f502012-11-22 00:00:08 -0600211
Alex Elder926f9b32013-02-11 12:33:24 -0600212enum obj_req_flags {
213 OBJ_REQ_DONE, /* completion flag: not done = 0, done = 1 */
Alex Elder6365d332013-02-11 12:33:24 -0600214 OBJ_REQ_IMG_DATA, /* object usage: standalone = 0, image = 1 */
Alex Elder5679c592013-02-11 12:33:24 -0600215 OBJ_REQ_KNOWN, /* EXISTS flag valid: no = 0, yes = 1 */
216 OBJ_REQ_EXISTS, /* target exists: no = 0, yes = 1 */
Alex Elder926f9b32013-02-11 12:33:24 -0600217};
218
Alex Elderbf0d5f502012-11-22 00:00:08 -0600219struct rbd_obj_request {
220 const char *object_name;
221 u64 offset; /* object start byte */
222 u64 length; /* bytes from offset */
Alex Elder926f9b32013-02-11 12:33:24 -0600223 unsigned long flags;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600224
Alex Elderc5b5ef62013-02-11 12:33:24 -0600225 /*
226 * An object request associated with an image will have its
227 * img_data flag set; a standalone object request will not.
228 *
229 * A standalone object request will have which == BAD_WHICH
230 * and a null obj_request pointer.
231 *
232 * An object request initiated in support of a layered image
233 * object (to check for its existence before a write) will
234 * have which == BAD_WHICH and a non-null obj_request pointer.
235 *
236 * Finally, an object request for rbd image data will have
237 * which != BAD_WHICH, and will have a non-null img_request
238 * pointer. The value of which will be in the range
239 * 0..(img_request->obj_request_count-1).
240 */
241 union {
242 struct rbd_obj_request *obj_request; /* STAT op */
243 struct {
244 struct rbd_img_request *img_request;
245 u64 img_offset;
246 /* links for img_request->obj_requests list */
247 struct list_head links;
248 };
249 };
Alex Elderbf0d5f502012-11-22 00:00:08 -0600250 u32 which; /* posn image request list */
251
252 enum obj_request_type type;
Alex Elder788e2df2013-01-17 12:25:27 -0600253 union {
254 struct bio *bio_list;
255 struct {
256 struct page **pages;
257 u32 page_count;
258 };
259 };
Alex Elder0eefd472013-04-19 15:34:50 -0500260 struct page **copyup_pages;
Alex Elderebda6402013-05-10 16:29:22 -0500261 u32 copyup_page_count;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600262
263 struct ceph_osd_request *osd_req;
264
265 u64 xferred; /* bytes transferred */
Sage Weil1b83bef2013-02-25 16:11:12 -0800266 int result;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600267
268 rbd_obj_callback_t callback;
Alex Elder788e2df2013-01-17 12:25:27 -0600269 struct completion completion;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600270
271 struct kref kref;
272};
273
Alex Elder0c425242013-02-08 09:55:49 -0600274enum img_req_flags {
Alex Elder9849e982013-01-24 16:13:36 -0600275 IMG_REQ_WRITE, /* I/O direction: read = 0, write = 1 */
276 IMG_REQ_CHILD, /* initiator: block = 0, child image = 1 */
Alex Elderd0b2e942013-01-24 16:13:36 -0600277 IMG_REQ_LAYERED, /* ENOENT handling: normal = 0, layered = 1 */
Alex Elder0c425242013-02-08 09:55:49 -0600278};
279
Alex Elderbf0d5f502012-11-22 00:00:08 -0600280struct rbd_img_request {
Alex Elderbf0d5f502012-11-22 00:00:08 -0600281 struct rbd_device *rbd_dev;
282 u64 offset; /* starting image byte offset */
283 u64 length; /* byte count from offset */
Alex Elder0c425242013-02-08 09:55:49 -0600284 unsigned long flags;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600285 union {
Alex Elder9849e982013-01-24 16:13:36 -0600286 u64 snap_id; /* for reads */
Alex Elderbf0d5f502012-11-22 00:00:08 -0600287 struct ceph_snap_context *snapc; /* for writes */
Alex Elder9849e982013-01-24 16:13:36 -0600288 };
289 union {
290 struct request *rq; /* block request */
291 struct rbd_obj_request *obj_request; /* obj req initiator */
Alex Elderbf0d5f502012-11-22 00:00:08 -0600292 };
Alex Elder3d7efd12013-04-19 15:34:50 -0500293 struct page **copyup_pages;
Alex Elderebda6402013-05-10 16:29:22 -0500294 u32 copyup_page_count;
Alex Elderbf0d5f502012-11-22 00:00:08 -0600295 spinlock_t completion_lock;/* protects next_completion */
296 u32 next_completion;
297 rbd_img_callback_t callback;
Alex Elder55f27e02013-04-10 12:34:25 -0500298 u64 xferred;/* aggregate bytes transferred */
Alex Eldera5a337d2013-01-24 16:13:36 -0600299 int result; /* first nonzero obj_request result */
Alex Elderbf0d5f502012-11-22 00:00:08 -0600300
301 u32 obj_request_count;
302 struct list_head obj_requests; /* rbd_obj_request structs */
303
304 struct kref kref;
305};
306
307#define for_each_obj_request(ireq, oreq) \
Alex Elderef06f4d32013-02-08 09:55:48 -0600308 list_for_each_entry(oreq, &(ireq)->obj_requests, links)
Alex Elderbf0d5f502012-11-22 00:00:08 -0600309#define for_each_obj_request_from(ireq, oreq) \
Alex Elderef06f4d32013-02-08 09:55:48 -0600310 list_for_each_entry_from(oreq, &(ireq)->obj_requests, links)
Alex Elderbf0d5f502012-11-22 00:00:08 -0600311#define for_each_obj_request_safe(ireq, oreq, n) \
Alex Elderef06f4d32013-02-08 09:55:48 -0600312 list_for_each_entry_safe_reverse(oreq, n, &(ireq)->obj_requests, links)
Alex Elderbf0d5f502012-11-22 00:00:08 -0600313
Alex Elderf84344f2012-08-31 17:29:51 -0500314struct rbd_mapping {
Alex Elder99c1f08f2012-08-30 14:42:15 -0500315 u64 size;
Alex Elder34b13182012-07-13 20:35:12 -0500316 u64 features;
Alex Elderf84344f2012-08-31 17:29:51 -0500317 bool read_only;
318};
319
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700320/*
321 * a single device
322 */
323struct rbd_device {
Alex Elderde71a292012-07-03 16:01:19 -0500324 int dev_id; /* blkdev unique id */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700325
326 int major; /* blkdev assigned major */
Ilya Dryomovdd82fff2013-12-13 15:28:57 +0200327 int minor;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700328 struct gendisk *disk; /* blkdev's gendisk and rq */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700329
Alex Eldera30b71b2012-07-10 20:30:11 -0500330 u32 image_format; /* Either 1 or 2 */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700331 struct rbd_client *rbd_client;
332
333 char name[DEV_NAME_LEN]; /* blkdev name, e.g. rbd3 */
334
Alex Elderb82d1672013-01-14 12:43:31 -0600335 spinlock_t lock; /* queue, flags, open_count */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700336
337 struct rbd_image_header header;
Alex Elderb82d1672013-01-14 12:43:31 -0600338 unsigned long flags; /* possibly lock protected */
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500339 struct rbd_spec *spec;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700340
Alex Elder0d7dbfc2012-10-25 23:34:41 -0500341 char *header_name;
Alex Elder971f8392012-10-25 23:34:41 -0500342
Alex Elder0903e872012-11-14 12:25:19 -0600343 struct ceph_file_layout layout;
344
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700345 struct ceph_osd_event *watch_event;
Alex Elder975241a2013-01-25 17:08:55 -0600346 struct rbd_obj_request *watch_request;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700347
Alex Elder86b00e02012-10-25 23:34:42 -0500348 struct rbd_spec *parent_spec;
349 u64 parent_overlap;
Alex Eldera2acd002013-05-08 22:50:04 -0500350 atomic_t parent_ref;
Alex Elder2f82ee52012-10-30 19:40:33 -0500351 struct rbd_device *parent;
Alex Elder86b00e02012-10-25 23:34:42 -0500352
Josh Durginc6666012011-11-21 17:11:12 -0800353 /* protects updating the header */
354 struct rw_semaphore header_rwsem;
Alex Elderf84344f2012-08-31 17:29:51 -0500355
356 struct rbd_mapping mapping;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700357
358 struct list_head node;
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800359
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800360 /* sysfs related */
361 struct device dev;
Alex Elderb82d1672013-01-14 12:43:31 -0600362 unsigned long open_count; /* protected by lock */
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800363};
364
Alex Elderb82d1672013-01-14 12:43:31 -0600365/*
366 * Flag bits for rbd_dev->flags. If atomicity is required,
367 * rbd_dev->lock is used to protect access.
368 *
369 * Currently, only the "removing" flag (which is coupled with the
370 * "open_count" field) requires atomic access.
371 */
Alex Elder6d292902013-01-14 12:43:31 -0600372enum rbd_dev_flags {
373 RBD_DEV_FLAG_EXISTS, /* mapped snapshot has not been deleted */
Alex Elderb82d1672013-01-14 12:43:31 -0600374 RBD_DEV_FLAG_REMOVING, /* this mapping is being removed */
Alex Elder6d292902013-01-14 12:43:31 -0600375};
376
Alex Eldercfbf6372013-05-31 17:40:45 -0500377static DEFINE_MUTEX(client_mutex); /* Serialize client creation */
Alex Eldere124a82f2012-01-29 13:57:44 -0600378
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700379static LIST_HEAD(rbd_dev_list); /* devices */
Alex Eldere124a82f2012-01-29 13:57:44 -0600380static DEFINE_SPINLOCK(rbd_dev_list_lock);
381
Alex Elder432b8582012-01-29 13:57:44 -0600382static LIST_HEAD(rbd_client_list); /* clients */
383static DEFINE_SPINLOCK(rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700384
Alex Elder78c2a442013-05-01 12:43:04 -0500385/* Slab caches for frequently-allocated structures */
386
Alex Elder1c2a9df2013-05-01 12:43:03 -0500387static struct kmem_cache *rbd_img_request_cache;
Alex Elder868311b2013-05-01 12:43:03 -0500388static struct kmem_cache *rbd_obj_request_cache;
Alex Elder78c2a442013-05-01 12:43:04 -0500389static struct kmem_cache *rbd_segment_name_cache;
Alex Elder1c2a9df2013-05-01 12:43:03 -0500390
Ilya Dryomov9b60e702013-12-13 15:28:57 +0200391static int rbd_major;
Ilya Dryomovf8a22fc2013-12-13 15:28:57 +0200392static DEFINE_IDA(rbd_dev_id_ida);
393
Ilya Dryomov9b60e702013-12-13 15:28:57 +0200394/*
395 * Default to false for now, as single-major requires >= 0.75 version of
396 * userspace rbd utility.
397 */
398static bool single_major = false;
399module_param(single_major, bool, S_IRUGO);
400MODULE_PARM_DESC(single_major, "Use a single major number for all rbd devices (default: false)");
401
Alex Elder3d7efd12013-04-19 15:34:50 -0500402static int rbd_img_request_submit(struct rbd_img_request *img_request);
403
Alex Elder200a6a82013-04-28 23:32:34 -0500404static void rbd_dev_device_release(struct device *dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800405
Alex Elderf0f8cef2012-01-29 13:57:44 -0600406static ssize_t rbd_add(struct bus_type *bus, const char *buf,
407 size_t count);
408static ssize_t rbd_remove(struct bus_type *bus, const char *buf,
409 size_t count);
Ilya Dryomov9b60e702013-12-13 15:28:57 +0200410static ssize_t rbd_add_single_major(struct bus_type *bus, const char *buf,
411 size_t count);
412static ssize_t rbd_remove_single_major(struct bus_type *bus, const char *buf,
413 size_t count);
Alex Elder1f3ef782013-05-06 17:40:33 -0500414static int rbd_dev_image_probe(struct rbd_device *rbd_dev, bool mapping);
Alex Eldera2acd002013-05-08 22:50:04 -0500415static void rbd_spec_put(struct rbd_spec *spec);
Alex Elderf0f8cef2012-01-29 13:57:44 -0600416
Ilya Dryomov9b60e702013-12-13 15:28:57 +0200417static int rbd_dev_id_to_minor(int dev_id)
418{
Ilya Dryomov7e513d42013-12-16 19:26:32 +0200419 return dev_id << RBD_SINGLE_MAJOR_PART_SHIFT;
Ilya Dryomov9b60e702013-12-13 15:28:57 +0200420}
421
422static int minor_to_rbd_dev_id(int minor)
423{
Ilya Dryomov7e513d42013-12-16 19:26:32 +0200424 return minor >> RBD_SINGLE_MAJOR_PART_SHIFT;
Ilya Dryomov9b60e702013-12-13 15:28:57 +0200425}
426
Greg Kroah-Hartmanb15a21d2013-08-23 14:24:28 -0700427static BUS_ATTR(add, S_IWUSR, NULL, rbd_add);
428static BUS_ATTR(remove, S_IWUSR, NULL, rbd_remove);
Ilya Dryomov9b60e702013-12-13 15:28:57 +0200429static BUS_ATTR(add_single_major, S_IWUSR, NULL, rbd_add_single_major);
430static BUS_ATTR(remove_single_major, S_IWUSR, NULL, rbd_remove_single_major);
Greg Kroah-Hartmanb15a21d2013-08-23 14:24:28 -0700431
432static struct attribute *rbd_bus_attrs[] = {
433 &bus_attr_add.attr,
434 &bus_attr_remove.attr,
Ilya Dryomov9b60e702013-12-13 15:28:57 +0200435 &bus_attr_add_single_major.attr,
436 &bus_attr_remove_single_major.attr,
Greg Kroah-Hartmanb15a21d2013-08-23 14:24:28 -0700437 NULL,
Alex Elderf0f8cef2012-01-29 13:57:44 -0600438};
Ilya Dryomov92c76dc2013-12-13 15:28:57 +0200439
440static umode_t rbd_bus_is_visible(struct kobject *kobj,
441 struct attribute *attr, int index)
442{
Ilya Dryomov9b60e702013-12-13 15:28:57 +0200443 if (!single_major &&
444 (attr == &bus_attr_add_single_major.attr ||
445 attr == &bus_attr_remove_single_major.attr))
446 return 0;
447
Ilya Dryomov92c76dc2013-12-13 15:28:57 +0200448 return attr->mode;
449}
450
451static const struct attribute_group rbd_bus_group = {
452 .attrs = rbd_bus_attrs,
453 .is_visible = rbd_bus_is_visible,
454};
455__ATTRIBUTE_GROUPS(rbd_bus);
Alex Elderf0f8cef2012-01-29 13:57:44 -0600456
457static struct bus_type rbd_bus_type = {
458 .name = "rbd",
Greg Kroah-Hartmanb15a21d2013-08-23 14:24:28 -0700459 .bus_groups = rbd_bus_groups,
Alex Elderf0f8cef2012-01-29 13:57:44 -0600460};
461
462static void rbd_root_dev_release(struct device *dev)
463{
464}
465
466static struct device rbd_root_dev = {
467 .init_name = "rbd",
468 .release = rbd_root_dev_release,
469};
470
Alex Elder06ecc6c2012-11-01 10:17:15 -0500471static __printf(2, 3)
472void rbd_warn(struct rbd_device *rbd_dev, const char *fmt, ...)
473{
474 struct va_format vaf;
475 va_list args;
476
477 va_start(args, fmt);
478 vaf.fmt = fmt;
479 vaf.va = &args;
480
481 if (!rbd_dev)
482 printk(KERN_WARNING "%s: %pV\n", RBD_DRV_NAME, &vaf);
483 else if (rbd_dev->disk)
484 printk(KERN_WARNING "%s: %s: %pV\n",
485 RBD_DRV_NAME, rbd_dev->disk->disk_name, &vaf);
486 else if (rbd_dev->spec && rbd_dev->spec->image_name)
487 printk(KERN_WARNING "%s: image %s: %pV\n",
488 RBD_DRV_NAME, rbd_dev->spec->image_name, &vaf);
489 else if (rbd_dev->spec && rbd_dev->spec->image_id)
490 printk(KERN_WARNING "%s: id %s: %pV\n",
491 RBD_DRV_NAME, rbd_dev->spec->image_id, &vaf);
492 else /* punt */
493 printk(KERN_WARNING "%s: rbd_dev %p: %pV\n",
494 RBD_DRV_NAME, rbd_dev, &vaf);
495 va_end(args);
496}
497
Alex Elderaafb2302012-09-06 16:00:54 -0500498#ifdef RBD_DEBUG
499#define rbd_assert(expr) \
500 if (unlikely(!(expr))) { \
501 printk(KERN_ERR "\nAssertion failure in %s() " \
502 "at line %d:\n\n" \
503 "\trbd_assert(%s);\n\n", \
504 __func__, __LINE__, #expr); \
505 BUG(); \
506 }
507#else /* !RBD_DEBUG */
508# define rbd_assert(expr) ((void) 0)
509#endif /* !RBD_DEBUG */
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800510
Alex Elderb454e362013-04-19 15:34:50 -0500511static int rbd_img_obj_request_submit(struct rbd_obj_request *obj_request);
Alex Elder05a46af2013-04-26 15:44:36 -0500512static void rbd_img_parent_read(struct rbd_obj_request *obj_request);
513static void rbd_dev_remove_parent(struct rbd_device *rbd_dev);
Alex Elder8b3e1a52013-01-24 16:13:36 -0600514
Alex Eldercc4a38bd2013-04-30 00:44:33 -0500515static int rbd_dev_refresh(struct rbd_device *rbd_dev);
Alex Elder2df3fac2013-05-06 09:51:30 -0500516static int rbd_dev_v2_header_onetime(struct rbd_device *rbd_dev);
517static int rbd_dev_v2_header_info(struct rbd_device *rbd_dev);
Alex Elder54cac612013-04-30 00:44:33 -0500518static const char *rbd_dev_v2_snap_name(struct rbd_device *rbd_dev,
519 u64 snap_id);
Alex Elder2ad3d712013-04-30 00:44:33 -0500520static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
521 u8 *order, u64 *snap_size);
522static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
523 u64 *snap_features);
524static u64 rbd_snap_id_by_name(struct rbd_device *rbd_dev, const char *name);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700525
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700526static int rbd_open(struct block_device *bdev, fmode_t mode)
527{
Alex Elderf0f8cef2012-01-29 13:57:44 -0600528 struct rbd_device *rbd_dev = bdev->bd_disk->private_data;
Alex Elderb82d1672013-01-14 12:43:31 -0600529 bool removing = false;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700530
Alex Elderf84344f2012-08-31 17:29:51 -0500531 if ((mode & FMODE_WRITE) && rbd_dev->mapping.read_only)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700532 return -EROFS;
533
Alex Eldera14ea262013-02-05 13:23:12 -0600534 spin_lock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600535 if (test_bit(RBD_DEV_FLAG_REMOVING, &rbd_dev->flags))
536 removing = true;
537 else
538 rbd_dev->open_count++;
Alex Eldera14ea262013-02-05 13:23:12 -0600539 spin_unlock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600540 if (removing)
541 return -ENOENT;
542
Alex Elderc3e946c2012-11-16 09:29:16 -0600543 (void) get_device(&rbd_dev->dev);
Alex Elderf84344f2012-08-31 17:29:51 -0500544 set_device_ro(bdev, rbd_dev->mapping.read_only);
Alex Elder340c7a22012-08-10 13:12:07 -0700545
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700546 return 0;
547}
548
Al Virodb2a1442013-05-05 21:52:57 -0400549static void rbd_release(struct gendisk *disk, fmode_t mode)
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800550{
551 struct rbd_device *rbd_dev = disk->private_data;
Alex Elderb82d1672013-01-14 12:43:31 -0600552 unsigned long open_count_before;
553
Alex Eldera14ea262013-02-05 13:23:12 -0600554 spin_lock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600555 open_count_before = rbd_dev->open_count--;
Alex Eldera14ea262013-02-05 13:23:12 -0600556 spin_unlock_irq(&rbd_dev->lock);
Alex Elderb82d1672013-01-14 12:43:31 -0600557 rbd_assert(open_count_before > 0);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800558
Alex Elderc3e946c2012-11-16 09:29:16 -0600559 put_device(&rbd_dev->dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800560}
561
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700562static const struct block_device_operations rbd_bd_ops = {
563 .owner = THIS_MODULE,
564 .open = rbd_open,
Yehuda Sadehdfc56062010-11-19 14:51:04 -0800565 .release = rbd_release,
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700566};
567
568/*
Alex Elder7262cfc2013-05-16 15:04:20 -0500569 * Initialize an rbd client instance. Success or not, this function
Alex Eldercfbf6372013-05-31 17:40:45 -0500570 * consumes ceph_opts. Caller holds client_mutex.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700571 */
Alex Elderf8c38922012-08-10 13:12:07 -0700572static struct rbd_client *rbd_client_create(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700573{
574 struct rbd_client *rbdc;
575 int ret = -ENOMEM;
576
Alex Elder37206ee2013-02-20 17:32:08 -0600577 dout("%s:\n", __func__);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700578 rbdc = kmalloc(sizeof(struct rbd_client), GFP_KERNEL);
579 if (!rbdc)
580 goto out_opt;
581
582 kref_init(&rbdc->kref);
583 INIT_LIST_HEAD(&rbdc->node);
584
Alex Elder43ae4702012-07-03 16:01:18 -0500585 rbdc->client = ceph_create_client(ceph_opts, rbdc, 0, 0);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700586 if (IS_ERR(rbdc->client))
Alex Elder08f75462013-05-29 11:19:00 -0500587 goto out_rbdc;
Alex Elder43ae4702012-07-03 16:01:18 -0500588 ceph_opts = NULL; /* Now rbdc->client is responsible for ceph_opts */
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700589
590 ret = ceph_open_session(rbdc->client);
591 if (ret < 0)
Alex Elder08f75462013-05-29 11:19:00 -0500592 goto out_client;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700593
Alex Elder432b8582012-01-29 13:57:44 -0600594 spin_lock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700595 list_add_tail(&rbdc->node, &rbd_client_list);
Alex Elder432b8582012-01-29 13:57:44 -0600596 spin_unlock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700597
Alex Elder37206ee2013-02-20 17:32:08 -0600598 dout("%s: rbdc %p\n", __func__, rbdc);
Alex Elderbc534d82012-01-29 13:57:44 -0600599
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700600 return rbdc;
Alex Elder08f75462013-05-29 11:19:00 -0500601out_client:
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700602 ceph_destroy_client(rbdc->client);
Alex Elder08f75462013-05-29 11:19:00 -0500603out_rbdc:
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700604 kfree(rbdc);
605out_opt:
Alex Elder43ae4702012-07-03 16:01:18 -0500606 if (ceph_opts)
607 ceph_destroy_options(ceph_opts);
Alex Elder37206ee2013-02-20 17:32:08 -0600608 dout("%s: error %d\n", __func__, ret);
609
Vasiliy Kulikov28f259b2010-09-26 12:59:37 +0400610 return ERR_PTR(ret);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700611}
612
Alex Elder2f82ee52012-10-30 19:40:33 -0500613static struct rbd_client *__rbd_get_client(struct rbd_client *rbdc)
614{
615 kref_get(&rbdc->kref);
616
617 return rbdc;
618}
619
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700620/*
Alex Elder1f7ba332012-08-10 13:12:07 -0700621 * Find a ceph client with specific addr and configuration. If
622 * found, bump its reference count.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700623 */
Alex Elder1f7ba332012-08-10 13:12:07 -0700624static struct rbd_client *rbd_client_find(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700625{
626 struct rbd_client *client_node;
Alex Elder1f7ba332012-08-10 13:12:07 -0700627 bool found = false;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700628
Alex Elder43ae4702012-07-03 16:01:18 -0500629 if (ceph_opts->flags & CEPH_OPT_NOSHARE)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700630 return NULL;
631
Alex Elder1f7ba332012-08-10 13:12:07 -0700632 spin_lock(&rbd_client_list_lock);
633 list_for_each_entry(client_node, &rbd_client_list, node) {
634 if (!ceph_compare_options(ceph_opts, client_node->client)) {
Alex Elder2f82ee52012-10-30 19:40:33 -0500635 __rbd_get_client(client_node);
636
Alex Elder1f7ba332012-08-10 13:12:07 -0700637 found = true;
638 break;
639 }
640 }
641 spin_unlock(&rbd_client_list_lock);
642
643 return found ? client_node : NULL;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700644}
645
646/*
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700647 * mount options
648 */
649enum {
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700650 Opt_last_int,
651 /* int args above */
652 Opt_last_string,
653 /* string args above */
Alex Eldercc0538b2012-08-10 13:12:07 -0700654 Opt_read_only,
655 Opt_read_write,
656 /* Boolean args above */
657 Opt_last_bool,
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700658};
659
Alex Elder43ae4702012-07-03 16:01:18 -0500660static match_table_t rbd_opts_tokens = {
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700661 /* int args above */
662 /* string args above */
Alex Elderbe466c12012-10-22 11:31:26 -0500663 {Opt_read_only, "read_only"},
Alex Eldercc0538b2012-08-10 13:12:07 -0700664 {Opt_read_only, "ro"}, /* Alternate spelling */
665 {Opt_read_write, "read_write"},
666 {Opt_read_write, "rw"}, /* Alternate spelling */
667 /* Boolean args above */
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700668 {-1, NULL}
669};
670
Alex Elder98571b52013-01-20 14:44:42 -0600671struct rbd_options {
672 bool read_only;
673};
674
675#define RBD_READ_ONLY_DEFAULT false
676
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700677static int parse_rbd_opts_token(char *c, void *private)
678{
Alex Elder43ae4702012-07-03 16:01:18 -0500679 struct rbd_options *rbd_opts = private;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700680 substring_t argstr[MAX_OPT_ARGS];
681 int token, intval, ret;
682
Alex Elder43ae4702012-07-03 16:01:18 -0500683 token = match_token(c, rbd_opts_tokens, argstr);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700684 if (token < 0)
685 return -EINVAL;
686
687 if (token < Opt_last_int) {
688 ret = match_int(&argstr[0], &intval);
689 if (ret < 0) {
690 pr_err("bad mount option arg (not int) "
691 "at '%s'\n", c);
692 return ret;
693 }
694 dout("got int token %d val %d\n", token, intval);
695 } else if (token > Opt_last_int && token < Opt_last_string) {
696 dout("got string token %d val %s\n", token,
697 argstr[0].from);
Alex Eldercc0538b2012-08-10 13:12:07 -0700698 } else if (token > Opt_last_string && token < Opt_last_bool) {
699 dout("got Boolean token %d\n", token);
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700700 } else {
701 dout("got token %d\n", token);
702 }
703
704 switch (token) {
Alex Eldercc0538b2012-08-10 13:12:07 -0700705 case Opt_read_only:
706 rbd_opts->read_only = true;
707 break;
708 case Opt_read_write:
709 rbd_opts->read_only = false;
710 break;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700711 default:
Alex Elderaafb2302012-09-06 16:00:54 -0500712 rbd_assert(false);
713 break;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700714 }
715 return 0;
716}
717
718/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700719 * Get a ceph client with specific addr and configuration, if one does
Alex Elder7262cfc2013-05-16 15:04:20 -0500720 * not exist create it. Either way, ceph_opts is consumed by this
721 * function.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700722 */
Alex Elder9d3997f2012-10-25 23:34:42 -0500723static struct rbd_client *rbd_get_client(struct ceph_options *ceph_opts)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700724{
Alex Elderf8c38922012-08-10 13:12:07 -0700725 struct rbd_client *rbdc;
Yehuda Sadeh59c2be12011-03-21 15:10:11 -0700726
Alex Eldercfbf6372013-05-31 17:40:45 -0500727 mutex_lock_nested(&client_mutex, SINGLE_DEPTH_NESTING);
Alex Elder1f7ba332012-08-10 13:12:07 -0700728 rbdc = rbd_client_find(ceph_opts);
Alex Elder9d3997f2012-10-25 23:34:42 -0500729 if (rbdc) /* using an existing client */
Alex Elder43ae4702012-07-03 16:01:18 -0500730 ceph_destroy_options(ceph_opts);
Alex Elder9d3997f2012-10-25 23:34:42 -0500731 else
Alex Elderf8c38922012-08-10 13:12:07 -0700732 rbdc = rbd_client_create(ceph_opts);
Alex Eldercfbf6372013-05-31 17:40:45 -0500733 mutex_unlock(&client_mutex);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700734
Alex Elder9d3997f2012-10-25 23:34:42 -0500735 return rbdc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700736}
737
738/*
739 * Destroy ceph client
Alex Elderd23a4b32012-01-29 13:57:43 -0600740 *
Alex Elder432b8582012-01-29 13:57:44 -0600741 * Caller must hold rbd_client_list_lock.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700742 */
743static void rbd_client_release(struct kref *kref)
744{
745 struct rbd_client *rbdc = container_of(kref, struct rbd_client, kref);
746
Alex Elder37206ee2013-02-20 17:32:08 -0600747 dout("%s: rbdc %p\n", __func__, rbdc);
Alex Eldercd9d9f52012-04-04 13:35:44 -0500748 spin_lock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700749 list_del(&rbdc->node);
Alex Eldercd9d9f52012-04-04 13:35:44 -0500750 spin_unlock(&rbd_client_list_lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700751
752 ceph_destroy_client(rbdc->client);
753 kfree(rbdc);
754}
755
756/*
757 * Drop reference to ceph client node. If it's not referenced anymore, release
758 * it.
759 */
Alex Elder9d3997f2012-10-25 23:34:42 -0500760static void rbd_put_client(struct rbd_client *rbdc)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700761{
Alex Elderc53d5892012-10-25 23:34:42 -0500762 if (rbdc)
763 kref_put(&rbdc->kref, rbd_client_release);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700764}
765
Alex Eldera30b71b2012-07-10 20:30:11 -0500766static bool rbd_image_format_valid(u32 image_format)
767{
768 return image_format == 1 || image_format == 2;
769}
770
Alex Elder8e94af82012-07-25 09:32:40 -0500771static bool rbd_dev_ondisk_valid(struct rbd_image_header_ondisk *ondisk)
772{
Alex Elder103a1502012-08-02 11:29:45 -0500773 size_t size;
774 u32 snap_count;
775
776 /* The header has to start with the magic rbd header text */
777 if (memcmp(&ondisk->text, RBD_HEADER_TEXT, sizeof (RBD_HEADER_TEXT)))
778 return false;
779
Alex Elderdb2388b2012-10-20 22:17:27 -0500780 /* The bio layer requires at least sector-sized I/O */
781
782 if (ondisk->options.order < SECTOR_SHIFT)
783 return false;
784
785 /* If we use u64 in a few spots we may be able to loosen this */
786
787 if (ondisk->options.order > 8 * sizeof (int) - 1)
788 return false;
789
Alex Elder103a1502012-08-02 11:29:45 -0500790 /*
791 * The size of a snapshot header has to fit in a size_t, and
792 * that limits the number of snapshots.
793 */
794 snap_count = le32_to_cpu(ondisk->snap_count);
795 size = SIZE_MAX - sizeof (struct ceph_snap_context);
796 if (snap_count > size / sizeof (__le64))
797 return false;
798
799 /*
800 * Not only that, but the size of the entire the snapshot
801 * header must also be representable in a size_t.
802 */
803 size -= snap_count * sizeof (__le64);
804 if ((u64) size < le64_to_cpu(ondisk->snap_names_len))
805 return false;
806
807 return true;
Alex Elder8e94af82012-07-25 09:32:40 -0500808}
809
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700810/*
Alex Elderbb23e372013-05-06 09:51:29 -0500811 * Fill an rbd image header with information from the given format 1
812 * on-disk header.
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700813 */
Alex Elder662518b2013-05-06 09:51:29 -0500814static int rbd_header_from_disk(struct rbd_device *rbd_dev,
Alex Elder4156d9982012-08-02 11:29:46 -0500815 struct rbd_image_header_ondisk *ondisk)
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700816{
Alex Elder662518b2013-05-06 09:51:29 -0500817 struct rbd_image_header *header = &rbd_dev->header;
Alex Elderbb23e372013-05-06 09:51:29 -0500818 bool first_time = header->object_prefix == NULL;
819 struct ceph_snap_context *snapc;
820 char *object_prefix = NULL;
821 char *snap_names = NULL;
822 u64 *snap_sizes = NULL;
Alex Elderccece232012-07-10 20:30:10 -0500823 u32 snap_count;
Alex Elderd2bb24e2012-07-26 23:37:14 -0500824 size_t size;
Alex Elderbb23e372013-05-06 09:51:29 -0500825 int ret = -ENOMEM;
Alex Elder621901d2012-08-23 23:22:06 -0500826 u32 i;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700827
Alex Elderbb23e372013-05-06 09:51:29 -0500828 /* Allocate this now to avoid having to handle failure below */
829
830 if (first_time) {
831 size_t len;
832
833 len = strnlen(ondisk->object_prefix,
834 sizeof (ondisk->object_prefix));
835 object_prefix = kmalloc(len + 1, GFP_KERNEL);
836 if (!object_prefix)
837 return -ENOMEM;
838 memcpy(object_prefix, ondisk->object_prefix, len);
839 object_prefix[len] = '\0';
840 }
841
842 /* Allocate the snapshot context and fill it in */
Alex Elder6a523252012-07-19 17:12:59 -0500843
Alex Elder103a1502012-08-02 11:29:45 -0500844 snap_count = le32_to_cpu(ondisk->snap_count);
Alex Elderbb23e372013-05-06 09:51:29 -0500845 snapc = ceph_create_snap_context(snap_count, GFP_KERNEL);
846 if (!snapc)
847 goto out_err;
848 snapc->seq = le64_to_cpu(ondisk->snap_seq);
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700849 if (snap_count) {
Alex Elderbb23e372013-05-06 09:51:29 -0500850 struct rbd_image_snap_ondisk *snaps;
Alex Elderf785cc12012-08-23 23:22:06 -0500851 u64 snap_names_len = le64_to_cpu(ondisk->snap_names_len);
852
Alex Elderbb23e372013-05-06 09:51:29 -0500853 /* We'll keep a copy of the snapshot names... */
Alex Elder621901d2012-08-23 23:22:06 -0500854
Alex Elderbb23e372013-05-06 09:51:29 -0500855 if (snap_names_len > (u64)SIZE_MAX)
856 goto out_2big;
857 snap_names = kmalloc(snap_names_len, GFP_KERNEL);
858 if (!snap_names)
Alex Elder6a523252012-07-19 17:12:59 -0500859 goto out_err;
Alex Elderbb23e372013-05-06 09:51:29 -0500860
861 /* ...as well as the array of their sizes. */
862
863 size = snap_count * sizeof (*header->snap_sizes);
864 snap_sizes = kmalloc(size, GFP_KERNEL);
865 if (!snap_sizes)
866 goto out_err;
867
Alex Elderf785cc12012-08-23 23:22:06 -0500868 /*
Alex Elderbb23e372013-05-06 09:51:29 -0500869 * Copy the names, and fill in each snapshot's id
870 * and size.
871 *
Alex Elder99a41eb2013-05-06 09:51:30 -0500872 * Note that rbd_dev_v1_header_info() guarantees the
Alex Elderbb23e372013-05-06 09:51:29 -0500873 * ondisk buffer we're working with has
Alex Elderf785cc12012-08-23 23:22:06 -0500874 * snap_names_len bytes beyond the end of the
875 * snapshot id array, this memcpy() is safe.
876 */
Alex Elderbb23e372013-05-06 09:51:29 -0500877 memcpy(snap_names, &ondisk->snaps[snap_count], snap_names_len);
878 snaps = ondisk->snaps;
879 for (i = 0; i < snap_count; i++) {
880 snapc->snaps[i] = le64_to_cpu(snaps[i].id);
881 snap_sizes[i] = le64_to_cpu(snaps[i].image_size);
882 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700883 }
Alex Elder849b4262012-07-09 21:04:24 -0500884
Alex Elderbb23e372013-05-06 09:51:29 -0500885 /* We won't fail any more, fill in the header */
Alex Elder6a523252012-07-19 17:12:59 -0500886
Alex Elderbb23e372013-05-06 09:51:29 -0500887 if (first_time) {
888 header->object_prefix = object_prefix;
889 header->obj_order = ondisk->options.order;
890 header->crypt_type = ondisk->options.crypt_type;
891 header->comp_type = ondisk->options.comp_type;
892 /* The rest aren't used for format 1 images */
893 header->stripe_unit = 0;
894 header->stripe_count = 0;
895 header->features = 0;
Alex Elder662518b2013-05-06 09:51:29 -0500896 } else {
897 ceph_put_snap_context(header->snapc);
898 kfree(header->snap_names);
899 kfree(header->snap_sizes);
Alex Elderbb23e372013-05-06 09:51:29 -0500900 }
901
902 /* The remaining fields always get updated (when we refresh) */
Alex Elder621901d2012-08-23 23:22:06 -0500903
Alex Elderf84344f2012-08-31 17:29:51 -0500904 header->image_size = le64_to_cpu(ondisk->image_size);
Alex Elderbb23e372013-05-06 09:51:29 -0500905 header->snapc = snapc;
906 header->snap_names = snap_names;
907 header->snap_sizes = snap_sizes;
Alex Elder468521c2013-04-26 09:43:47 -0500908
Alex Elder662518b2013-05-06 09:51:29 -0500909 /* Make sure mapping size is consistent with header info */
910
911 if (rbd_dev->spec->snap_id == CEPH_NOSNAP || first_time)
912 if (rbd_dev->mapping.size != header->image_size)
913 rbd_dev->mapping.size = header->image_size;
914
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700915 return 0;
Alex Elderbb23e372013-05-06 09:51:29 -0500916out_2big:
917 ret = -EIO;
Alex Elder6a523252012-07-19 17:12:59 -0500918out_err:
Alex Elderbb23e372013-05-06 09:51:29 -0500919 kfree(snap_sizes);
920 kfree(snap_names);
921 ceph_put_snap_context(snapc);
922 kfree(object_prefix);
Alex Elderccece232012-07-10 20:30:10 -0500923
Alex Elderbb23e372013-05-06 09:51:29 -0500924 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -0700925}
926
Alex Elder9682fc62013-04-30 00:44:33 -0500927static const char *_rbd_dev_v1_snap_name(struct rbd_device *rbd_dev, u32 which)
928{
929 const char *snap_name;
930
931 rbd_assert(which < rbd_dev->header.snapc->num_snaps);
932
933 /* Skip over names until we find the one we are looking for */
934
935 snap_name = rbd_dev->header.snap_names;
936 while (which--)
937 snap_name += strlen(snap_name) + 1;
938
939 return kstrdup(snap_name, GFP_KERNEL);
940}
941
Alex Elder30d1cff2013-05-01 12:43:03 -0500942/*
943 * Snapshot id comparison function for use with qsort()/bsearch().
944 * Note that result is for snapshots in *descending* order.
945 */
946static int snapid_compare_reverse(const void *s1, const void *s2)
947{
948 u64 snap_id1 = *(u64 *)s1;
949 u64 snap_id2 = *(u64 *)s2;
950
951 if (snap_id1 < snap_id2)
952 return 1;
953 return snap_id1 == snap_id2 ? 0 : -1;
954}
955
956/*
957 * Search a snapshot context to see if the given snapshot id is
958 * present.
959 *
960 * Returns the position of the snapshot id in the array if it's found,
961 * or BAD_SNAP_INDEX otherwise.
962 *
963 * Note: The snapshot array is in kept sorted (by the osd) in
964 * reverse order, highest snapshot id first.
965 */
Alex Elder9682fc62013-04-30 00:44:33 -0500966static u32 rbd_dev_snap_index(struct rbd_device *rbd_dev, u64 snap_id)
967{
968 struct ceph_snap_context *snapc = rbd_dev->header.snapc;
Alex Elder30d1cff2013-05-01 12:43:03 -0500969 u64 *found;
Alex Elder9682fc62013-04-30 00:44:33 -0500970
Alex Elder30d1cff2013-05-01 12:43:03 -0500971 found = bsearch(&snap_id, &snapc->snaps, snapc->num_snaps,
972 sizeof (snap_id), snapid_compare_reverse);
Alex Elder9682fc62013-04-30 00:44:33 -0500973
Alex Elder30d1cff2013-05-01 12:43:03 -0500974 return found ? (u32)(found - &snapc->snaps[0]) : BAD_SNAP_INDEX;
Alex Elder9682fc62013-04-30 00:44:33 -0500975}
976
Alex Elder2ad3d712013-04-30 00:44:33 -0500977static const char *rbd_dev_v1_snap_name(struct rbd_device *rbd_dev,
978 u64 snap_id)
Alex Elder54cac612013-04-30 00:44:33 -0500979{
980 u32 which;
Josh Durginda6a6b62013-09-04 17:57:31 -0700981 const char *snap_name;
Alex Elder54cac612013-04-30 00:44:33 -0500982
983 which = rbd_dev_snap_index(rbd_dev, snap_id);
984 if (which == BAD_SNAP_INDEX)
Josh Durginda6a6b62013-09-04 17:57:31 -0700985 return ERR_PTR(-ENOENT);
Alex Elder54cac612013-04-30 00:44:33 -0500986
Josh Durginda6a6b62013-09-04 17:57:31 -0700987 snap_name = _rbd_dev_v1_snap_name(rbd_dev, which);
988 return snap_name ? snap_name : ERR_PTR(-ENOMEM);
Alex Elder54cac612013-04-30 00:44:33 -0500989}
990
Alex Elder9e15b772012-10-30 19:40:33 -0500991static const char *rbd_snap_name(struct rbd_device *rbd_dev, u64 snap_id)
992{
Alex Elder9e15b772012-10-30 19:40:33 -0500993 if (snap_id == CEPH_NOSNAP)
994 return RBD_SNAP_HEAD_NAME;
995
Alex Elder54cac612013-04-30 00:44:33 -0500996 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
997 if (rbd_dev->image_format == 1)
998 return rbd_dev_v1_snap_name(rbd_dev, snap_id);
Alex Elder9e15b772012-10-30 19:40:33 -0500999
Alex Elder54cac612013-04-30 00:44:33 -05001000 return rbd_dev_v2_snap_name(rbd_dev, snap_id);
Alex Elder9e15b772012-10-30 19:40:33 -05001001}
1002
Alex Elder2ad3d712013-04-30 00:44:33 -05001003static int rbd_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
1004 u64 *snap_size)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001005{
Alex Elder2ad3d712013-04-30 00:44:33 -05001006 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
1007 if (snap_id == CEPH_NOSNAP) {
1008 *snap_size = rbd_dev->header.image_size;
1009 } else if (rbd_dev->image_format == 1) {
1010 u32 which;
Alex Elder00f1f362012-02-07 12:03:36 -06001011
Alex Elder2ad3d712013-04-30 00:44:33 -05001012 which = rbd_dev_snap_index(rbd_dev, snap_id);
1013 if (which == BAD_SNAP_INDEX)
1014 return -ENOENT;
Alex Elder00f1f362012-02-07 12:03:36 -06001015
Alex Elder2ad3d712013-04-30 00:44:33 -05001016 *snap_size = rbd_dev->header.snap_sizes[which];
1017 } else {
1018 u64 size = 0;
1019 int ret;
1020
1021 ret = _rbd_dev_v2_snap_size(rbd_dev, snap_id, NULL, &size);
1022 if (ret)
1023 return ret;
1024
1025 *snap_size = size;
1026 }
1027 return 0;
1028}
1029
1030static int rbd_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
1031 u64 *snap_features)
1032{
1033 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
1034 if (snap_id == CEPH_NOSNAP) {
1035 *snap_features = rbd_dev->header.features;
1036 } else if (rbd_dev->image_format == 1) {
1037 *snap_features = 0; /* No features for format 1 */
1038 } else {
1039 u64 features = 0;
1040 int ret;
1041
1042 ret = _rbd_dev_v2_snap_features(rbd_dev, snap_id, &features);
1043 if (ret)
1044 return ret;
1045
1046 *snap_features = features;
1047 }
1048 return 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001049}
1050
Alex Elderd1cf5782013-04-27 09:59:30 -05001051static int rbd_dev_mapping_set(struct rbd_device *rbd_dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001052{
Alex Elder8f4b7d92013-05-06 07:40:30 -05001053 u64 snap_id = rbd_dev->spec->snap_id;
Alex Elder2ad3d712013-04-30 00:44:33 -05001054 u64 size = 0;
1055 u64 features = 0;
1056 int ret;
Alex Elder8b0241f2013-04-25 23:15:08 -05001057
Alex Elder2ad3d712013-04-30 00:44:33 -05001058 ret = rbd_snap_size(rbd_dev, snap_id, &size);
1059 if (ret)
1060 return ret;
1061 ret = rbd_snap_features(rbd_dev, snap_id, &features);
1062 if (ret)
1063 return ret;
1064
1065 rbd_dev->mapping.size = size;
1066 rbd_dev->mapping.features = features;
1067
Alex Elder8b0241f2013-04-25 23:15:08 -05001068 return 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001069}
1070
Alex Elderd1cf5782013-04-27 09:59:30 -05001071static void rbd_dev_mapping_clear(struct rbd_device *rbd_dev)
1072{
1073 rbd_dev->mapping.size = 0;
1074 rbd_dev->mapping.features = 0;
Alex Elder200a6a82013-04-28 23:32:34 -05001075}
1076
Alex Elder98571b52013-01-20 14:44:42 -06001077static const char *rbd_segment_name(struct rbd_device *rbd_dev, u64 offset)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001078{
Alex Elder65ccfe22012-08-09 10:33:26 -07001079 char *name;
1080 u64 segment;
1081 int ret;
Josh Durgin3a96d5c2013-06-12 19:15:06 -07001082 char *name_format;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001083
Alex Elder78c2a442013-05-01 12:43:04 -05001084 name = kmem_cache_alloc(rbd_segment_name_cache, GFP_NOIO);
Alex Elder65ccfe22012-08-09 10:33:26 -07001085 if (!name)
1086 return NULL;
1087 segment = offset >> rbd_dev->header.obj_order;
Josh Durgin3a96d5c2013-06-12 19:15:06 -07001088 name_format = "%s.%012llx";
1089 if (rbd_dev->image_format == 2)
1090 name_format = "%s.%016llx";
Ilya Dryomov2d0ebc52014-01-27 17:40:18 +02001091 ret = snprintf(name, CEPH_MAX_OID_NAME_LEN + 1, name_format,
Alex Elder65ccfe22012-08-09 10:33:26 -07001092 rbd_dev->header.object_prefix, segment);
Ilya Dryomov2d0ebc52014-01-27 17:40:18 +02001093 if (ret < 0 || ret > CEPH_MAX_OID_NAME_LEN) {
Alex Elder65ccfe22012-08-09 10:33:26 -07001094 pr_err("error formatting segment name for #%llu (%d)\n",
1095 segment, ret);
1096 kfree(name);
1097 name = NULL;
1098 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001099
Alex Elder65ccfe22012-08-09 10:33:26 -07001100 return name;
1101}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001102
Alex Elder78c2a442013-05-01 12:43:04 -05001103static void rbd_segment_name_free(const char *name)
1104{
1105 /* The explicit cast here is needed to drop the const qualifier */
1106
1107 kmem_cache_free(rbd_segment_name_cache, (void *)name);
1108}
1109
Alex Elder65ccfe22012-08-09 10:33:26 -07001110static u64 rbd_segment_offset(struct rbd_device *rbd_dev, u64 offset)
1111{
1112 u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001113
Alex Elder65ccfe22012-08-09 10:33:26 -07001114 return offset & (segment_size - 1);
1115}
1116
1117static u64 rbd_segment_length(struct rbd_device *rbd_dev,
1118 u64 offset, u64 length)
1119{
1120 u64 segment_size = (u64) 1 << rbd_dev->header.obj_order;
1121
1122 offset &= segment_size - 1;
1123
Alex Elderaafb2302012-09-06 16:00:54 -05001124 rbd_assert(length <= U64_MAX - offset);
Alex Elder65ccfe22012-08-09 10:33:26 -07001125 if (offset + length > segment_size)
1126 length = segment_size - offset;
1127
1128 return length;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001129}
1130
1131/*
Josh Durgin029bcbd2011-07-22 11:35:23 -07001132 * returns the size of an object in the image
1133 */
1134static u64 rbd_obj_bytes(struct rbd_image_header *header)
1135{
1136 return 1 << header->obj_order;
1137}
1138
1139/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001140 * bio helpers
1141 */
1142
1143static void bio_chain_put(struct bio *chain)
1144{
1145 struct bio *tmp;
1146
1147 while (chain) {
1148 tmp = chain;
1149 chain = chain->bi_next;
1150 bio_put(tmp);
1151 }
1152}
1153
1154/*
1155 * zeros a bio chain, starting at specific offset
1156 */
1157static void zero_bio_chain(struct bio *chain, int start_ofs)
1158{
Kent Overstreet79886132013-11-23 17:19:00 -08001159 struct bio_vec bv;
1160 struct bvec_iter iter;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001161 unsigned long flags;
1162 void *buf;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001163 int pos = 0;
1164
1165 while (chain) {
Kent Overstreet79886132013-11-23 17:19:00 -08001166 bio_for_each_segment(bv, chain, iter) {
1167 if (pos + bv.bv_len > start_ofs) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001168 int remainder = max(start_ofs - pos, 0);
Kent Overstreet79886132013-11-23 17:19:00 -08001169 buf = bvec_kmap_irq(&bv, &flags);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001170 memset(buf + remainder, 0,
Kent Overstreet79886132013-11-23 17:19:00 -08001171 bv.bv_len - remainder);
1172 flush_dcache_page(bv.bv_page);
Dan Carpenter85b5aaa2010-10-11 21:15:11 +02001173 bvec_kunmap_irq(buf, &flags);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001174 }
Kent Overstreet79886132013-11-23 17:19:00 -08001175 pos += bv.bv_len;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001176 }
1177
1178 chain = chain->bi_next;
1179 }
1180}
1181
1182/*
Alex Elderb9434c52013-04-19 15:34:50 -05001183 * similar to zero_bio_chain(), zeros data defined by a page array,
1184 * starting at the given byte offset from the start of the array and
1185 * continuing up to the given end offset. The pages array is
1186 * assumed to be big enough to hold all bytes up to the end.
1187 */
1188static void zero_pages(struct page **pages, u64 offset, u64 end)
1189{
1190 struct page **page = &pages[offset >> PAGE_SHIFT];
1191
1192 rbd_assert(end > offset);
1193 rbd_assert(end - offset <= (u64)SIZE_MAX);
1194 while (offset < end) {
1195 size_t page_offset;
1196 size_t length;
1197 unsigned long flags;
1198 void *kaddr;
1199
Geert Uytterhoeven491205a2013-05-13 20:35:37 -05001200 page_offset = offset & ~PAGE_MASK;
1201 length = min_t(size_t, PAGE_SIZE - page_offset, end - offset);
Alex Elderb9434c52013-04-19 15:34:50 -05001202 local_irq_save(flags);
1203 kaddr = kmap_atomic(*page);
1204 memset(kaddr + page_offset, 0, length);
Alex Eldere2156052013-05-22 20:54:25 -05001205 flush_dcache_page(*page);
Alex Elderb9434c52013-04-19 15:34:50 -05001206 kunmap_atomic(kaddr);
1207 local_irq_restore(flags);
1208
1209 offset += length;
1210 page++;
1211 }
1212}
1213
1214/*
Alex Elderf7760da2012-10-20 22:17:27 -05001215 * Clone a portion of a bio, starting at the given byte offset
1216 * and continuing for the number of bytes indicated.
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001217 */
Alex Elderf7760da2012-10-20 22:17:27 -05001218static struct bio *bio_clone_range(struct bio *bio_src,
1219 unsigned int offset,
1220 unsigned int len,
1221 gfp_t gfpmask)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001222{
Alex Elderf7760da2012-10-20 22:17:27 -05001223 struct bio *bio;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001224
Kent Overstreet5341a622013-08-07 14:31:11 -07001225 bio = bio_clone(bio_src, gfpmask);
Alex Elderf7760da2012-10-20 22:17:27 -05001226 if (!bio)
1227 return NULL; /* ENOMEM */
1228
Kent Overstreet5341a622013-08-07 14:31:11 -07001229 bio_advance(bio, offset);
Kent Overstreet4f024f32013-10-11 15:44:27 -07001230 bio->bi_iter.bi_size = len;
Alex Elder542582f2012-08-09 10:33:25 -07001231
Alex Elderf7760da2012-10-20 22:17:27 -05001232 return bio;
1233}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001234
Alex Elderf7760da2012-10-20 22:17:27 -05001235/*
1236 * Clone a portion of a bio chain, starting at the given byte offset
1237 * into the first bio in the source chain and continuing for the
1238 * number of bytes indicated. The result is another bio chain of
1239 * exactly the given length, or a null pointer on error.
1240 *
1241 * The bio_src and offset parameters are both in-out. On entry they
1242 * refer to the first source bio and the offset into that bio where
1243 * the start of data to be cloned is located.
1244 *
1245 * On return, bio_src is updated to refer to the bio in the source
1246 * chain that contains first un-cloned byte, and *offset will
1247 * contain the offset of that byte within that bio.
1248 */
1249static struct bio *bio_chain_clone_range(struct bio **bio_src,
1250 unsigned int *offset,
1251 unsigned int len,
1252 gfp_t gfpmask)
1253{
1254 struct bio *bi = *bio_src;
1255 unsigned int off = *offset;
1256 struct bio *chain = NULL;
1257 struct bio **end;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001258
Alex Elderf7760da2012-10-20 22:17:27 -05001259 /* Build up a chain of clone bios up to the limit */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001260
Kent Overstreet4f024f32013-10-11 15:44:27 -07001261 if (!bi || off >= bi->bi_iter.bi_size || !len)
Alex Elderf7760da2012-10-20 22:17:27 -05001262 return NULL; /* Nothing to clone */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001263
Alex Elderf7760da2012-10-20 22:17:27 -05001264 end = &chain;
1265 while (len) {
1266 unsigned int bi_size;
1267 struct bio *bio;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001268
Alex Elderf5400b72012-11-01 10:17:15 -05001269 if (!bi) {
1270 rbd_warn(NULL, "bio_chain exhausted with %u left", len);
Alex Elderf7760da2012-10-20 22:17:27 -05001271 goto out_err; /* EINVAL; ran out of bio's */
Alex Elderf5400b72012-11-01 10:17:15 -05001272 }
Kent Overstreet4f024f32013-10-11 15:44:27 -07001273 bi_size = min_t(unsigned int, bi->bi_iter.bi_size - off, len);
Alex Elderf7760da2012-10-20 22:17:27 -05001274 bio = bio_clone_range(bi, off, bi_size, gfpmask);
1275 if (!bio)
1276 goto out_err; /* ENOMEM */
1277
1278 *end = bio;
1279 end = &bio->bi_next;
1280
1281 off += bi_size;
Kent Overstreet4f024f32013-10-11 15:44:27 -07001282 if (off == bi->bi_iter.bi_size) {
Alex Elderf7760da2012-10-20 22:17:27 -05001283 bi = bi->bi_next;
1284 off = 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001285 }
Alex Elderf7760da2012-10-20 22:17:27 -05001286 len -= bi_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001287 }
Alex Elderf7760da2012-10-20 22:17:27 -05001288 *bio_src = bi;
1289 *offset = off;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001290
Alex Elderf7760da2012-10-20 22:17:27 -05001291 return chain;
1292out_err:
1293 bio_chain_put(chain);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001294
Yehuda Sadeh602adf42010-08-12 16:11:25 -07001295 return NULL;
1296}
1297
Alex Elder926f9b32013-02-11 12:33:24 -06001298/*
1299 * The default/initial value for all object request flags is 0. For
1300 * each flag, once its value is set to 1 it is never reset to 0
1301 * again.
1302 */
Alex Elder6365d332013-02-11 12:33:24 -06001303static void obj_request_img_data_set(struct rbd_obj_request *obj_request)
1304{
1305 if (test_and_set_bit(OBJ_REQ_IMG_DATA, &obj_request->flags)) {
Alex Elder6365d332013-02-11 12:33:24 -06001306 struct rbd_device *rbd_dev;
1307
Alex Elder57acbaa2013-02-11 12:33:24 -06001308 rbd_dev = obj_request->img_request->rbd_dev;
Alex Elder6365d332013-02-11 12:33:24 -06001309 rbd_warn(rbd_dev, "obj_request %p already marked img_data\n",
1310 obj_request);
1311 }
1312}
1313
1314static bool obj_request_img_data_test(struct rbd_obj_request *obj_request)
1315{
1316 smp_mb();
1317 return test_bit(OBJ_REQ_IMG_DATA, &obj_request->flags) != 0;
1318}
1319
Alex Elder57acbaa2013-02-11 12:33:24 -06001320static void obj_request_done_set(struct rbd_obj_request *obj_request)
1321{
1322 if (test_and_set_bit(OBJ_REQ_DONE, &obj_request->flags)) {
1323 struct rbd_device *rbd_dev = NULL;
1324
1325 if (obj_request_img_data_test(obj_request))
1326 rbd_dev = obj_request->img_request->rbd_dev;
1327 rbd_warn(rbd_dev, "obj_request %p already marked done\n",
1328 obj_request);
1329 }
1330}
1331
1332static bool obj_request_done_test(struct rbd_obj_request *obj_request)
1333{
1334 smp_mb();
1335 return test_bit(OBJ_REQ_DONE, &obj_request->flags) != 0;
1336}
1337
Alex Elder5679c592013-02-11 12:33:24 -06001338/*
1339 * This sets the KNOWN flag after (possibly) setting the EXISTS
1340 * flag. The latter is set based on the "exists" value provided.
1341 *
1342 * Note that for our purposes once an object exists it never goes
1343 * away again. It's possible that the response from two existence
1344 * checks are separated by the creation of the target object, and
1345 * the first ("doesn't exist") response arrives *after* the second
1346 * ("does exist"). In that case we ignore the second one.
1347 */
1348static void obj_request_existence_set(struct rbd_obj_request *obj_request,
1349 bool exists)
1350{
1351 if (exists)
1352 set_bit(OBJ_REQ_EXISTS, &obj_request->flags);
1353 set_bit(OBJ_REQ_KNOWN, &obj_request->flags);
1354 smp_mb();
1355}
1356
1357static bool obj_request_known_test(struct rbd_obj_request *obj_request)
1358{
1359 smp_mb();
1360 return test_bit(OBJ_REQ_KNOWN, &obj_request->flags) != 0;
1361}
1362
1363static bool obj_request_exists_test(struct rbd_obj_request *obj_request)
1364{
1365 smp_mb();
1366 return test_bit(OBJ_REQ_EXISTS, &obj_request->flags) != 0;
1367}
1368
Alex Elderbf0d5f502012-11-22 00:00:08 -06001369static void rbd_obj_request_get(struct rbd_obj_request *obj_request)
1370{
Alex Elder37206ee2013-02-20 17:32:08 -06001371 dout("%s: obj %p (was %d)\n", __func__, obj_request,
1372 atomic_read(&obj_request->kref.refcount));
Alex Elderbf0d5f502012-11-22 00:00:08 -06001373 kref_get(&obj_request->kref);
1374}
1375
1376static void rbd_obj_request_destroy(struct kref *kref);
1377static void rbd_obj_request_put(struct rbd_obj_request *obj_request)
1378{
1379 rbd_assert(obj_request != NULL);
Alex Elder37206ee2013-02-20 17:32:08 -06001380 dout("%s: obj %p (was %d)\n", __func__, obj_request,
1381 atomic_read(&obj_request->kref.refcount));
Alex Elderbf0d5f502012-11-22 00:00:08 -06001382 kref_put(&obj_request->kref, rbd_obj_request_destroy);
1383}
1384
Alex Eldere93f3152013-05-08 22:50:04 -05001385static bool img_request_child_test(struct rbd_img_request *img_request);
1386static void rbd_parent_request_destroy(struct kref *kref);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001387static void rbd_img_request_destroy(struct kref *kref);
1388static void rbd_img_request_put(struct rbd_img_request *img_request)
1389{
1390 rbd_assert(img_request != NULL);
Alex Elder37206ee2013-02-20 17:32:08 -06001391 dout("%s: img %p (was %d)\n", __func__, img_request,
1392 atomic_read(&img_request->kref.refcount));
Alex Eldere93f3152013-05-08 22:50:04 -05001393 if (img_request_child_test(img_request))
1394 kref_put(&img_request->kref, rbd_parent_request_destroy);
1395 else
1396 kref_put(&img_request->kref, rbd_img_request_destroy);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001397}
1398
1399static inline void rbd_img_obj_request_add(struct rbd_img_request *img_request,
1400 struct rbd_obj_request *obj_request)
1401{
Alex Elder25dcf952013-01-25 17:08:55 -06001402 rbd_assert(obj_request->img_request == NULL);
1403
Alex Elderb155e862013-04-15 14:50:37 -05001404 /* Image request now owns object's original reference */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001405 obj_request->img_request = img_request;
Alex Elder25dcf952013-01-25 17:08:55 -06001406 obj_request->which = img_request->obj_request_count;
Alex Elder6365d332013-02-11 12:33:24 -06001407 rbd_assert(!obj_request_img_data_test(obj_request));
1408 obj_request_img_data_set(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001409 rbd_assert(obj_request->which != BAD_WHICH);
Alex Elder25dcf952013-01-25 17:08:55 -06001410 img_request->obj_request_count++;
1411 list_add_tail(&obj_request->links, &img_request->obj_requests);
Alex Elder37206ee2013-02-20 17:32:08 -06001412 dout("%s: img %p obj %p w=%u\n", __func__, img_request, obj_request,
1413 obj_request->which);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001414}
1415
1416static inline void rbd_img_obj_request_del(struct rbd_img_request *img_request,
1417 struct rbd_obj_request *obj_request)
1418{
1419 rbd_assert(obj_request->which != BAD_WHICH);
Alex Elder25dcf952013-01-25 17:08:55 -06001420
Alex Elder37206ee2013-02-20 17:32:08 -06001421 dout("%s: img %p obj %p w=%u\n", __func__, img_request, obj_request,
1422 obj_request->which);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001423 list_del(&obj_request->links);
Alex Elder25dcf952013-01-25 17:08:55 -06001424 rbd_assert(img_request->obj_request_count > 0);
1425 img_request->obj_request_count--;
1426 rbd_assert(obj_request->which == img_request->obj_request_count);
1427 obj_request->which = BAD_WHICH;
Alex Elder6365d332013-02-11 12:33:24 -06001428 rbd_assert(obj_request_img_data_test(obj_request));
Alex Elderbf0d5f502012-11-22 00:00:08 -06001429 rbd_assert(obj_request->img_request == img_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001430 obj_request->img_request = NULL;
Alex Elder25dcf952013-01-25 17:08:55 -06001431 obj_request->callback = NULL;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001432 rbd_obj_request_put(obj_request);
1433}
1434
1435static bool obj_request_type_valid(enum obj_request_type type)
1436{
1437 switch (type) {
Alex Elder9969ebc2013-01-18 12:31:10 -06001438 case OBJ_REQUEST_NODATA:
Alex Elderbf0d5f502012-11-22 00:00:08 -06001439 case OBJ_REQUEST_BIO:
Alex Elder788e2df2013-01-17 12:25:27 -06001440 case OBJ_REQUEST_PAGES:
Alex Elderbf0d5f502012-11-22 00:00:08 -06001441 return true;
1442 default:
1443 return false;
1444 }
1445}
1446
Alex Elderbf0d5f502012-11-22 00:00:08 -06001447static int rbd_obj_request_submit(struct ceph_osd_client *osdc,
1448 struct rbd_obj_request *obj_request)
1449{
Alex Elder37206ee2013-02-20 17:32:08 -06001450 dout("%s: osdc %p obj %p\n", __func__, osdc, obj_request);
1451
Alex Elderbf0d5f502012-11-22 00:00:08 -06001452 return ceph_osdc_start_request(osdc, obj_request->osd_req, false);
1453}
1454
1455static void rbd_img_request_complete(struct rbd_img_request *img_request)
1456{
Alex Elder55f27e02013-04-10 12:34:25 -05001457
Alex Elder37206ee2013-02-20 17:32:08 -06001458 dout("%s: img %p\n", __func__, img_request);
Alex Elder55f27e02013-04-10 12:34:25 -05001459
1460 /*
1461 * If no error occurred, compute the aggregate transfer
1462 * count for the image request. We could instead use
1463 * atomic64_cmpxchg() to update it as each object request
1464 * completes; not clear which way is better off hand.
1465 */
1466 if (!img_request->result) {
1467 struct rbd_obj_request *obj_request;
1468 u64 xferred = 0;
1469
1470 for_each_obj_request(img_request, obj_request)
1471 xferred += obj_request->xferred;
1472 img_request->xferred = xferred;
1473 }
1474
Alex Elderbf0d5f502012-11-22 00:00:08 -06001475 if (img_request->callback)
1476 img_request->callback(img_request);
1477 else
1478 rbd_img_request_put(img_request);
1479}
1480
Alex Elder788e2df2013-01-17 12:25:27 -06001481/* Caller is responsible for rbd_obj_request_destroy(obj_request) */
1482
1483static int rbd_obj_request_wait(struct rbd_obj_request *obj_request)
1484{
Alex Elder37206ee2013-02-20 17:32:08 -06001485 dout("%s: obj %p\n", __func__, obj_request);
1486
Alex Elder788e2df2013-01-17 12:25:27 -06001487 return wait_for_completion_interruptible(&obj_request->completion);
1488}
1489
Alex Elder0c425242013-02-08 09:55:49 -06001490/*
1491 * The default/initial value for all image request flags is 0. Each
1492 * is conditionally set to 1 at image request initialization time
1493 * and currently never change thereafter.
1494 */
1495static void img_request_write_set(struct rbd_img_request *img_request)
1496{
1497 set_bit(IMG_REQ_WRITE, &img_request->flags);
1498 smp_mb();
1499}
1500
1501static bool img_request_write_test(struct rbd_img_request *img_request)
1502{
1503 smp_mb();
1504 return test_bit(IMG_REQ_WRITE, &img_request->flags) != 0;
1505}
1506
Alex Elder9849e982013-01-24 16:13:36 -06001507static void img_request_child_set(struct rbd_img_request *img_request)
1508{
1509 set_bit(IMG_REQ_CHILD, &img_request->flags);
1510 smp_mb();
1511}
1512
Alex Eldere93f3152013-05-08 22:50:04 -05001513static void img_request_child_clear(struct rbd_img_request *img_request)
1514{
1515 clear_bit(IMG_REQ_CHILD, &img_request->flags);
1516 smp_mb();
1517}
1518
Alex Elder9849e982013-01-24 16:13:36 -06001519static bool img_request_child_test(struct rbd_img_request *img_request)
1520{
1521 smp_mb();
1522 return test_bit(IMG_REQ_CHILD, &img_request->flags) != 0;
1523}
1524
Alex Elderd0b2e942013-01-24 16:13:36 -06001525static void img_request_layered_set(struct rbd_img_request *img_request)
1526{
1527 set_bit(IMG_REQ_LAYERED, &img_request->flags);
1528 smp_mb();
1529}
1530
Alex Eldera2acd002013-05-08 22:50:04 -05001531static void img_request_layered_clear(struct rbd_img_request *img_request)
1532{
1533 clear_bit(IMG_REQ_LAYERED, &img_request->flags);
1534 smp_mb();
1535}
1536
Alex Elderd0b2e942013-01-24 16:13:36 -06001537static bool img_request_layered_test(struct rbd_img_request *img_request)
1538{
1539 smp_mb();
1540 return test_bit(IMG_REQ_LAYERED, &img_request->flags) != 0;
1541}
1542
Alex Elder6e2a4502013-03-27 09:16:30 -05001543static void
1544rbd_img_obj_request_read_callback(struct rbd_obj_request *obj_request)
1545{
Alex Elderb9434c52013-04-19 15:34:50 -05001546 u64 xferred = obj_request->xferred;
1547 u64 length = obj_request->length;
1548
Alex Elder6e2a4502013-03-27 09:16:30 -05001549 dout("%s: obj %p img %p result %d %llu/%llu\n", __func__,
1550 obj_request, obj_request->img_request, obj_request->result,
Alex Elderb9434c52013-04-19 15:34:50 -05001551 xferred, length);
Alex Elder6e2a4502013-03-27 09:16:30 -05001552 /*
Josh Durgin17c1cc12013-08-26 17:55:38 -07001553 * ENOENT means a hole in the image. We zero-fill the entire
1554 * length of the request. A short read also implies zero-fill
1555 * to the end of the request. An error requires the whole
1556 * length of the request to be reported finished with an error
1557 * to the block layer. In each case we update the xferred
1558 * count to indicate the whole request was satisfied.
Alex Elder6e2a4502013-03-27 09:16:30 -05001559 */
Alex Elderb9434c52013-04-19 15:34:50 -05001560 rbd_assert(obj_request->type != OBJ_REQUEST_NODATA);
Alex Elder6e2a4502013-03-27 09:16:30 -05001561 if (obj_request->result == -ENOENT) {
Alex Elderb9434c52013-04-19 15:34:50 -05001562 if (obj_request->type == OBJ_REQUEST_BIO)
1563 zero_bio_chain(obj_request->bio_list, 0);
1564 else
1565 zero_pages(obj_request->pages, 0, length);
Alex Elder6e2a4502013-03-27 09:16:30 -05001566 obj_request->result = 0;
Alex Elderb9434c52013-04-19 15:34:50 -05001567 } else if (xferred < length && !obj_request->result) {
1568 if (obj_request->type == OBJ_REQUEST_BIO)
1569 zero_bio_chain(obj_request->bio_list, xferred);
1570 else
1571 zero_pages(obj_request->pages, xferred, length);
Alex Elder6e2a4502013-03-27 09:16:30 -05001572 }
Josh Durgin17c1cc12013-08-26 17:55:38 -07001573 obj_request->xferred = length;
Alex Elder6e2a4502013-03-27 09:16:30 -05001574 obj_request_done_set(obj_request);
1575}
1576
Alex Elderbf0d5f502012-11-22 00:00:08 -06001577static void rbd_obj_request_complete(struct rbd_obj_request *obj_request)
1578{
Alex Elder37206ee2013-02-20 17:32:08 -06001579 dout("%s: obj %p cb %p\n", __func__, obj_request,
1580 obj_request->callback);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001581 if (obj_request->callback)
1582 obj_request->callback(obj_request);
Alex Elder788e2df2013-01-17 12:25:27 -06001583 else
1584 complete_all(&obj_request->completion);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001585}
1586
Alex Elderc47f9372013-02-26 14:23:07 -06001587static void rbd_osd_trivial_callback(struct rbd_obj_request *obj_request)
Alex Elder39bf2c52013-02-26 14:23:07 -06001588{
1589 dout("%s: obj %p\n", __func__, obj_request);
1590 obj_request_done_set(obj_request);
1591}
1592
Alex Elderc47f9372013-02-26 14:23:07 -06001593static void rbd_osd_read_callback(struct rbd_obj_request *obj_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001594{
Alex Elder57acbaa2013-02-11 12:33:24 -06001595 struct rbd_img_request *img_request = NULL;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05001596 struct rbd_device *rbd_dev = NULL;
Alex Elder57acbaa2013-02-11 12:33:24 -06001597 bool layered = false;
1598
1599 if (obj_request_img_data_test(obj_request)) {
1600 img_request = obj_request->img_request;
1601 layered = img_request && img_request_layered_test(img_request);
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05001602 rbd_dev = img_request->rbd_dev;
Alex Elder57acbaa2013-02-11 12:33:24 -06001603 }
Alex Elder8b3e1a52013-01-24 16:13:36 -06001604
1605 dout("%s: obj %p img %p result %d %llu/%llu\n", __func__,
1606 obj_request, img_request, obj_request->result,
1607 obj_request->xferred, obj_request->length);
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05001608 if (layered && obj_request->result == -ENOENT &&
1609 obj_request->img_offset < rbd_dev->parent_overlap)
Alex Elder8b3e1a52013-01-24 16:13:36 -06001610 rbd_img_parent_read(obj_request);
1611 else if (img_request)
Alex Elder6e2a4502013-03-27 09:16:30 -05001612 rbd_img_obj_request_read_callback(obj_request);
1613 else
1614 obj_request_done_set(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001615}
1616
Alex Elderc47f9372013-02-26 14:23:07 -06001617static void rbd_osd_write_callback(struct rbd_obj_request *obj_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001618{
Sage Weil1b83bef2013-02-25 16:11:12 -08001619 dout("%s: obj %p result %d %llu\n", __func__, obj_request,
1620 obj_request->result, obj_request->length);
1621 /*
Alex Elder8b3e1a52013-01-24 16:13:36 -06001622 * There is no such thing as a successful short write. Set
1623 * it to our originally-requested length.
Sage Weil1b83bef2013-02-25 16:11:12 -08001624 */
1625 obj_request->xferred = obj_request->length;
Alex Elder07741302013-02-05 23:41:50 -06001626 obj_request_done_set(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001627}
1628
Alex Elderfbfab532013-02-08 09:55:48 -06001629/*
1630 * For a simple stat call there's nothing to do. We'll do more if
1631 * this is part of a write sequence for a layered image.
1632 */
Alex Elderc47f9372013-02-26 14:23:07 -06001633static void rbd_osd_stat_callback(struct rbd_obj_request *obj_request)
Alex Elderfbfab532013-02-08 09:55:48 -06001634{
Alex Elder37206ee2013-02-20 17:32:08 -06001635 dout("%s: obj %p\n", __func__, obj_request);
Alex Elderfbfab532013-02-08 09:55:48 -06001636 obj_request_done_set(obj_request);
1637}
1638
Alex Elderbf0d5f502012-11-22 00:00:08 -06001639static void rbd_osd_req_callback(struct ceph_osd_request *osd_req,
1640 struct ceph_msg *msg)
1641{
1642 struct rbd_obj_request *obj_request = osd_req->r_priv;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001643 u16 opcode;
1644
Alex Elder37206ee2013-02-20 17:32:08 -06001645 dout("%s: osd_req %p msg %p\n", __func__, osd_req, msg);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001646 rbd_assert(osd_req == obj_request->osd_req);
Alex Elder57acbaa2013-02-11 12:33:24 -06001647 if (obj_request_img_data_test(obj_request)) {
1648 rbd_assert(obj_request->img_request);
1649 rbd_assert(obj_request->which != BAD_WHICH);
1650 } else {
1651 rbd_assert(obj_request->which == BAD_WHICH);
1652 }
Alex Elderbf0d5f502012-11-22 00:00:08 -06001653
Sage Weil1b83bef2013-02-25 16:11:12 -08001654 if (osd_req->r_result < 0)
1655 obj_request->result = osd_req->r_result;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001656
Ilya Dryomov7cc69d42014-02-25 16:22:27 +02001657 rbd_assert(osd_req->r_num_ops <= CEPH_OSD_MAX_OP);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001658
Alex Elderc47f9372013-02-26 14:23:07 -06001659 /*
1660 * We support a 64-bit length, but ultimately it has to be
1661 * passed to blk_end_request(), which takes an unsigned int.
1662 */
Sage Weil1b83bef2013-02-25 16:11:12 -08001663 obj_request->xferred = osd_req->r_reply_op_len[0];
Alex Elder8b3e1a52013-01-24 16:13:36 -06001664 rbd_assert(obj_request->xferred < (u64)UINT_MAX);
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02001665
Alex Elder79528732013-04-03 21:32:51 -05001666 opcode = osd_req->r_ops[0].op;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001667 switch (opcode) {
1668 case CEPH_OSD_OP_READ:
Alex Elderc47f9372013-02-26 14:23:07 -06001669 rbd_osd_read_callback(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001670 break;
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02001671 case CEPH_OSD_OP_SETALLOCHINT:
1672 rbd_assert(osd_req->r_ops[1].op == CEPH_OSD_OP_WRITE);
1673 /* fall through */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001674 case CEPH_OSD_OP_WRITE:
Alex Elderc47f9372013-02-26 14:23:07 -06001675 rbd_osd_write_callback(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001676 break;
Alex Elderfbfab532013-02-08 09:55:48 -06001677 case CEPH_OSD_OP_STAT:
Alex Elderc47f9372013-02-26 14:23:07 -06001678 rbd_osd_stat_callback(obj_request);
Alex Elderfbfab532013-02-08 09:55:48 -06001679 break;
Alex Elder36be9a72013-01-19 00:30:28 -06001680 case CEPH_OSD_OP_CALL:
Alex Elderb8d70032012-11-30 17:53:04 -06001681 case CEPH_OSD_OP_NOTIFY_ACK:
Alex Elder9969ebc2013-01-18 12:31:10 -06001682 case CEPH_OSD_OP_WATCH:
Alex Elderc47f9372013-02-26 14:23:07 -06001683 rbd_osd_trivial_callback(obj_request);
Alex Elder9969ebc2013-01-18 12:31:10 -06001684 break;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001685 default:
1686 rbd_warn(NULL, "%s: unsupported op %hu\n",
1687 obj_request->object_name, (unsigned short) opcode);
1688 break;
1689 }
1690
Alex Elder07741302013-02-05 23:41:50 -06001691 if (obj_request_done_test(obj_request))
Alex Elderbf0d5f502012-11-22 00:00:08 -06001692 rbd_obj_request_complete(obj_request);
1693}
1694
Alex Elder9d4df012013-04-19 15:34:50 -05001695static void rbd_osd_req_format_read(struct rbd_obj_request *obj_request)
Alex Elder430c28c2013-04-03 21:32:51 -05001696{
1697 struct rbd_img_request *img_request = obj_request->img_request;
Alex Elder8c042b02013-04-03 01:28:58 -05001698 struct ceph_osd_request *osd_req = obj_request->osd_req;
Alex Elder9d4df012013-04-19 15:34:50 -05001699 u64 snap_id;
Alex Elder430c28c2013-04-03 21:32:51 -05001700
Alex Elder8c042b02013-04-03 01:28:58 -05001701 rbd_assert(osd_req != NULL);
Alex Elder430c28c2013-04-03 21:32:51 -05001702
Alex Elder9d4df012013-04-19 15:34:50 -05001703 snap_id = img_request ? img_request->snap_id : CEPH_NOSNAP;
Alex Elder8c042b02013-04-03 01:28:58 -05001704 ceph_osdc_build_request(osd_req, obj_request->offset,
Alex Elder9d4df012013-04-19 15:34:50 -05001705 NULL, snap_id, NULL);
1706}
1707
1708static void rbd_osd_req_format_write(struct rbd_obj_request *obj_request)
1709{
1710 struct rbd_img_request *img_request = obj_request->img_request;
1711 struct ceph_osd_request *osd_req = obj_request->osd_req;
1712 struct ceph_snap_context *snapc;
1713 struct timespec mtime = CURRENT_TIME;
1714
1715 rbd_assert(osd_req != NULL);
1716
1717 snapc = img_request ? img_request->snapc : NULL;
1718 ceph_osdc_build_request(osd_req, obj_request->offset,
1719 snapc, CEPH_NOSNAP, &mtime);
Alex Elder430c28c2013-04-03 21:32:51 -05001720}
1721
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02001722/*
1723 * Create an osd request. A read request has one osd op (read).
1724 * A write request has either one (watch) or two (hint+write) osd ops.
1725 * (All rbd data writes are prefixed with an allocation hint op, but
1726 * technically osd watch is a write request, hence this distinction.)
1727 */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001728static struct ceph_osd_request *rbd_osd_req_create(
1729 struct rbd_device *rbd_dev,
1730 bool write_request,
Ilya Dryomovdeb236b2014-02-25 16:22:27 +02001731 unsigned int num_ops,
Alex Elder430c28c2013-04-03 21:32:51 -05001732 struct rbd_obj_request *obj_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001733{
Alex Elderbf0d5f502012-11-22 00:00:08 -06001734 struct ceph_snap_context *snapc = NULL;
1735 struct ceph_osd_client *osdc;
1736 struct ceph_osd_request *osd_req;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001737
Alex Elder6365d332013-02-11 12:33:24 -06001738 if (obj_request_img_data_test(obj_request)) {
1739 struct rbd_img_request *img_request = obj_request->img_request;
1740
Alex Elder0c425242013-02-08 09:55:49 -06001741 rbd_assert(write_request ==
1742 img_request_write_test(img_request));
1743 if (write_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001744 snapc = img_request->snapc;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001745 }
1746
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02001747 rbd_assert(num_ops == 1 || (write_request && num_ops == 2));
Ilya Dryomovdeb236b2014-02-25 16:22:27 +02001748
1749 /* Allocate and initialize the request, for the num_ops ops */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001750
1751 osdc = &rbd_dev->rbd_client->client->osdc;
Ilya Dryomovdeb236b2014-02-25 16:22:27 +02001752 osd_req = ceph_osdc_alloc_request(osdc, snapc, num_ops, false,
1753 GFP_ATOMIC);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001754 if (!osd_req)
1755 return NULL; /* ENOMEM */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001756
Alex Elder430c28c2013-04-03 21:32:51 -05001757 if (write_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001758 osd_req->r_flags = CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK;
Alex Elder430c28c2013-04-03 21:32:51 -05001759 else
Alex Elderbf0d5f502012-11-22 00:00:08 -06001760 osd_req->r_flags = CEPH_OSD_FLAG_READ;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001761
1762 osd_req->r_callback = rbd_osd_req_callback;
1763 osd_req->r_priv = obj_request;
1764
Ilya Dryomov3c972c92014-01-27 17:40:20 +02001765 osd_req->r_base_oloc.pool = ceph_file_layout_pg_pool(rbd_dev->layout);
1766 ceph_oid_set_name(&osd_req->r_base_oid, obj_request->object_name);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001767
Alex Elderbf0d5f502012-11-22 00:00:08 -06001768 return osd_req;
1769}
1770
Alex Elder0eefd472013-04-19 15:34:50 -05001771/*
1772 * Create a copyup osd request based on the information in the
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02001773 * object request supplied. A copyup request has three osd ops,
1774 * a copyup method call, a hint op, and a write op.
Alex Elder0eefd472013-04-19 15:34:50 -05001775 */
1776static struct ceph_osd_request *
1777rbd_osd_req_create_copyup(struct rbd_obj_request *obj_request)
1778{
1779 struct rbd_img_request *img_request;
1780 struct ceph_snap_context *snapc;
1781 struct rbd_device *rbd_dev;
1782 struct ceph_osd_client *osdc;
1783 struct ceph_osd_request *osd_req;
1784
1785 rbd_assert(obj_request_img_data_test(obj_request));
1786 img_request = obj_request->img_request;
1787 rbd_assert(img_request);
1788 rbd_assert(img_request_write_test(img_request));
1789
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02001790 /* Allocate and initialize the request, for the three ops */
Alex Elder0eefd472013-04-19 15:34:50 -05001791
1792 snapc = img_request->snapc;
1793 rbd_dev = img_request->rbd_dev;
1794 osdc = &rbd_dev->rbd_client->client->osdc;
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02001795 osd_req = ceph_osdc_alloc_request(osdc, snapc, 3, false, GFP_ATOMIC);
Alex Elder0eefd472013-04-19 15:34:50 -05001796 if (!osd_req)
1797 return NULL; /* ENOMEM */
1798
1799 osd_req->r_flags = CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK;
1800 osd_req->r_callback = rbd_osd_req_callback;
1801 osd_req->r_priv = obj_request;
1802
Ilya Dryomov3c972c92014-01-27 17:40:20 +02001803 osd_req->r_base_oloc.pool = ceph_file_layout_pg_pool(rbd_dev->layout);
1804 ceph_oid_set_name(&osd_req->r_base_oid, obj_request->object_name);
Alex Elder0eefd472013-04-19 15:34:50 -05001805
Alex Elder0eefd472013-04-19 15:34:50 -05001806 return osd_req;
1807}
1808
1809
Alex Elderbf0d5f502012-11-22 00:00:08 -06001810static void rbd_osd_req_destroy(struct ceph_osd_request *osd_req)
1811{
1812 ceph_osdc_put_request(osd_req);
1813}
1814
1815/* object_name is assumed to be a non-null pointer and NUL-terminated */
1816
1817static struct rbd_obj_request *rbd_obj_request_create(const char *object_name,
1818 u64 offset, u64 length,
1819 enum obj_request_type type)
1820{
1821 struct rbd_obj_request *obj_request;
1822 size_t size;
1823 char *name;
1824
1825 rbd_assert(obj_request_type_valid(type));
1826
1827 size = strlen(object_name) + 1;
Alex Elderf907ad52013-05-01 12:43:03 -05001828 name = kmalloc(size, GFP_KERNEL);
1829 if (!name)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001830 return NULL;
1831
Alex Elder868311b2013-05-01 12:43:03 -05001832 obj_request = kmem_cache_zalloc(rbd_obj_request_cache, GFP_KERNEL);
Alex Elderf907ad52013-05-01 12:43:03 -05001833 if (!obj_request) {
1834 kfree(name);
1835 return NULL;
1836 }
1837
Alex Elderbf0d5f502012-11-22 00:00:08 -06001838 obj_request->object_name = memcpy(name, object_name, size);
1839 obj_request->offset = offset;
1840 obj_request->length = length;
Alex Elder926f9b32013-02-11 12:33:24 -06001841 obj_request->flags = 0;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001842 obj_request->which = BAD_WHICH;
1843 obj_request->type = type;
1844 INIT_LIST_HEAD(&obj_request->links);
Alex Elder788e2df2013-01-17 12:25:27 -06001845 init_completion(&obj_request->completion);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001846 kref_init(&obj_request->kref);
1847
Alex Elder37206ee2013-02-20 17:32:08 -06001848 dout("%s: \"%s\" %llu/%llu %d -> obj %p\n", __func__, object_name,
1849 offset, length, (int)type, obj_request);
1850
Alex Elderbf0d5f502012-11-22 00:00:08 -06001851 return obj_request;
1852}
1853
1854static void rbd_obj_request_destroy(struct kref *kref)
1855{
1856 struct rbd_obj_request *obj_request;
1857
1858 obj_request = container_of(kref, struct rbd_obj_request, kref);
1859
Alex Elder37206ee2013-02-20 17:32:08 -06001860 dout("%s: obj %p\n", __func__, obj_request);
1861
Alex Elderbf0d5f502012-11-22 00:00:08 -06001862 rbd_assert(obj_request->img_request == NULL);
1863 rbd_assert(obj_request->which == BAD_WHICH);
1864
1865 if (obj_request->osd_req)
1866 rbd_osd_req_destroy(obj_request->osd_req);
1867
1868 rbd_assert(obj_request_type_valid(obj_request->type));
1869 switch (obj_request->type) {
Alex Elder9969ebc2013-01-18 12:31:10 -06001870 case OBJ_REQUEST_NODATA:
1871 break; /* Nothing to do */
Alex Elderbf0d5f502012-11-22 00:00:08 -06001872 case OBJ_REQUEST_BIO:
1873 if (obj_request->bio_list)
1874 bio_chain_put(obj_request->bio_list);
1875 break;
Alex Elder788e2df2013-01-17 12:25:27 -06001876 case OBJ_REQUEST_PAGES:
1877 if (obj_request->pages)
1878 ceph_release_page_vector(obj_request->pages,
1879 obj_request->page_count);
1880 break;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001881 }
1882
Alex Elderf907ad52013-05-01 12:43:03 -05001883 kfree(obj_request->object_name);
Alex Elder868311b2013-05-01 12:43:03 -05001884 obj_request->object_name = NULL;
1885 kmem_cache_free(rbd_obj_request_cache, obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001886}
1887
Alex Elderfb65d2282013-05-08 22:50:04 -05001888/* It's OK to call this for a device with no parent */
1889
1890static void rbd_spec_put(struct rbd_spec *spec);
1891static void rbd_dev_unparent(struct rbd_device *rbd_dev)
1892{
1893 rbd_dev_remove_parent(rbd_dev);
1894 rbd_spec_put(rbd_dev->parent_spec);
1895 rbd_dev->parent_spec = NULL;
1896 rbd_dev->parent_overlap = 0;
1897}
1898
Alex Elderbf0d5f502012-11-22 00:00:08 -06001899/*
Alex Eldera2acd002013-05-08 22:50:04 -05001900 * Parent image reference counting is used to determine when an
1901 * image's parent fields can be safely torn down--after there are no
1902 * more in-flight requests to the parent image. When the last
1903 * reference is dropped, cleaning them up is safe.
1904 */
1905static void rbd_dev_parent_put(struct rbd_device *rbd_dev)
1906{
1907 int counter;
1908
1909 if (!rbd_dev->parent_spec)
1910 return;
1911
1912 counter = atomic_dec_return_safe(&rbd_dev->parent_ref);
1913 if (counter > 0)
1914 return;
1915
1916 /* Last reference; clean up parent data structures */
1917
1918 if (!counter)
1919 rbd_dev_unparent(rbd_dev);
1920 else
1921 rbd_warn(rbd_dev, "parent reference underflow\n");
1922}
1923
1924/*
1925 * If an image has a non-zero parent overlap, get a reference to its
1926 * parent.
1927 *
Alex Elder392a9da2013-05-06 17:40:33 -05001928 * We must get the reference before checking for the overlap to
1929 * coordinate properly with zeroing the parent overlap in
1930 * rbd_dev_v2_parent_info() when an image gets flattened. We
1931 * drop it again if there is no overlap.
1932 *
Alex Eldera2acd002013-05-08 22:50:04 -05001933 * Returns true if the rbd device has a parent with a non-zero
1934 * overlap and a reference for it was successfully taken, or
1935 * false otherwise.
1936 */
1937static bool rbd_dev_parent_get(struct rbd_device *rbd_dev)
1938{
1939 int counter;
1940
1941 if (!rbd_dev->parent_spec)
1942 return false;
1943
1944 counter = atomic_inc_return_safe(&rbd_dev->parent_ref);
1945 if (counter > 0 && rbd_dev->parent_overlap)
1946 return true;
1947
1948 /* Image was flattened, but parent is not yet torn down */
1949
1950 if (counter < 0)
1951 rbd_warn(rbd_dev, "parent reference overflow\n");
1952
1953 return false;
1954}
1955
Alex Elderbf0d5f502012-11-22 00:00:08 -06001956/*
1957 * Caller is responsible for filling in the list of object requests
1958 * that comprises the image request, and the Linux request pointer
1959 * (if there is one).
1960 */
Alex Eldercc344fa2013-02-19 12:25:56 -06001961static struct rbd_img_request *rbd_img_request_create(
1962 struct rbd_device *rbd_dev,
Alex Elderbf0d5f502012-11-22 00:00:08 -06001963 u64 offset, u64 length,
Alex Eldere93f3152013-05-08 22:50:04 -05001964 bool write_request)
Alex Elderbf0d5f502012-11-22 00:00:08 -06001965{
1966 struct rbd_img_request *img_request;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001967
Alex Elder1c2a9df2013-05-01 12:43:03 -05001968 img_request = kmem_cache_alloc(rbd_img_request_cache, GFP_ATOMIC);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001969 if (!img_request)
1970 return NULL;
1971
1972 if (write_request) {
1973 down_read(&rbd_dev->header_rwsem);
Alex Elder812164f82013-04-30 00:44:32 -05001974 ceph_get_snap_context(rbd_dev->header.snapc);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001975 up_read(&rbd_dev->header_rwsem);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001976 }
1977
1978 img_request->rq = NULL;
1979 img_request->rbd_dev = rbd_dev;
1980 img_request->offset = offset;
1981 img_request->length = length;
Alex Elder0c425242013-02-08 09:55:49 -06001982 img_request->flags = 0;
1983 if (write_request) {
1984 img_request_write_set(img_request);
Alex Elder468521c2013-04-26 09:43:47 -05001985 img_request->snapc = rbd_dev->header.snapc;
Alex Elder0c425242013-02-08 09:55:49 -06001986 } else {
Alex Elderbf0d5f502012-11-22 00:00:08 -06001987 img_request->snap_id = rbd_dev->spec->snap_id;
Alex Elder0c425242013-02-08 09:55:49 -06001988 }
Alex Eldera2acd002013-05-08 22:50:04 -05001989 if (rbd_dev_parent_get(rbd_dev))
Alex Elderd0b2e942013-01-24 16:13:36 -06001990 img_request_layered_set(img_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06001991 spin_lock_init(&img_request->completion_lock);
1992 img_request->next_completion = 0;
1993 img_request->callback = NULL;
Alex Eldera5a337d2013-01-24 16:13:36 -06001994 img_request->result = 0;
Alex Elderbf0d5f502012-11-22 00:00:08 -06001995 img_request->obj_request_count = 0;
1996 INIT_LIST_HEAD(&img_request->obj_requests);
1997 kref_init(&img_request->kref);
1998
Alex Elder37206ee2013-02-20 17:32:08 -06001999 dout("%s: rbd_dev %p %s %llu/%llu -> img %p\n", __func__, rbd_dev,
2000 write_request ? "write" : "read", offset, length,
2001 img_request);
2002
Alex Elderbf0d5f502012-11-22 00:00:08 -06002003 return img_request;
2004}
2005
2006static void rbd_img_request_destroy(struct kref *kref)
2007{
2008 struct rbd_img_request *img_request;
2009 struct rbd_obj_request *obj_request;
2010 struct rbd_obj_request *next_obj_request;
2011
2012 img_request = container_of(kref, struct rbd_img_request, kref);
2013
Alex Elder37206ee2013-02-20 17:32:08 -06002014 dout("%s: img %p\n", __func__, img_request);
2015
Alex Elderbf0d5f502012-11-22 00:00:08 -06002016 for_each_obj_request_safe(img_request, obj_request, next_obj_request)
2017 rbd_img_obj_request_del(img_request, obj_request);
Alex Elder25dcf952013-01-25 17:08:55 -06002018 rbd_assert(img_request->obj_request_count == 0);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002019
Alex Eldera2acd002013-05-08 22:50:04 -05002020 if (img_request_layered_test(img_request)) {
2021 img_request_layered_clear(img_request);
2022 rbd_dev_parent_put(img_request->rbd_dev);
2023 }
2024
Alex Elder0c425242013-02-08 09:55:49 -06002025 if (img_request_write_test(img_request))
Alex Elder812164f82013-04-30 00:44:32 -05002026 ceph_put_snap_context(img_request->snapc);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002027
Alex Elder1c2a9df2013-05-01 12:43:03 -05002028 kmem_cache_free(rbd_img_request_cache, img_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002029}
2030
Alex Eldere93f3152013-05-08 22:50:04 -05002031static struct rbd_img_request *rbd_parent_request_create(
2032 struct rbd_obj_request *obj_request,
2033 u64 img_offset, u64 length)
2034{
2035 struct rbd_img_request *parent_request;
2036 struct rbd_device *rbd_dev;
2037
2038 rbd_assert(obj_request->img_request);
2039 rbd_dev = obj_request->img_request->rbd_dev;
2040
2041 parent_request = rbd_img_request_create(rbd_dev->parent,
2042 img_offset, length, false);
2043 if (!parent_request)
2044 return NULL;
2045
2046 img_request_child_set(parent_request);
2047 rbd_obj_request_get(obj_request);
2048 parent_request->obj_request = obj_request;
2049
2050 return parent_request;
2051}
2052
2053static void rbd_parent_request_destroy(struct kref *kref)
2054{
2055 struct rbd_img_request *parent_request;
2056 struct rbd_obj_request *orig_request;
2057
2058 parent_request = container_of(kref, struct rbd_img_request, kref);
2059 orig_request = parent_request->obj_request;
2060
2061 parent_request->obj_request = NULL;
2062 rbd_obj_request_put(orig_request);
2063 img_request_child_clear(parent_request);
2064
2065 rbd_img_request_destroy(kref);
2066}
2067
Alex Elder12178572013-02-08 09:55:49 -06002068static bool rbd_img_obj_end_request(struct rbd_obj_request *obj_request)
2069{
Alex Elder6365d332013-02-11 12:33:24 -06002070 struct rbd_img_request *img_request;
Alex Elder12178572013-02-08 09:55:49 -06002071 unsigned int xferred;
2072 int result;
Alex Elder8b3e1a52013-01-24 16:13:36 -06002073 bool more;
Alex Elder12178572013-02-08 09:55:49 -06002074
Alex Elder6365d332013-02-11 12:33:24 -06002075 rbd_assert(obj_request_img_data_test(obj_request));
2076 img_request = obj_request->img_request;
2077
Alex Elder12178572013-02-08 09:55:49 -06002078 rbd_assert(obj_request->xferred <= (u64)UINT_MAX);
2079 xferred = (unsigned int)obj_request->xferred;
2080 result = obj_request->result;
2081 if (result) {
2082 struct rbd_device *rbd_dev = img_request->rbd_dev;
2083
2084 rbd_warn(rbd_dev, "%s %llx at %llx (%llx)\n",
2085 img_request_write_test(img_request) ? "write" : "read",
2086 obj_request->length, obj_request->img_offset,
2087 obj_request->offset);
2088 rbd_warn(rbd_dev, " result %d xferred %x\n",
2089 result, xferred);
2090 if (!img_request->result)
2091 img_request->result = result;
2092 }
2093
Alex Elderf1a47392013-04-19 15:34:50 -05002094 /* Image object requests don't own their page array */
2095
2096 if (obj_request->type == OBJ_REQUEST_PAGES) {
2097 obj_request->pages = NULL;
2098 obj_request->page_count = 0;
2099 }
2100
Alex Elder8b3e1a52013-01-24 16:13:36 -06002101 if (img_request_child_test(img_request)) {
2102 rbd_assert(img_request->obj_request != NULL);
2103 more = obj_request->which < img_request->obj_request_count - 1;
2104 } else {
2105 rbd_assert(img_request->rq != NULL);
2106 more = blk_end_request(img_request->rq, result, xferred);
2107 }
2108
2109 return more;
Alex Elder12178572013-02-08 09:55:49 -06002110}
2111
Alex Elder21692382013-04-05 01:27:12 -05002112static void rbd_img_obj_callback(struct rbd_obj_request *obj_request)
2113{
2114 struct rbd_img_request *img_request;
2115 u32 which = obj_request->which;
2116 bool more = true;
2117
Alex Elder6365d332013-02-11 12:33:24 -06002118 rbd_assert(obj_request_img_data_test(obj_request));
Alex Elder21692382013-04-05 01:27:12 -05002119 img_request = obj_request->img_request;
2120
2121 dout("%s: img %p obj %p\n", __func__, img_request, obj_request);
2122 rbd_assert(img_request != NULL);
Alex Elder21692382013-04-05 01:27:12 -05002123 rbd_assert(img_request->obj_request_count > 0);
2124 rbd_assert(which != BAD_WHICH);
2125 rbd_assert(which < img_request->obj_request_count);
Alex Elder21692382013-04-05 01:27:12 -05002126
2127 spin_lock_irq(&img_request->completion_lock);
2128 if (which != img_request->next_completion)
2129 goto out;
2130
2131 for_each_obj_request_from(img_request, obj_request) {
Alex Elder21692382013-04-05 01:27:12 -05002132 rbd_assert(more);
2133 rbd_assert(which < img_request->obj_request_count);
2134
2135 if (!obj_request_done_test(obj_request))
2136 break;
Alex Elder12178572013-02-08 09:55:49 -06002137 more = rbd_img_obj_end_request(obj_request);
Alex Elder21692382013-04-05 01:27:12 -05002138 which++;
2139 }
2140
2141 rbd_assert(more ^ (which == img_request->obj_request_count));
2142 img_request->next_completion = which;
2143out:
2144 spin_unlock_irq(&img_request->completion_lock);
2145
2146 if (!more)
2147 rbd_img_request_complete(img_request);
2148}
2149
Alex Elderf1a47392013-04-19 15:34:50 -05002150/*
2151 * Split up an image request into one or more object requests, each
2152 * to a different object. The "type" parameter indicates whether
2153 * "data_desc" is the pointer to the head of a list of bio
2154 * structures, or the base of a page array. In either case this
2155 * function assumes data_desc describes memory sufficient to hold
2156 * all data described by the image request.
2157 */
2158static int rbd_img_request_fill(struct rbd_img_request *img_request,
2159 enum obj_request_type type,
2160 void *data_desc)
Alex Elderbf0d5f502012-11-22 00:00:08 -06002161{
2162 struct rbd_device *rbd_dev = img_request->rbd_dev;
2163 struct rbd_obj_request *obj_request = NULL;
2164 struct rbd_obj_request *next_obj_request;
Alex Elder0c425242013-02-08 09:55:49 -06002165 bool write_request = img_request_write_test(img_request);
Jingoo Hana1580732013-08-09 13:04:35 +09002166 struct bio *bio_list = NULL;
Alex Elderf1a47392013-04-19 15:34:50 -05002167 unsigned int bio_offset = 0;
Jingoo Hana1580732013-08-09 13:04:35 +09002168 struct page **pages = NULL;
Alex Elder7da22d22013-01-24 16:13:36 -06002169 u64 img_offset;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002170 u64 resid;
2171 u16 opcode;
2172
Alex Elderf1a47392013-04-19 15:34:50 -05002173 dout("%s: img %p type %d data_desc %p\n", __func__, img_request,
2174 (int)type, data_desc);
Alex Elder37206ee2013-02-20 17:32:08 -06002175
Alex Elder430c28c2013-04-03 21:32:51 -05002176 opcode = write_request ? CEPH_OSD_OP_WRITE : CEPH_OSD_OP_READ;
Alex Elder7da22d22013-01-24 16:13:36 -06002177 img_offset = img_request->offset;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002178 resid = img_request->length;
Alex Elder4dda41d2013-02-20 21:59:33 -06002179 rbd_assert(resid > 0);
Alex Elderf1a47392013-04-19 15:34:50 -05002180
2181 if (type == OBJ_REQUEST_BIO) {
2182 bio_list = data_desc;
Kent Overstreet4f024f32013-10-11 15:44:27 -07002183 rbd_assert(img_offset ==
2184 bio_list->bi_iter.bi_sector << SECTOR_SHIFT);
Alex Elderf1a47392013-04-19 15:34:50 -05002185 } else {
2186 rbd_assert(type == OBJ_REQUEST_PAGES);
2187 pages = data_desc;
2188 }
2189
Alex Elderbf0d5f502012-11-22 00:00:08 -06002190 while (resid) {
Alex Elder2fa12322013-04-05 01:27:12 -05002191 struct ceph_osd_request *osd_req;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002192 const char *object_name;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002193 u64 offset;
2194 u64 length;
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02002195 unsigned int which = 0;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002196
Alex Elder7da22d22013-01-24 16:13:36 -06002197 object_name = rbd_segment_name(rbd_dev, img_offset);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002198 if (!object_name)
2199 goto out_unwind;
Alex Elder7da22d22013-01-24 16:13:36 -06002200 offset = rbd_segment_offset(rbd_dev, img_offset);
2201 length = rbd_segment_length(rbd_dev, img_offset, resid);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002202 obj_request = rbd_obj_request_create(object_name,
Alex Elderf1a47392013-04-19 15:34:50 -05002203 offset, length, type);
Alex Elder78c2a442013-05-01 12:43:04 -05002204 /* object request has its own copy of the object name */
2205 rbd_segment_name_free(object_name);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002206 if (!obj_request)
2207 goto out_unwind;
Ilya Dryomov62054da2014-03-04 11:57:17 +02002208
Josh Durgin03507db2013-08-27 14:45:46 -07002209 /*
2210 * set obj_request->img_request before creating the
2211 * osd_request so that it gets the right snapc
2212 */
2213 rbd_img_obj_request_add(img_request, obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002214
Alex Elderf1a47392013-04-19 15:34:50 -05002215 if (type == OBJ_REQUEST_BIO) {
2216 unsigned int clone_size;
2217
2218 rbd_assert(length <= (u64)UINT_MAX);
2219 clone_size = (unsigned int)length;
2220 obj_request->bio_list =
2221 bio_chain_clone_range(&bio_list,
2222 &bio_offset,
2223 clone_size,
2224 GFP_ATOMIC);
2225 if (!obj_request->bio_list)
Ilya Dryomov62054da2014-03-04 11:57:17 +02002226 goto out_unwind;
Alex Elderf1a47392013-04-19 15:34:50 -05002227 } else {
2228 unsigned int page_count;
2229
2230 obj_request->pages = pages;
2231 page_count = (u32)calc_pages_for(offset, length);
2232 obj_request->page_count = page_count;
2233 if ((offset + length) & ~PAGE_MASK)
2234 page_count--; /* more on last page */
2235 pages += page_count;
2236 }
Alex Elderbf0d5f502012-11-22 00:00:08 -06002237
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02002238 osd_req = rbd_osd_req_create(rbd_dev, write_request,
2239 (write_request ? 2 : 1),
Ilya Dryomovdeb236b2014-02-25 16:22:27 +02002240 obj_request);
Alex Elder2fa12322013-04-05 01:27:12 -05002241 if (!osd_req)
Ilya Dryomov62054da2014-03-04 11:57:17 +02002242 goto out_unwind;
Alex Elder2fa12322013-04-05 01:27:12 -05002243 obj_request->osd_req = osd_req;
Alex Elder21692382013-04-05 01:27:12 -05002244 obj_request->callback = rbd_img_obj_callback;
Alex Elder430c28c2013-04-03 21:32:51 -05002245
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02002246 if (write_request) {
2247 osd_req_op_alloc_hint_init(osd_req, which,
2248 rbd_obj_bytes(&rbd_dev->header),
2249 rbd_obj_bytes(&rbd_dev->header));
2250 which++;
2251 }
2252
2253 osd_req_op_extent_init(osd_req, which, opcode, offset, length,
2254 0, 0);
Alex Elderf1a47392013-04-19 15:34:50 -05002255 if (type == OBJ_REQUEST_BIO)
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02002256 osd_req_op_extent_osd_data_bio(osd_req, which,
Alex Elderf1a47392013-04-19 15:34:50 -05002257 obj_request->bio_list, length);
2258 else
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02002259 osd_req_op_extent_osd_data_pages(osd_req, which,
Alex Elderf1a47392013-04-19 15:34:50 -05002260 obj_request->pages, length,
2261 offset & ~PAGE_MASK, false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05002262
2263 if (write_request)
2264 rbd_osd_req_format_write(obj_request);
2265 else
2266 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05002267
Alex Elder7da22d22013-01-24 16:13:36 -06002268 obj_request->img_offset = img_offset;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002269
Alex Elder7da22d22013-01-24 16:13:36 -06002270 img_offset += length;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002271 resid -= length;
2272 }
2273
2274 return 0;
2275
Alex Elderbf0d5f502012-11-22 00:00:08 -06002276out_unwind:
2277 for_each_obj_request_safe(img_request, obj_request, next_obj_request)
Ilya Dryomov42dd0372014-03-04 11:57:17 +02002278 rbd_img_obj_request_del(img_request, obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002279
2280 return -ENOMEM;
2281}
2282
Alex Elder3d7efd12013-04-19 15:34:50 -05002283static void
Alex Elder0eefd472013-04-19 15:34:50 -05002284rbd_img_obj_copyup_callback(struct rbd_obj_request *obj_request)
2285{
2286 struct rbd_img_request *img_request;
2287 struct rbd_device *rbd_dev;
Alex Elderebda6402013-05-10 16:29:22 -05002288 struct page **pages;
Alex Elder0eefd472013-04-19 15:34:50 -05002289 u32 page_count;
2290
2291 rbd_assert(obj_request->type == OBJ_REQUEST_BIO);
2292 rbd_assert(obj_request_img_data_test(obj_request));
2293 img_request = obj_request->img_request;
2294 rbd_assert(img_request);
2295
2296 rbd_dev = img_request->rbd_dev;
2297 rbd_assert(rbd_dev);
Alex Elder0eefd472013-04-19 15:34:50 -05002298
Alex Elderebda6402013-05-10 16:29:22 -05002299 pages = obj_request->copyup_pages;
2300 rbd_assert(pages != NULL);
Alex Elder0eefd472013-04-19 15:34:50 -05002301 obj_request->copyup_pages = NULL;
Alex Elderebda6402013-05-10 16:29:22 -05002302 page_count = obj_request->copyup_page_count;
2303 rbd_assert(page_count);
2304 obj_request->copyup_page_count = 0;
2305 ceph_release_page_vector(pages, page_count);
Alex Elder0eefd472013-04-19 15:34:50 -05002306
2307 /*
2308 * We want the transfer count to reflect the size of the
2309 * original write request. There is no such thing as a
2310 * successful short write, so if the request was successful
2311 * we can just set it to the originally-requested length.
2312 */
2313 if (!obj_request->result)
2314 obj_request->xferred = obj_request->length;
2315
2316 /* Finish up with the normal image object callback */
2317
2318 rbd_img_obj_callback(obj_request);
2319}
2320
2321static void
Alex Elder3d7efd12013-04-19 15:34:50 -05002322rbd_img_obj_parent_read_full_callback(struct rbd_img_request *img_request)
2323{
2324 struct rbd_obj_request *orig_request;
Alex Elder0eefd472013-04-19 15:34:50 -05002325 struct ceph_osd_request *osd_req;
2326 struct ceph_osd_client *osdc;
2327 struct rbd_device *rbd_dev;
Alex Elder3d7efd12013-04-19 15:34:50 -05002328 struct page **pages;
Alex Elderebda6402013-05-10 16:29:22 -05002329 u32 page_count;
Alex Elderbbea1c12013-05-06 17:40:33 -05002330 int img_result;
Alex Elderebda6402013-05-10 16:29:22 -05002331 u64 parent_length;
Alex Elderb91f09f2013-05-10 16:29:22 -05002332 u64 offset;
2333 u64 length;
Alex Elder3d7efd12013-04-19 15:34:50 -05002334
2335 rbd_assert(img_request_child_test(img_request));
2336
2337 /* First get what we need from the image request */
2338
2339 pages = img_request->copyup_pages;
2340 rbd_assert(pages != NULL);
2341 img_request->copyup_pages = NULL;
Alex Elderebda6402013-05-10 16:29:22 -05002342 page_count = img_request->copyup_page_count;
2343 rbd_assert(page_count);
2344 img_request->copyup_page_count = 0;
Alex Elder3d7efd12013-04-19 15:34:50 -05002345
2346 orig_request = img_request->obj_request;
2347 rbd_assert(orig_request != NULL);
Alex Elderb91f09f2013-05-10 16:29:22 -05002348 rbd_assert(obj_request_type_valid(orig_request->type));
Alex Elderbbea1c12013-05-06 17:40:33 -05002349 img_result = img_request->result;
Alex Elderebda6402013-05-10 16:29:22 -05002350 parent_length = img_request->length;
2351 rbd_assert(parent_length == img_request->xferred);
Alex Elder3d7efd12013-04-19 15:34:50 -05002352 rbd_img_request_put(img_request);
2353
Alex Elder91c6feb2013-05-06 17:40:32 -05002354 rbd_assert(orig_request->img_request);
2355 rbd_dev = orig_request->img_request->rbd_dev;
Alex Elder3d7efd12013-04-19 15:34:50 -05002356 rbd_assert(rbd_dev);
Alex Elder3d7efd12013-04-19 15:34:50 -05002357
Alex Elderbbea1c12013-05-06 17:40:33 -05002358 /*
2359 * If the overlap has become 0 (most likely because the
2360 * image has been flattened) we need to free the pages
2361 * and re-submit the original write request.
2362 */
2363 if (!rbd_dev->parent_overlap) {
2364 struct ceph_osd_client *osdc;
2365
2366 ceph_release_page_vector(pages, page_count);
2367 osdc = &rbd_dev->rbd_client->client->osdc;
2368 img_result = rbd_obj_request_submit(osdc, orig_request);
2369 if (!img_result)
2370 return;
2371 }
2372
2373 if (img_result)
Alex Elder0eefd472013-04-19 15:34:50 -05002374 goto out_err;
Alex Elder3d7efd12013-04-19 15:34:50 -05002375
Alex Elder8785b1d2013-05-09 10:08:49 -05002376 /*
2377 * The original osd request is of no use to use any more.
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02002378 * We need a new one that can hold the three ops in a copyup
Alex Elder8785b1d2013-05-09 10:08:49 -05002379 * request. Allocate the new copyup osd request for the
2380 * original request, and release the old one.
2381 */
Alex Elderbbea1c12013-05-06 17:40:33 -05002382 img_result = -ENOMEM;
Alex Elder0eefd472013-04-19 15:34:50 -05002383 osd_req = rbd_osd_req_create_copyup(orig_request);
2384 if (!osd_req)
2385 goto out_err;
Alex Elder8785b1d2013-05-09 10:08:49 -05002386 rbd_osd_req_destroy(orig_request->osd_req);
Alex Elder0eefd472013-04-19 15:34:50 -05002387 orig_request->osd_req = osd_req;
2388 orig_request->copyup_pages = pages;
Alex Elderebda6402013-05-10 16:29:22 -05002389 orig_request->copyup_page_count = page_count;
Alex Elder3d7efd12013-04-19 15:34:50 -05002390
Alex Elder0eefd472013-04-19 15:34:50 -05002391 /* Initialize the copyup op */
2392
2393 osd_req_op_cls_init(osd_req, 0, CEPH_OSD_OP_CALL, "rbd", "copyup");
Alex Elderebda6402013-05-10 16:29:22 -05002394 osd_req_op_cls_request_data_pages(osd_req, 0, pages, parent_length, 0,
Alex Elder0eefd472013-04-19 15:34:50 -05002395 false, false);
2396
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02002397 /* Then the hint op */
2398
2399 osd_req_op_alloc_hint_init(osd_req, 1, rbd_obj_bytes(&rbd_dev->header),
2400 rbd_obj_bytes(&rbd_dev->header));
2401
2402 /* And the original write request op */
Alex Elder0eefd472013-04-19 15:34:50 -05002403
Alex Elderb91f09f2013-05-10 16:29:22 -05002404 offset = orig_request->offset;
2405 length = orig_request->length;
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02002406 osd_req_op_extent_init(osd_req, 2, CEPH_OSD_OP_WRITE,
Alex Elderb91f09f2013-05-10 16:29:22 -05002407 offset, length, 0, 0);
2408 if (orig_request->type == OBJ_REQUEST_BIO)
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02002409 osd_req_op_extent_osd_data_bio(osd_req, 2,
Alex Elderb91f09f2013-05-10 16:29:22 -05002410 orig_request->bio_list, length);
2411 else
Ilya Dryomov0ccd5922014-02-25 16:22:28 +02002412 osd_req_op_extent_osd_data_pages(osd_req, 2,
Alex Elderb91f09f2013-05-10 16:29:22 -05002413 orig_request->pages, length,
2414 offset & ~PAGE_MASK, false, false);
Alex Elder0eefd472013-04-19 15:34:50 -05002415
2416 rbd_osd_req_format_write(orig_request);
2417
2418 /* All set, send it off. */
2419
2420 orig_request->callback = rbd_img_obj_copyup_callback;
2421 osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elderbbea1c12013-05-06 17:40:33 -05002422 img_result = rbd_obj_request_submit(osdc, orig_request);
2423 if (!img_result)
Alex Elder0eefd472013-04-19 15:34:50 -05002424 return;
2425out_err:
2426 /* Record the error code and complete the request */
2427
Alex Elderbbea1c12013-05-06 17:40:33 -05002428 orig_request->result = img_result;
Alex Elder0eefd472013-04-19 15:34:50 -05002429 orig_request->xferred = 0;
2430 obj_request_done_set(orig_request);
2431 rbd_obj_request_complete(orig_request);
Alex Elder3d7efd12013-04-19 15:34:50 -05002432}
2433
2434/*
2435 * Read from the parent image the range of data that covers the
2436 * entire target of the given object request. This is used for
2437 * satisfying a layered image write request when the target of an
2438 * object request from the image request does not exist.
2439 *
2440 * A page array big enough to hold the returned data is allocated
2441 * and supplied to rbd_img_request_fill() as the "data descriptor."
2442 * When the read completes, this page array will be transferred to
2443 * the original object request for the copyup operation.
2444 *
2445 * If an error occurs, record it as the result of the original
2446 * object request and mark it done so it gets completed.
2447 */
2448static int rbd_img_obj_parent_read_full(struct rbd_obj_request *obj_request)
2449{
2450 struct rbd_img_request *img_request = NULL;
2451 struct rbd_img_request *parent_request = NULL;
2452 struct rbd_device *rbd_dev;
2453 u64 img_offset;
2454 u64 length;
2455 struct page **pages = NULL;
2456 u32 page_count;
2457 int result;
2458
2459 rbd_assert(obj_request_img_data_test(obj_request));
Alex Elderb91f09f2013-05-10 16:29:22 -05002460 rbd_assert(obj_request_type_valid(obj_request->type));
Alex Elder3d7efd12013-04-19 15:34:50 -05002461
2462 img_request = obj_request->img_request;
2463 rbd_assert(img_request != NULL);
2464 rbd_dev = img_request->rbd_dev;
2465 rbd_assert(rbd_dev->parent != NULL);
2466
2467 /*
2468 * Determine the byte range covered by the object in the
2469 * child image to which the original request was to be sent.
2470 */
2471 img_offset = obj_request->img_offset - obj_request->offset;
2472 length = (u64)1 << rbd_dev->header.obj_order;
2473
2474 /*
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002475 * There is no defined parent data beyond the parent
2476 * overlap, so limit what we read at that boundary if
2477 * necessary.
2478 */
2479 if (img_offset + length > rbd_dev->parent_overlap) {
2480 rbd_assert(img_offset < rbd_dev->parent_overlap);
2481 length = rbd_dev->parent_overlap - img_offset;
2482 }
2483
2484 /*
Alex Elder3d7efd12013-04-19 15:34:50 -05002485 * Allocate a page array big enough to receive the data read
2486 * from the parent.
2487 */
2488 page_count = (u32)calc_pages_for(0, length);
2489 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
2490 if (IS_ERR(pages)) {
2491 result = PTR_ERR(pages);
2492 pages = NULL;
2493 goto out_err;
2494 }
2495
2496 result = -ENOMEM;
Alex Eldere93f3152013-05-08 22:50:04 -05002497 parent_request = rbd_parent_request_create(obj_request,
2498 img_offset, length);
Alex Elder3d7efd12013-04-19 15:34:50 -05002499 if (!parent_request)
2500 goto out_err;
Alex Elder3d7efd12013-04-19 15:34:50 -05002501
2502 result = rbd_img_request_fill(parent_request, OBJ_REQUEST_PAGES, pages);
2503 if (result)
2504 goto out_err;
2505 parent_request->copyup_pages = pages;
Alex Elderebda6402013-05-10 16:29:22 -05002506 parent_request->copyup_page_count = page_count;
Alex Elder3d7efd12013-04-19 15:34:50 -05002507
2508 parent_request->callback = rbd_img_obj_parent_read_full_callback;
2509 result = rbd_img_request_submit(parent_request);
2510 if (!result)
2511 return 0;
2512
2513 parent_request->copyup_pages = NULL;
Alex Elderebda6402013-05-10 16:29:22 -05002514 parent_request->copyup_page_count = 0;
Alex Elder3d7efd12013-04-19 15:34:50 -05002515 parent_request->obj_request = NULL;
2516 rbd_obj_request_put(obj_request);
2517out_err:
2518 if (pages)
2519 ceph_release_page_vector(pages, page_count);
2520 if (parent_request)
2521 rbd_img_request_put(parent_request);
2522 obj_request->result = result;
2523 obj_request->xferred = 0;
2524 obj_request_done_set(obj_request);
2525
2526 return result;
2527}
2528
Alex Elderc5b5ef62013-02-11 12:33:24 -06002529static void rbd_img_obj_exists_callback(struct rbd_obj_request *obj_request)
2530{
Alex Elderc5b5ef62013-02-11 12:33:24 -06002531 struct rbd_obj_request *orig_request;
Alex Elder638f5ab2013-05-06 17:40:33 -05002532 struct rbd_device *rbd_dev;
Alex Elderc5b5ef62013-02-11 12:33:24 -06002533 int result;
2534
2535 rbd_assert(!obj_request_img_data_test(obj_request));
2536
2537 /*
2538 * All we need from the object request is the original
2539 * request and the result of the STAT op. Grab those, then
2540 * we're done with the request.
2541 */
2542 orig_request = obj_request->obj_request;
2543 obj_request->obj_request = NULL;
Alex Elder912c3172013-05-13 20:35:38 -05002544 rbd_obj_request_put(orig_request);
Alex Elderc5b5ef62013-02-11 12:33:24 -06002545 rbd_assert(orig_request);
2546 rbd_assert(orig_request->img_request);
2547
2548 result = obj_request->result;
2549 obj_request->result = 0;
2550
2551 dout("%s: obj %p for obj %p result %d %llu/%llu\n", __func__,
2552 obj_request, orig_request, result,
2553 obj_request->xferred, obj_request->length);
2554 rbd_obj_request_put(obj_request);
2555
Alex Elder638f5ab2013-05-06 17:40:33 -05002556 /*
2557 * If the overlap has become 0 (most likely because the
2558 * image has been flattened) we need to free the pages
2559 * and re-submit the original write request.
2560 */
2561 rbd_dev = orig_request->img_request->rbd_dev;
2562 if (!rbd_dev->parent_overlap) {
2563 struct ceph_osd_client *osdc;
2564
Alex Elder638f5ab2013-05-06 17:40:33 -05002565 osdc = &rbd_dev->rbd_client->client->osdc;
2566 result = rbd_obj_request_submit(osdc, orig_request);
2567 if (!result)
2568 return;
2569 }
Alex Elderc5b5ef62013-02-11 12:33:24 -06002570
2571 /*
2572 * Our only purpose here is to determine whether the object
2573 * exists, and we don't want to treat the non-existence as
2574 * an error. If something else comes back, transfer the
2575 * error to the original request and complete it now.
2576 */
2577 if (!result) {
2578 obj_request_existence_set(orig_request, true);
2579 } else if (result == -ENOENT) {
2580 obj_request_existence_set(orig_request, false);
2581 } else if (result) {
2582 orig_request->result = result;
Alex Elder3d7efd12013-04-19 15:34:50 -05002583 goto out;
Alex Elderc5b5ef62013-02-11 12:33:24 -06002584 }
2585
2586 /*
2587 * Resubmit the original request now that we have recorded
2588 * whether the target object exists.
2589 */
Alex Elderb454e362013-04-19 15:34:50 -05002590 orig_request->result = rbd_img_obj_request_submit(orig_request);
Alex Elder3d7efd12013-04-19 15:34:50 -05002591out:
Alex Elderc5b5ef62013-02-11 12:33:24 -06002592 if (orig_request->result)
2593 rbd_obj_request_complete(orig_request);
Alex Elderc5b5ef62013-02-11 12:33:24 -06002594}
2595
2596static int rbd_img_obj_exists_submit(struct rbd_obj_request *obj_request)
2597{
2598 struct rbd_obj_request *stat_request;
2599 struct rbd_device *rbd_dev;
2600 struct ceph_osd_client *osdc;
2601 struct page **pages = NULL;
2602 u32 page_count;
2603 size_t size;
2604 int ret;
2605
2606 /*
2607 * The response data for a STAT call consists of:
2608 * le64 length;
2609 * struct {
2610 * le32 tv_sec;
2611 * le32 tv_nsec;
2612 * } mtime;
2613 */
2614 size = sizeof (__le64) + sizeof (__le32) + sizeof (__le32);
2615 page_count = (u32)calc_pages_for(0, size);
2616 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
2617 if (IS_ERR(pages))
2618 return PTR_ERR(pages);
2619
2620 ret = -ENOMEM;
2621 stat_request = rbd_obj_request_create(obj_request->object_name, 0, 0,
2622 OBJ_REQUEST_PAGES);
2623 if (!stat_request)
2624 goto out;
2625
2626 rbd_obj_request_get(obj_request);
2627 stat_request->obj_request = obj_request;
2628 stat_request->pages = pages;
2629 stat_request->page_count = page_count;
2630
2631 rbd_assert(obj_request->img_request);
2632 rbd_dev = obj_request->img_request->rbd_dev;
Ilya Dryomovdeb236b2014-02-25 16:22:27 +02002633 stat_request->osd_req = rbd_osd_req_create(rbd_dev, false, 1,
2634 stat_request);
Alex Elderc5b5ef62013-02-11 12:33:24 -06002635 if (!stat_request->osd_req)
2636 goto out;
2637 stat_request->callback = rbd_img_obj_exists_callback;
2638
2639 osd_req_op_init(stat_request->osd_req, 0, CEPH_OSD_OP_STAT);
2640 osd_req_op_raw_data_in_pages(stat_request->osd_req, 0, pages, size, 0,
2641 false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05002642 rbd_osd_req_format_read(stat_request);
Alex Elderc5b5ef62013-02-11 12:33:24 -06002643
2644 osdc = &rbd_dev->rbd_client->client->osdc;
2645 ret = rbd_obj_request_submit(osdc, stat_request);
2646out:
2647 if (ret)
2648 rbd_obj_request_put(obj_request);
2649
2650 return ret;
2651}
2652
Alex Elderb454e362013-04-19 15:34:50 -05002653static int rbd_img_obj_request_submit(struct rbd_obj_request *obj_request)
2654{
2655 struct rbd_img_request *img_request;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002656 struct rbd_device *rbd_dev;
Alex Elder3d7efd12013-04-19 15:34:50 -05002657 bool known;
Alex Elderb454e362013-04-19 15:34:50 -05002658
2659 rbd_assert(obj_request_img_data_test(obj_request));
2660
2661 img_request = obj_request->img_request;
2662 rbd_assert(img_request);
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002663 rbd_dev = img_request->rbd_dev;
Alex Elderb454e362013-04-19 15:34:50 -05002664
Alex Elderb454e362013-04-19 15:34:50 -05002665 /*
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002666 * Only writes to layered images need special handling.
2667 * Reads and non-layered writes are simple object requests.
2668 * Layered writes that start beyond the end of the overlap
2669 * with the parent have no parent data, so they too are
2670 * simple object requests. Finally, if the target object is
2671 * known to already exist, its parent data has already been
2672 * copied, so a write to the object can also be handled as a
2673 * simple object request.
Alex Elderb454e362013-04-19 15:34:50 -05002674 */
2675 if (!img_request_write_test(img_request) ||
2676 !img_request_layered_test(img_request) ||
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002677 rbd_dev->parent_overlap <= obj_request->img_offset ||
Alex Elder3d7efd12013-04-19 15:34:50 -05002678 ((known = obj_request_known_test(obj_request)) &&
2679 obj_request_exists_test(obj_request))) {
Alex Elderb454e362013-04-19 15:34:50 -05002680
2681 struct rbd_device *rbd_dev;
2682 struct ceph_osd_client *osdc;
2683
2684 rbd_dev = obj_request->img_request->rbd_dev;
2685 osdc = &rbd_dev->rbd_client->client->osdc;
2686
2687 return rbd_obj_request_submit(osdc, obj_request);
2688 }
2689
2690 /*
Alex Elder3d7efd12013-04-19 15:34:50 -05002691 * It's a layered write. The target object might exist but
2692 * we may not know that yet. If we know it doesn't exist,
2693 * start by reading the data for the full target object from
2694 * the parent so we can use it for a copyup to the target.
Alex Elderb454e362013-04-19 15:34:50 -05002695 */
Alex Elder3d7efd12013-04-19 15:34:50 -05002696 if (known)
2697 return rbd_img_obj_parent_read_full(obj_request);
2698
2699 /* We don't know whether the target exists. Go find out. */
Alex Elderb454e362013-04-19 15:34:50 -05002700
2701 return rbd_img_obj_exists_submit(obj_request);
2702}
2703
Alex Elderbf0d5f502012-11-22 00:00:08 -06002704static int rbd_img_request_submit(struct rbd_img_request *img_request)
2705{
Alex Elderbf0d5f502012-11-22 00:00:08 -06002706 struct rbd_obj_request *obj_request;
Alex Elder46faeed2013-04-10 17:47:46 -05002707 struct rbd_obj_request *next_obj_request;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002708
Alex Elder37206ee2013-02-20 17:32:08 -06002709 dout("%s: img %p\n", __func__, img_request);
Alex Elder46faeed2013-04-10 17:47:46 -05002710 for_each_obj_request_safe(img_request, obj_request, next_obj_request) {
Alex Elderbf0d5f502012-11-22 00:00:08 -06002711 int ret;
2712
Alex Elderb454e362013-04-19 15:34:50 -05002713 ret = rbd_img_obj_request_submit(obj_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06002714 if (ret)
2715 return ret;
Alex Elderbf0d5f502012-11-22 00:00:08 -06002716 }
2717
2718 return 0;
2719}
2720
Alex Elder8b3e1a52013-01-24 16:13:36 -06002721static void rbd_img_parent_read_callback(struct rbd_img_request *img_request)
2722{
2723 struct rbd_obj_request *obj_request;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002724 struct rbd_device *rbd_dev;
2725 u64 obj_end;
Alex Elder02c74fb2013-05-06 17:40:33 -05002726 u64 img_xferred;
2727 int img_result;
Alex Elder8b3e1a52013-01-24 16:13:36 -06002728
2729 rbd_assert(img_request_child_test(img_request));
2730
Alex Elder02c74fb2013-05-06 17:40:33 -05002731 /* First get what we need from the image request and release it */
2732
Alex Elder8b3e1a52013-01-24 16:13:36 -06002733 obj_request = img_request->obj_request;
Alex Elder02c74fb2013-05-06 17:40:33 -05002734 img_xferred = img_request->xferred;
2735 img_result = img_request->result;
2736 rbd_img_request_put(img_request);
2737
2738 /*
2739 * If the overlap has become 0 (most likely because the
2740 * image has been flattened) we need to re-submit the
2741 * original request.
2742 */
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002743 rbd_assert(obj_request);
2744 rbd_assert(obj_request->img_request);
Alex Elder02c74fb2013-05-06 17:40:33 -05002745 rbd_dev = obj_request->img_request->rbd_dev;
2746 if (!rbd_dev->parent_overlap) {
2747 struct ceph_osd_client *osdc;
Alex Elder8b3e1a52013-01-24 16:13:36 -06002748
Alex Elder02c74fb2013-05-06 17:40:33 -05002749 osdc = &rbd_dev->rbd_client->client->osdc;
2750 img_result = rbd_obj_request_submit(osdc, obj_request);
2751 if (!img_result)
2752 return;
2753 }
2754
2755 obj_request->result = img_result;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002756 if (obj_request->result)
2757 goto out;
2758
2759 /*
2760 * We need to zero anything beyond the parent overlap
2761 * boundary. Since rbd_img_obj_request_read_callback()
2762 * will zero anything beyond the end of a short read, an
2763 * easy way to do this is to pretend the data from the
2764 * parent came up short--ending at the overlap boundary.
2765 */
2766 rbd_assert(obj_request->img_offset < U64_MAX - obj_request->length);
2767 obj_end = obj_request->img_offset + obj_request->length;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002768 if (obj_end > rbd_dev->parent_overlap) {
2769 u64 xferred = 0;
2770
2771 if (obj_request->img_offset < rbd_dev->parent_overlap)
2772 xferred = rbd_dev->parent_overlap -
2773 obj_request->img_offset;
2774
Alex Elder02c74fb2013-05-06 17:40:33 -05002775 obj_request->xferred = min(img_xferred, xferred);
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002776 } else {
Alex Elder02c74fb2013-05-06 17:40:33 -05002777 obj_request->xferred = img_xferred;
Alex Eldera9e8ba2c2013-04-21 00:32:07 -05002778 }
2779out:
Alex Elder8b3e1a52013-01-24 16:13:36 -06002780 rbd_img_obj_request_read_callback(obj_request);
2781 rbd_obj_request_complete(obj_request);
2782}
2783
2784static void rbd_img_parent_read(struct rbd_obj_request *obj_request)
2785{
Alex Elder8b3e1a52013-01-24 16:13:36 -06002786 struct rbd_img_request *img_request;
2787 int result;
2788
2789 rbd_assert(obj_request_img_data_test(obj_request));
2790 rbd_assert(obj_request->img_request != NULL);
2791 rbd_assert(obj_request->result == (s32) -ENOENT);
Alex Elder5b2ab722013-05-06 17:40:33 -05002792 rbd_assert(obj_request_type_valid(obj_request->type));
Alex Elder8b3e1a52013-01-24 16:13:36 -06002793
Alex Elder8b3e1a52013-01-24 16:13:36 -06002794 /* rbd_read_finish(obj_request, obj_request->length); */
Alex Eldere93f3152013-05-08 22:50:04 -05002795 img_request = rbd_parent_request_create(obj_request,
Alex Elder8b3e1a52013-01-24 16:13:36 -06002796 obj_request->img_offset,
Alex Eldere93f3152013-05-08 22:50:04 -05002797 obj_request->length);
Alex Elder8b3e1a52013-01-24 16:13:36 -06002798 result = -ENOMEM;
2799 if (!img_request)
2800 goto out_err;
2801
Alex Elder5b2ab722013-05-06 17:40:33 -05002802 if (obj_request->type == OBJ_REQUEST_BIO)
2803 result = rbd_img_request_fill(img_request, OBJ_REQUEST_BIO,
2804 obj_request->bio_list);
2805 else
2806 result = rbd_img_request_fill(img_request, OBJ_REQUEST_PAGES,
2807 obj_request->pages);
Alex Elder8b3e1a52013-01-24 16:13:36 -06002808 if (result)
2809 goto out_err;
2810
2811 img_request->callback = rbd_img_parent_read_callback;
2812 result = rbd_img_request_submit(img_request);
2813 if (result)
2814 goto out_err;
2815
2816 return;
2817out_err:
2818 if (img_request)
2819 rbd_img_request_put(img_request);
2820 obj_request->result = result;
2821 obj_request->xferred = 0;
2822 obj_request_done_set(obj_request);
2823}
2824
Josh Durgin20e0af62013-08-29 17:36:03 -07002825static int rbd_obj_notify_ack_sync(struct rbd_device *rbd_dev, u64 notify_id)
Alex Elderb8d70032012-11-30 17:53:04 -06002826{
2827 struct rbd_obj_request *obj_request;
Alex Elder21692382013-04-05 01:27:12 -05002828 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elderb8d70032012-11-30 17:53:04 -06002829 int ret;
2830
2831 obj_request = rbd_obj_request_create(rbd_dev->header_name, 0, 0,
2832 OBJ_REQUEST_NODATA);
2833 if (!obj_request)
2834 return -ENOMEM;
2835
2836 ret = -ENOMEM;
Ilya Dryomovdeb236b2014-02-25 16:22:27 +02002837 obj_request->osd_req = rbd_osd_req_create(rbd_dev, false, 1,
2838 obj_request);
Alex Elderb8d70032012-11-30 17:53:04 -06002839 if (!obj_request->osd_req)
2840 goto out;
2841
Alex Elderc99d2d42013-04-05 01:27:11 -05002842 osd_req_op_watch_init(obj_request->osd_req, 0, CEPH_OSD_OP_NOTIFY_ACK,
Alex Eldercc4a38bd2013-04-30 00:44:33 -05002843 notify_id, 0, 0);
Alex Elder9d4df012013-04-19 15:34:50 -05002844 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05002845
Alex Elderb8d70032012-11-30 17:53:04 -06002846 ret = rbd_obj_request_submit(osdc, obj_request);
Alex Eldercf81b602013-01-17 12:18:46 -06002847 if (ret)
Josh Durgin20e0af62013-08-29 17:36:03 -07002848 goto out;
2849 ret = rbd_obj_request_wait(obj_request);
2850out:
2851 rbd_obj_request_put(obj_request);
Alex Elderb8d70032012-11-30 17:53:04 -06002852
2853 return ret;
2854}
2855
2856static void rbd_watch_cb(u64 ver, u64 notify_id, u8 opcode, void *data)
2857{
2858 struct rbd_device *rbd_dev = (struct rbd_device *)data;
Alex Eldere627db02013-05-06 07:40:30 -05002859 int ret;
Alex Elderb8d70032012-11-30 17:53:04 -06002860
2861 if (!rbd_dev)
2862 return;
2863
Alex Elder37206ee2013-02-20 17:32:08 -06002864 dout("%s: \"%s\" notify_id %llu opcode %u\n", __func__,
Alex Eldercc4a38bd2013-04-30 00:44:33 -05002865 rbd_dev->header_name, (unsigned long long)notify_id,
2866 (unsigned int)opcode);
Alex Eldere627db02013-05-06 07:40:30 -05002867 ret = rbd_dev_refresh(rbd_dev);
2868 if (ret)
Alex Elder3b5cf2a2013-05-29 11:18:59 -05002869 rbd_warn(rbd_dev, "header refresh error (%d)\n", ret);
Alex Elderb8d70032012-11-30 17:53:04 -06002870
Josh Durgin20e0af62013-08-29 17:36:03 -07002871 rbd_obj_notify_ack_sync(rbd_dev, notify_id);
Alex Elderb8d70032012-11-30 17:53:04 -06002872}
2873
Alex Elder9969ebc2013-01-18 12:31:10 -06002874/*
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002875 * Initiate a watch request, synchronously.
Alex Elder9969ebc2013-01-18 12:31:10 -06002876 */
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002877static int rbd_dev_header_watch_sync(struct rbd_device *rbd_dev)
Alex Elder9969ebc2013-01-18 12:31:10 -06002878{
2879 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
2880 struct rbd_obj_request *obj_request;
Alex Elder9969ebc2013-01-18 12:31:10 -06002881 int ret;
2882
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002883 rbd_assert(!rbd_dev->watch_event);
2884 rbd_assert(!rbd_dev->watch_request);
Alex Elder9969ebc2013-01-18 12:31:10 -06002885
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002886 ret = ceph_osdc_create_event(osdc, rbd_watch_cb, rbd_dev,
2887 &rbd_dev->watch_event);
2888 if (ret < 0)
2889 return ret;
Alex Elder9969ebc2013-01-18 12:31:10 -06002890
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002891 rbd_assert(rbd_dev->watch_event);
2892
Alex Elder9969ebc2013-01-18 12:31:10 -06002893 obj_request = rbd_obj_request_create(rbd_dev->header_name, 0, 0,
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002894 OBJ_REQUEST_NODATA);
2895 if (!obj_request) {
2896 ret = -ENOMEM;
Alex Elder9969ebc2013-01-18 12:31:10 -06002897 goto out_cancel;
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002898 }
Alex Elder9969ebc2013-01-18 12:31:10 -06002899
Ilya Dryomovdeb236b2014-02-25 16:22:27 +02002900 obj_request->osd_req = rbd_osd_req_create(rbd_dev, true, 1,
2901 obj_request);
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002902 if (!obj_request->osd_req) {
2903 ret = -ENOMEM;
2904 goto out_put;
2905 }
Alex Elder430c28c2013-04-03 21:32:51 -05002906
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002907 ceph_osdc_set_request_linger(osdc, obj_request->osd_req);
Alex Elder21692382013-04-05 01:27:12 -05002908
2909 osd_req_op_watch_init(obj_request->osd_req, 0, CEPH_OSD_OP_WATCH,
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002910 rbd_dev->watch_event->cookie, 0, 1);
Alex Elder9d4df012013-04-19 15:34:50 -05002911 rbd_osd_req_format_write(obj_request);
Alex Elder21692382013-04-05 01:27:12 -05002912
Alex Elder9969ebc2013-01-18 12:31:10 -06002913 ret = rbd_obj_request_submit(osdc, obj_request);
2914 if (ret)
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002915 goto out_linger;
2916
Alex Elder9969ebc2013-01-18 12:31:10 -06002917 ret = rbd_obj_request_wait(obj_request);
2918 if (ret)
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002919 goto out_linger;
2920
Alex Elder9969ebc2013-01-18 12:31:10 -06002921 ret = obj_request->result;
2922 if (ret)
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002923 goto out_linger;
Alex Elder9969ebc2013-01-18 12:31:10 -06002924
Alex Elder8eb87562013-01-25 17:08:55 -06002925 /*
2926 * A watch request is set to linger, so the underlying osd
2927 * request won't go away until we unregister it. We retain
2928 * a pointer to the object request during that time (in
2929 * rbd_dev->watch_request), so we'll keep a reference to
2930 * it. We'll drop that reference (below) after we've
2931 * unregistered it.
2932 */
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002933 rbd_dev->watch_request = obj_request;
Alex Elder8eb87562013-01-25 17:08:55 -06002934
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002935 return 0;
Alex Elder8eb87562013-01-25 17:08:55 -06002936
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002937out_linger:
2938 ceph_osdc_unregister_linger_request(osdc, obj_request->osd_req);
2939out_put:
2940 rbd_obj_request_put(obj_request);
Alex Elder9969ebc2013-01-18 12:31:10 -06002941out_cancel:
Alex Elder9969ebc2013-01-18 12:31:10 -06002942 ceph_osdc_cancel_event(rbd_dev->watch_event);
2943 rbd_dev->watch_event = NULL;
Alex Elder9969ebc2013-01-18 12:31:10 -06002944
2945 return ret;
2946}
2947
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002948/*
2949 * Tear down a watch request, synchronously.
2950 */
2951static int __rbd_dev_header_unwatch_sync(struct rbd_device *rbd_dev)
Ilya Dryomovfca27062013-12-16 18:02:40 +02002952{
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04002953 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
2954 struct rbd_obj_request *obj_request;
2955 int ret;
2956
2957 rbd_assert(rbd_dev->watch_event);
2958 rbd_assert(rbd_dev->watch_request);
2959
2960 obj_request = rbd_obj_request_create(rbd_dev->header_name, 0, 0,
2961 OBJ_REQUEST_NODATA);
2962 if (!obj_request) {
2963 ret = -ENOMEM;
2964 goto out_cancel;
2965 }
2966
2967 obj_request->osd_req = rbd_osd_req_create(rbd_dev, true, 1,
2968 obj_request);
2969 if (!obj_request->osd_req) {
2970 ret = -ENOMEM;
2971 goto out_put;
2972 }
2973
2974 osd_req_op_watch_init(obj_request->osd_req, 0, CEPH_OSD_OP_WATCH,
2975 rbd_dev->watch_event->cookie, 0, 0);
2976 rbd_osd_req_format_write(obj_request);
2977
2978 ret = rbd_obj_request_submit(osdc, obj_request);
2979 if (ret)
2980 goto out_put;
2981
2982 ret = rbd_obj_request_wait(obj_request);
2983 if (ret)
2984 goto out_put;
2985
2986 ret = obj_request->result;
2987 if (ret)
2988 goto out_put;
2989
2990 /* We have successfully torn down the watch request */
2991
2992 ceph_osdc_unregister_linger_request(osdc,
2993 rbd_dev->watch_request->osd_req);
2994 rbd_obj_request_put(rbd_dev->watch_request);
2995 rbd_dev->watch_request = NULL;
2996
2997out_put:
2998 rbd_obj_request_put(obj_request);
2999out_cancel:
3000 ceph_osdc_cancel_event(rbd_dev->watch_event);
3001 rbd_dev->watch_event = NULL;
3002
3003 return ret;
Ilya Dryomovfca27062013-12-16 18:02:40 +02003004}
3005
3006static void rbd_dev_header_unwatch_sync(struct rbd_device *rbd_dev)
3007{
3008 int ret;
3009
Ilya Dryomovb30a01f2014-05-22 19:28:52 +04003010 ret = __rbd_dev_header_unwatch_sync(rbd_dev);
Ilya Dryomovfca27062013-12-16 18:02:40 +02003011 if (ret) {
3012 rbd_warn(rbd_dev, "unable to tear down watch request: %d\n",
3013 ret);
3014 }
3015}
3016
Alex Elder36be9a72013-01-19 00:30:28 -06003017/*
Alex Elderf40eb342013-04-25 15:09:42 -05003018 * Synchronous osd object method call. Returns the number of bytes
3019 * returned in the outbound buffer, or a negative error code.
Alex Elder36be9a72013-01-19 00:30:28 -06003020 */
3021static int rbd_obj_method_sync(struct rbd_device *rbd_dev,
3022 const char *object_name,
3023 const char *class_name,
3024 const char *method_name,
Alex Elder41579762013-04-21 12:14:45 -05003025 const void *outbound,
Alex Elder36be9a72013-01-19 00:30:28 -06003026 size_t outbound_size,
Alex Elder41579762013-04-21 12:14:45 -05003027 void *inbound,
Alex Eldere2a58ee2013-04-30 00:44:33 -05003028 size_t inbound_size)
Alex Elder36be9a72013-01-19 00:30:28 -06003029{
Alex Elder21692382013-04-05 01:27:12 -05003030 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elder36be9a72013-01-19 00:30:28 -06003031 struct rbd_obj_request *obj_request;
Alex Elder36be9a72013-01-19 00:30:28 -06003032 struct page **pages;
3033 u32 page_count;
3034 int ret;
3035
3036 /*
Alex Elder6010a452013-04-05 01:27:11 -05003037 * Method calls are ultimately read operations. The result
3038 * should placed into the inbound buffer provided. They
3039 * also supply outbound data--parameters for the object
3040 * method. Currently if this is present it will be a
3041 * snapshot id.
Alex Elder36be9a72013-01-19 00:30:28 -06003042 */
Alex Elder57385b52013-04-21 12:14:45 -05003043 page_count = (u32)calc_pages_for(0, inbound_size);
Alex Elder36be9a72013-01-19 00:30:28 -06003044 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
3045 if (IS_ERR(pages))
3046 return PTR_ERR(pages);
3047
3048 ret = -ENOMEM;
Alex Elder6010a452013-04-05 01:27:11 -05003049 obj_request = rbd_obj_request_create(object_name, 0, inbound_size,
Alex Elder36be9a72013-01-19 00:30:28 -06003050 OBJ_REQUEST_PAGES);
3051 if (!obj_request)
3052 goto out;
3053
3054 obj_request->pages = pages;
3055 obj_request->page_count = page_count;
3056
Ilya Dryomovdeb236b2014-02-25 16:22:27 +02003057 obj_request->osd_req = rbd_osd_req_create(rbd_dev, false, 1,
3058 obj_request);
Alex Elder36be9a72013-01-19 00:30:28 -06003059 if (!obj_request->osd_req)
3060 goto out;
3061
Alex Elderc99d2d42013-04-05 01:27:11 -05003062 osd_req_op_cls_init(obj_request->osd_req, 0, CEPH_OSD_OP_CALL,
Alex Elder04017e22013-04-05 14:46:02 -05003063 class_name, method_name);
3064 if (outbound_size) {
3065 struct ceph_pagelist *pagelist;
3066
3067 pagelist = kmalloc(sizeof (*pagelist), GFP_NOFS);
3068 if (!pagelist)
3069 goto out;
3070
3071 ceph_pagelist_init(pagelist);
3072 ceph_pagelist_append(pagelist, outbound, outbound_size);
3073 osd_req_op_cls_request_data_pagelist(obj_request->osd_req, 0,
3074 pagelist);
3075 }
Alex Eldera4ce40a2013-04-05 01:27:12 -05003076 osd_req_op_cls_response_data_pages(obj_request->osd_req, 0,
3077 obj_request->pages, inbound_size,
Alex Elder44cd1882013-04-05 01:27:12 -05003078 0, false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05003079 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05003080
Alex Elder36be9a72013-01-19 00:30:28 -06003081 ret = rbd_obj_request_submit(osdc, obj_request);
3082 if (ret)
3083 goto out;
3084 ret = rbd_obj_request_wait(obj_request);
3085 if (ret)
3086 goto out;
3087
3088 ret = obj_request->result;
3089 if (ret < 0)
3090 goto out;
Alex Elder57385b52013-04-21 12:14:45 -05003091
3092 rbd_assert(obj_request->xferred < (u64)INT_MAX);
3093 ret = (int)obj_request->xferred;
Alex Elder903bb322013-02-06 13:11:38 -06003094 ceph_copy_from_page_vector(pages, inbound, 0, obj_request->xferred);
Alex Elder36be9a72013-01-19 00:30:28 -06003095out:
3096 if (obj_request)
3097 rbd_obj_request_put(obj_request);
3098 else
3099 ceph_release_page_vector(pages, page_count);
3100
3101 return ret;
3102}
3103
Alex Elderbf0d5f502012-11-22 00:00:08 -06003104static void rbd_request_fn(struct request_queue *q)
Alex Eldercc344fa2013-02-19 12:25:56 -06003105 __releases(q->queue_lock) __acquires(q->queue_lock)
Alex Elderbf0d5f502012-11-22 00:00:08 -06003106{
3107 struct rbd_device *rbd_dev = q->queuedata;
3108 bool read_only = rbd_dev->mapping.read_only;
3109 struct request *rq;
3110 int result;
3111
3112 while ((rq = blk_fetch_request(q))) {
3113 bool write_request = rq_data_dir(rq) == WRITE;
3114 struct rbd_img_request *img_request;
3115 u64 offset;
3116 u64 length;
3117
3118 /* Ignore any non-FS requests that filter through. */
3119
3120 if (rq->cmd_type != REQ_TYPE_FS) {
Alex Elder4dda41d2013-02-20 21:59:33 -06003121 dout("%s: non-fs request type %d\n", __func__,
3122 (int) rq->cmd_type);
3123 __blk_end_request_all(rq, 0);
3124 continue;
3125 }
3126
3127 /* Ignore/skip any zero-length requests */
3128
3129 offset = (u64) blk_rq_pos(rq) << SECTOR_SHIFT;
3130 length = (u64) blk_rq_bytes(rq);
3131
3132 if (!length) {
3133 dout("%s: zero-length request\n", __func__);
Alex Elderbf0d5f502012-11-22 00:00:08 -06003134 __blk_end_request_all(rq, 0);
3135 continue;
3136 }
3137
3138 spin_unlock_irq(q->queue_lock);
3139
3140 /* Disallow writes to a read-only device */
3141
3142 if (write_request) {
3143 result = -EROFS;
3144 if (read_only)
3145 goto end_request;
3146 rbd_assert(rbd_dev->spec->snap_id == CEPH_NOSNAP);
3147 }
3148
Alex Elder6d292902013-01-14 12:43:31 -06003149 /*
3150 * Quit early if the mapped snapshot no longer
3151 * exists. It's still possible the snapshot will
3152 * have disappeared by the time our request arrives
3153 * at the osd, but there's no sense in sending it if
3154 * we already know.
3155 */
3156 if (!test_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags)) {
Alex Elderbf0d5f502012-11-22 00:00:08 -06003157 dout("request for non-existent snapshot");
3158 rbd_assert(rbd_dev->spec->snap_id != CEPH_NOSNAP);
3159 result = -ENXIO;
3160 goto end_request;
3161 }
3162
Alex Elderbf0d5f502012-11-22 00:00:08 -06003163 result = -EINVAL;
Alex Elderc0cd10db2013-04-26 09:43:47 -05003164 if (offset && length > U64_MAX - offset + 1) {
3165 rbd_warn(rbd_dev, "bad request range (%llu~%llu)\n",
3166 offset, length);
Alex Elderbf0d5f502012-11-22 00:00:08 -06003167 goto end_request; /* Shouldn't happen */
Alex Elderc0cd10db2013-04-26 09:43:47 -05003168 }
Alex Elderbf0d5f502012-11-22 00:00:08 -06003169
Alex Elder00a653e2013-05-06 07:40:30 -05003170 result = -EIO;
3171 if (offset + length > rbd_dev->mapping.size) {
3172 rbd_warn(rbd_dev, "beyond EOD (%llu~%llu > %llu)\n",
3173 offset, length, rbd_dev->mapping.size);
3174 goto end_request;
3175 }
3176
Alex Elderbf0d5f502012-11-22 00:00:08 -06003177 result = -ENOMEM;
3178 img_request = rbd_img_request_create(rbd_dev, offset, length,
Alex Eldere93f3152013-05-08 22:50:04 -05003179 write_request);
Alex Elderbf0d5f502012-11-22 00:00:08 -06003180 if (!img_request)
3181 goto end_request;
3182
3183 img_request->rq = rq;
3184
Alex Elderf1a47392013-04-19 15:34:50 -05003185 result = rbd_img_request_fill(img_request, OBJ_REQUEST_BIO,
3186 rq->bio);
Alex Elderbf0d5f502012-11-22 00:00:08 -06003187 if (!result)
3188 result = rbd_img_request_submit(img_request);
3189 if (result)
3190 rbd_img_request_put(img_request);
3191end_request:
3192 spin_lock_irq(q->queue_lock);
3193 if (result < 0) {
Alex Elder7da22d22013-01-24 16:13:36 -06003194 rbd_warn(rbd_dev, "%s %llx at %llx result %d\n",
3195 write_request ? "write" : "read",
3196 length, offset, result);
3197
Alex Elderbf0d5f502012-11-22 00:00:08 -06003198 __blk_end_request_all(rq, result);
3199 }
3200 }
3201}
3202
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003203/*
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003204 * a queue callback. Makes sure that we don't create a bio that spans across
3205 * multiple osd objects. One exception would be with a single page bios,
Alex Elderf7760da2012-10-20 22:17:27 -05003206 * which we handle later at bio_chain_clone_range()
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003207 */
3208static int rbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bmd,
3209 struct bio_vec *bvec)
3210{
3211 struct rbd_device *rbd_dev = q->queuedata;
Alex Eldere5cfeed22012-10-20 22:17:27 -05003212 sector_t sector_offset;
3213 sector_t sectors_per_obj;
3214 sector_t obj_sector_offset;
3215 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003216
Alex Eldere5cfeed22012-10-20 22:17:27 -05003217 /*
3218 * Find how far into its rbd object the partition-relative
3219 * bio start sector is to offset relative to the enclosing
3220 * device.
3221 */
3222 sector_offset = get_start_sect(bmd->bi_bdev) + bmd->bi_sector;
3223 sectors_per_obj = 1 << (rbd_dev->header.obj_order - SECTOR_SHIFT);
3224 obj_sector_offset = sector_offset & (sectors_per_obj - 1);
Alex Elder593a9e72012-02-07 12:03:37 -06003225
Alex Eldere5cfeed22012-10-20 22:17:27 -05003226 /*
3227 * Compute the number of bytes from that offset to the end
3228 * of the object. Account for what's already used by the bio.
3229 */
3230 ret = (int) (sectors_per_obj - obj_sector_offset) << SECTOR_SHIFT;
3231 if (ret > bmd->bi_size)
3232 ret -= bmd->bi_size;
3233 else
3234 ret = 0;
3235
3236 /*
3237 * Don't send back more than was asked for. And if the bio
3238 * was empty, let the whole thing through because: "Note
3239 * that a block device *must* allow a single page to be
3240 * added to an empty bio."
3241 */
3242 rbd_assert(bvec->bv_len <= PAGE_SIZE);
3243 if (ret > (int) bvec->bv_len || !bmd->bi_size)
3244 ret = (int) bvec->bv_len;
3245
3246 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003247}
3248
3249static void rbd_free_disk(struct rbd_device *rbd_dev)
3250{
3251 struct gendisk *disk = rbd_dev->disk;
3252
3253 if (!disk)
3254 return;
3255
Alex Eldera0cab922013-04-25 23:15:08 -05003256 rbd_dev->disk = NULL;
3257 if (disk->flags & GENHD_FL_UP) {
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003258 del_gendisk(disk);
Alex Eldera0cab922013-04-25 23:15:08 -05003259 if (disk->queue)
3260 blk_cleanup_queue(disk->queue);
3261 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003262 put_disk(disk);
3263}
3264
Alex Elder788e2df2013-01-17 12:25:27 -06003265static int rbd_obj_read_sync(struct rbd_device *rbd_dev,
3266 const char *object_name,
Alex Elder7097f8d2013-04-30 00:44:33 -05003267 u64 offset, u64 length, void *buf)
Alex Elder788e2df2013-01-17 12:25:27 -06003268
3269{
Alex Elder21692382013-04-05 01:27:12 -05003270 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
Alex Elder788e2df2013-01-17 12:25:27 -06003271 struct rbd_obj_request *obj_request;
Alex Elder788e2df2013-01-17 12:25:27 -06003272 struct page **pages = NULL;
3273 u32 page_count;
Alex Elder1ceae7e2013-02-06 13:11:38 -06003274 size_t size;
Alex Elder788e2df2013-01-17 12:25:27 -06003275 int ret;
3276
3277 page_count = (u32) calc_pages_for(offset, length);
3278 pages = ceph_alloc_page_vector(page_count, GFP_KERNEL);
3279 if (IS_ERR(pages))
3280 ret = PTR_ERR(pages);
3281
3282 ret = -ENOMEM;
3283 obj_request = rbd_obj_request_create(object_name, offset, length,
Alex Elder36be9a72013-01-19 00:30:28 -06003284 OBJ_REQUEST_PAGES);
Alex Elder788e2df2013-01-17 12:25:27 -06003285 if (!obj_request)
3286 goto out;
3287
3288 obj_request->pages = pages;
3289 obj_request->page_count = page_count;
3290
Ilya Dryomovdeb236b2014-02-25 16:22:27 +02003291 obj_request->osd_req = rbd_osd_req_create(rbd_dev, false, 1,
3292 obj_request);
Alex Elder788e2df2013-01-17 12:25:27 -06003293 if (!obj_request->osd_req)
3294 goto out;
3295
Alex Elderc99d2d42013-04-05 01:27:11 -05003296 osd_req_op_extent_init(obj_request->osd_req, 0, CEPH_OSD_OP_READ,
3297 offset, length, 0, 0);
Alex Elder406e2c92013-04-15 14:50:36 -05003298 osd_req_op_extent_osd_data_pages(obj_request->osd_req, 0,
Alex Eldera4ce40a2013-04-05 01:27:12 -05003299 obj_request->pages,
Alex Elder44cd1882013-04-05 01:27:12 -05003300 obj_request->length,
3301 obj_request->offset & ~PAGE_MASK,
3302 false, false);
Alex Elder9d4df012013-04-19 15:34:50 -05003303 rbd_osd_req_format_read(obj_request);
Alex Elder430c28c2013-04-03 21:32:51 -05003304
Alex Elder788e2df2013-01-17 12:25:27 -06003305 ret = rbd_obj_request_submit(osdc, obj_request);
3306 if (ret)
3307 goto out;
3308 ret = rbd_obj_request_wait(obj_request);
3309 if (ret)
3310 goto out;
3311
3312 ret = obj_request->result;
3313 if (ret < 0)
3314 goto out;
Alex Elder1ceae7e2013-02-06 13:11:38 -06003315
3316 rbd_assert(obj_request->xferred <= (u64) SIZE_MAX);
3317 size = (size_t) obj_request->xferred;
Alex Elder903bb322013-02-06 13:11:38 -06003318 ceph_copy_from_page_vector(pages, buf, 0, size);
Alex Elder7097f8d2013-04-30 00:44:33 -05003319 rbd_assert(size <= (size_t)INT_MAX);
3320 ret = (int)size;
Alex Elder788e2df2013-01-17 12:25:27 -06003321out:
3322 if (obj_request)
3323 rbd_obj_request_put(obj_request);
3324 else
3325 ceph_release_page_vector(pages, page_count);
3326
3327 return ret;
3328}
3329
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003330/*
Alex Elder662518b2013-05-06 09:51:29 -05003331 * Read the complete header for the given rbd device. On successful
3332 * return, the rbd_dev->header field will contain up-to-date
3333 * information about the image.
Alex Elder4156d9982012-08-02 11:29:46 -05003334 */
Alex Elder99a41eb2013-05-06 09:51:30 -05003335static int rbd_dev_v1_header_info(struct rbd_device *rbd_dev)
Alex Elder4156d9982012-08-02 11:29:46 -05003336{
3337 struct rbd_image_header_ondisk *ondisk = NULL;
3338 u32 snap_count = 0;
3339 u64 names_size = 0;
3340 u32 want_count;
3341 int ret;
3342
3343 /*
3344 * The complete header will include an array of its 64-bit
3345 * snapshot ids, followed by the names of those snapshots as
3346 * a contiguous block of NUL-terminated strings. Note that
3347 * the number of snapshots could change by the time we read
3348 * it in, in which case we re-read it.
3349 */
3350 do {
3351 size_t size;
3352
3353 kfree(ondisk);
3354
3355 size = sizeof (*ondisk);
3356 size += snap_count * sizeof (struct rbd_image_snap_ondisk);
3357 size += names_size;
3358 ondisk = kmalloc(size, GFP_KERNEL);
3359 if (!ondisk)
Alex Elder662518b2013-05-06 09:51:29 -05003360 return -ENOMEM;
Alex Elder4156d9982012-08-02 11:29:46 -05003361
Alex Elder788e2df2013-01-17 12:25:27 -06003362 ret = rbd_obj_read_sync(rbd_dev, rbd_dev->header_name,
Alex Elder7097f8d2013-04-30 00:44:33 -05003363 0, size, ondisk);
Alex Elder4156d9982012-08-02 11:29:46 -05003364 if (ret < 0)
Alex Elder662518b2013-05-06 09:51:29 -05003365 goto out;
Alex Elderc0cd10db2013-04-26 09:43:47 -05003366 if ((size_t)ret < size) {
Alex Elder4156d9982012-08-02 11:29:46 -05003367 ret = -ENXIO;
Alex Elder06ecc6c2012-11-01 10:17:15 -05003368 rbd_warn(rbd_dev, "short header read (want %zd got %d)",
3369 size, ret);
Alex Elder662518b2013-05-06 09:51:29 -05003370 goto out;
Alex Elder4156d9982012-08-02 11:29:46 -05003371 }
3372 if (!rbd_dev_ondisk_valid(ondisk)) {
3373 ret = -ENXIO;
Alex Elder06ecc6c2012-11-01 10:17:15 -05003374 rbd_warn(rbd_dev, "invalid header");
Alex Elder662518b2013-05-06 09:51:29 -05003375 goto out;
Alex Elder4156d9982012-08-02 11:29:46 -05003376 }
3377
3378 names_size = le64_to_cpu(ondisk->snap_names_len);
3379 want_count = snap_count;
3380 snap_count = le32_to_cpu(ondisk->snap_count);
3381 } while (snap_count != want_count);
3382
Alex Elder662518b2013-05-06 09:51:29 -05003383 ret = rbd_header_from_disk(rbd_dev, ondisk);
3384out:
Alex Elder4156d9982012-08-02 11:29:46 -05003385 kfree(ondisk);
3386
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003387 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003388}
3389
Alex Elder15228ed2013-05-01 12:43:03 -05003390/*
3391 * Clear the rbd device's EXISTS flag if the snapshot it's mapped to
3392 * has disappeared from the (just updated) snapshot context.
3393 */
3394static void rbd_exists_validate(struct rbd_device *rbd_dev)
3395{
3396 u64 snap_id;
3397
3398 if (!test_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags))
3399 return;
3400
3401 snap_id = rbd_dev->spec->snap_id;
3402 if (snap_id == CEPH_NOSNAP)
3403 return;
3404
3405 if (rbd_dev_snap_index(rbd_dev, snap_id) == BAD_SNAP_INDEX)
3406 clear_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags);
3407}
3408
Josh Durgin98752012013-08-29 17:26:31 -07003409static void rbd_dev_update_size(struct rbd_device *rbd_dev)
3410{
3411 sector_t size;
3412 bool removing;
3413
3414 /*
3415 * Don't hold the lock while doing disk operations,
3416 * or lock ordering will conflict with the bdev mutex via:
3417 * rbd_add() -> blkdev_get() -> rbd_open()
3418 */
3419 spin_lock_irq(&rbd_dev->lock);
3420 removing = test_bit(RBD_DEV_FLAG_REMOVING, &rbd_dev->flags);
3421 spin_unlock_irq(&rbd_dev->lock);
3422 /*
3423 * If the device is being removed, rbd_dev->disk has
3424 * been destroyed, so don't try to update its size
3425 */
3426 if (!removing) {
3427 size = (sector_t)rbd_dev->mapping.size / SECTOR_SIZE;
3428 dout("setting size to %llu sectors", (unsigned long long)size);
3429 set_capacity(rbd_dev->disk, size);
3430 revalidate_disk(rbd_dev->disk);
3431 }
3432}
3433
Alex Eldercc4a38bd2013-04-30 00:44:33 -05003434static int rbd_dev_refresh(struct rbd_device *rbd_dev)
Alex Elder1fe5e992012-07-25 09:32:41 -05003435{
Alex Eldere627db02013-05-06 07:40:30 -05003436 u64 mapping_size;
Alex Elder1fe5e992012-07-25 09:32:41 -05003437 int ret;
3438
Alex Elder117973f2012-08-31 17:29:55 -05003439 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
Alex Eldercfbf6372013-05-31 17:40:45 -05003440 down_write(&rbd_dev->header_rwsem);
Alex Elder3b5cf2a2013-05-29 11:18:59 -05003441 mapping_size = rbd_dev->mapping.size;
Alex Elder117973f2012-08-31 17:29:55 -05003442 if (rbd_dev->image_format == 1)
Alex Elder99a41eb2013-05-06 09:51:30 -05003443 ret = rbd_dev_v1_header_info(rbd_dev);
Alex Elder117973f2012-08-31 17:29:55 -05003444 else
Alex Elder2df3fac2013-05-06 09:51:30 -05003445 ret = rbd_dev_v2_header_info(rbd_dev);
Alex Elder15228ed2013-05-01 12:43:03 -05003446
3447 /* If it's a mapped snapshot, validate its EXISTS flag */
3448
3449 rbd_exists_validate(rbd_dev);
Alex Eldercfbf6372013-05-31 17:40:45 -05003450 up_write(&rbd_dev->header_rwsem);
3451
Alex Elder00a653e2013-05-06 07:40:30 -05003452 if (mapping_size != rbd_dev->mapping.size) {
Josh Durgin98752012013-08-29 17:26:31 -07003453 rbd_dev_update_size(rbd_dev);
Alex Elder00a653e2013-05-06 07:40:30 -05003454 }
Alex Elder1fe5e992012-07-25 09:32:41 -05003455
3456 return ret;
3457}
3458
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003459static int rbd_init_disk(struct rbd_device *rbd_dev)
3460{
3461 struct gendisk *disk;
3462 struct request_queue *q;
Alex Elder593a9e72012-02-07 12:03:37 -06003463 u64 segment_size;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003464
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003465 /* create gendisk info */
Ilya Dryomov7e513d42013-12-16 19:26:32 +02003466 disk = alloc_disk(single_major ?
3467 (1 << RBD_SINGLE_MAJOR_PART_SHIFT) :
3468 RBD_MINORS_PER_MAJOR);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003469 if (!disk)
Alex Elder1fcdb8a2012-08-29 17:11:06 -05003470 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003471
Alex Elderf0f8cef2012-01-29 13:57:44 -06003472 snprintf(disk->disk_name, sizeof(disk->disk_name), RBD_DRV_NAME "%d",
Alex Elderde71a292012-07-03 16:01:19 -05003473 rbd_dev->dev_id);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003474 disk->major = rbd_dev->major;
Ilya Dryomovdd82fff2013-12-13 15:28:57 +02003475 disk->first_minor = rbd_dev->minor;
Ilya Dryomov7e513d42013-12-16 19:26:32 +02003476 if (single_major)
3477 disk->flags |= GENHD_FL_EXT_DEVT;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003478 disk->fops = &rbd_bd_ops;
3479 disk->private_data = rbd_dev;
3480
Alex Elderbf0d5f502012-11-22 00:00:08 -06003481 q = blk_init_queue(rbd_request_fn, &rbd_dev->lock);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003482 if (!q)
3483 goto out_disk;
Josh Durgin029bcbd2011-07-22 11:35:23 -07003484
Alex Elder593a9e72012-02-07 12:03:37 -06003485 /* We use the default size, but let's be explicit about it. */
3486 blk_queue_physical_block_size(q, SECTOR_SIZE);
3487
Josh Durgin029bcbd2011-07-22 11:35:23 -07003488 /* set io sizes to object size */
Alex Elder593a9e72012-02-07 12:03:37 -06003489 segment_size = rbd_obj_bytes(&rbd_dev->header);
3490 blk_queue_max_hw_sectors(q, segment_size / SECTOR_SIZE);
3491 blk_queue_max_segment_size(q, segment_size);
3492 blk_queue_io_min(q, segment_size);
3493 blk_queue_io_opt(q, segment_size);
Josh Durgin029bcbd2011-07-22 11:35:23 -07003494
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003495 blk_queue_merge_bvec(q, rbd_merge_bvec);
3496 disk->queue = q;
3497
3498 q->queuedata = rbd_dev;
3499
3500 rbd_dev->disk = disk;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003501
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003502 return 0;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003503out_disk:
3504 put_disk(disk);
Alex Elder1fcdb8a2012-08-29 17:11:06 -05003505
3506 return -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003507}
3508
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003509/*
3510 sysfs
3511*/
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003512
Alex Elder593a9e72012-02-07 12:03:37 -06003513static struct rbd_device *dev_to_rbd_dev(struct device *dev)
3514{
3515 return container_of(dev, struct rbd_device, dev);
3516}
3517
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003518static ssize_t rbd_size_show(struct device *dev,
3519 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003520{
Alex Elder593a9e72012-02-07 12:03:37 -06003521 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003522
Alex Elderfc71d832013-04-26 15:44:36 -05003523 return sprintf(buf, "%llu\n",
3524 (unsigned long long)rbd_dev->mapping.size);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003525}
3526
Alex Elder34b13182012-07-13 20:35:12 -05003527/*
3528 * Note this shows the features for whatever's mapped, which is not
3529 * necessarily the base image.
3530 */
3531static ssize_t rbd_features_show(struct device *dev,
3532 struct device_attribute *attr, char *buf)
3533{
3534 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3535
3536 return sprintf(buf, "0x%016llx\n",
Alex Elderfc71d832013-04-26 15:44:36 -05003537 (unsigned long long)rbd_dev->mapping.features);
Alex Elder34b13182012-07-13 20:35:12 -05003538}
3539
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003540static ssize_t rbd_major_show(struct device *dev,
3541 struct device_attribute *attr, char *buf)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003542{
Alex Elder593a9e72012-02-07 12:03:37 -06003543 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003544
Alex Elderfc71d832013-04-26 15:44:36 -05003545 if (rbd_dev->major)
3546 return sprintf(buf, "%d\n", rbd_dev->major);
3547
3548 return sprintf(buf, "(none)\n");
Ilya Dryomovdd82fff2013-12-13 15:28:57 +02003549}
Alex Elderfc71d832013-04-26 15:44:36 -05003550
Ilya Dryomovdd82fff2013-12-13 15:28:57 +02003551static ssize_t rbd_minor_show(struct device *dev,
3552 struct device_attribute *attr, char *buf)
3553{
3554 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3555
3556 return sprintf(buf, "%d\n", rbd_dev->minor);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003557}
3558
3559static ssize_t rbd_client_id_show(struct device *dev,
3560 struct device_attribute *attr, char *buf)
3561{
Alex Elder593a9e72012-02-07 12:03:37 -06003562 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003563
Alex Elder1dbb4392012-01-24 10:08:37 -06003564 return sprintf(buf, "client%lld\n",
3565 ceph_client_id(rbd_dev->rbd_client->client));
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003566}
3567
3568static ssize_t rbd_pool_show(struct device *dev,
3569 struct device_attribute *attr, char *buf)
3570{
Alex Elder593a9e72012-02-07 12:03:37 -06003571 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003572
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003573 return sprintf(buf, "%s\n", rbd_dev->spec->pool_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003574}
3575
Alex Elder9bb2f332012-07-12 10:46:35 -05003576static ssize_t rbd_pool_id_show(struct device *dev,
3577 struct device_attribute *attr, char *buf)
3578{
3579 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3580
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003581 return sprintf(buf, "%llu\n",
Alex Elderfc71d832013-04-26 15:44:36 -05003582 (unsigned long long) rbd_dev->spec->pool_id);
Alex Elder9bb2f332012-07-12 10:46:35 -05003583}
3584
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003585static ssize_t rbd_name_show(struct device *dev,
3586 struct device_attribute *attr, char *buf)
3587{
Alex Elder593a9e72012-02-07 12:03:37 -06003588 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003589
Alex Eldera92ffdf2012-10-30 19:40:33 -05003590 if (rbd_dev->spec->image_name)
3591 return sprintf(buf, "%s\n", rbd_dev->spec->image_name);
3592
3593 return sprintf(buf, "(unknown)\n");
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003594}
3595
Alex Elder589d30e2012-07-10 20:30:11 -05003596static ssize_t rbd_image_id_show(struct device *dev,
3597 struct device_attribute *attr, char *buf)
3598{
3599 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3600
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003601 return sprintf(buf, "%s\n", rbd_dev->spec->image_id);
Alex Elder589d30e2012-07-10 20:30:11 -05003602}
3603
Alex Elder34b13182012-07-13 20:35:12 -05003604/*
3605 * Shows the name of the currently-mapped snapshot (or
3606 * RBD_SNAP_HEAD_NAME for the base image).
3607 */
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003608static ssize_t rbd_snap_show(struct device *dev,
3609 struct device_attribute *attr,
3610 char *buf)
3611{
Alex Elder593a9e72012-02-07 12:03:37 -06003612 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003613
Alex Elder0d7dbfc2012-10-25 23:34:41 -05003614 return sprintf(buf, "%s\n", rbd_dev->spec->snap_name);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003615}
3616
Alex Elder86b00e02012-10-25 23:34:42 -05003617/*
3618 * For an rbd v2 image, shows the pool id, image id, and snapshot id
3619 * for the parent image. If there is no parent, simply shows
3620 * "(no parent image)".
3621 */
3622static ssize_t rbd_parent_show(struct device *dev,
3623 struct device_attribute *attr,
3624 char *buf)
3625{
3626 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
3627 struct rbd_spec *spec = rbd_dev->parent_spec;
3628 int count;
3629 char *bufp = buf;
3630
3631 if (!spec)
3632 return sprintf(buf, "(no parent image)\n");
3633
3634 count = sprintf(bufp, "pool_id %llu\npool_name %s\n",
3635 (unsigned long long) spec->pool_id, spec->pool_name);
3636 if (count < 0)
3637 return count;
3638 bufp += count;
3639
3640 count = sprintf(bufp, "image_id %s\nimage_name %s\n", spec->image_id,
3641 spec->image_name ? spec->image_name : "(unknown)");
3642 if (count < 0)
3643 return count;
3644 bufp += count;
3645
3646 count = sprintf(bufp, "snap_id %llu\nsnap_name %s\n",
3647 (unsigned long long) spec->snap_id, spec->snap_name);
3648 if (count < 0)
3649 return count;
3650 bufp += count;
3651
3652 count = sprintf(bufp, "overlap %llu\n", rbd_dev->parent_overlap);
3653 if (count < 0)
3654 return count;
3655 bufp += count;
3656
3657 return (ssize_t) (bufp - buf);
3658}
3659
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003660static ssize_t rbd_image_refresh(struct device *dev,
3661 struct device_attribute *attr,
3662 const char *buf,
3663 size_t size)
3664{
Alex Elder593a9e72012-02-07 12:03:37 -06003665 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Alex Elderb8136232012-07-25 09:32:41 -05003666 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003667
Alex Eldercc4a38bd2013-04-30 00:44:33 -05003668 ret = rbd_dev_refresh(rbd_dev);
Alex Eldere627db02013-05-06 07:40:30 -05003669 if (ret)
3670 rbd_warn(rbd_dev, ": manual header refresh error (%d)\n", ret);
Alex Elderb8136232012-07-25 09:32:41 -05003671
3672 return ret < 0 ? ret : size;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003673}
Yehuda Sadeh602adf42010-08-12 16:11:25 -07003674
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003675static DEVICE_ATTR(size, S_IRUGO, rbd_size_show, NULL);
Alex Elder34b13182012-07-13 20:35:12 -05003676static DEVICE_ATTR(features, S_IRUGO, rbd_features_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003677static DEVICE_ATTR(major, S_IRUGO, rbd_major_show, NULL);
Ilya Dryomovdd82fff2013-12-13 15:28:57 +02003678static DEVICE_ATTR(minor, S_IRUGO, rbd_minor_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003679static DEVICE_ATTR(client_id, S_IRUGO, rbd_client_id_show, NULL);
3680static DEVICE_ATTR(pool, S_IRUGO, rbd_pool_show, NULL);
Alex Elder9bb2f332012-07-12 10:46:35 -05003681static DEVICE_ATTR(pool_id, S_IRUGO, rbd_pool_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003682static DEVICE_ATTR(name, S_IRUGO, rbd_name_show, NULL);
Alex Elder589d30e2012-07-10 20:30:11 -05003683static DEVICE_ATTR(image_id, S_IRUGO, rbd_image_id_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003684static DEVICE_ATTR(refresh, S_IWUSR, NULL, rbd_image_refresh);
3685static DEVICE_ATTR(current_snap, S_IRUGO, rbd_snap_show, NULL);
Alex Elder86b00e02012-10-25 23:34:42 -05003686static DEVICE_ATTR(parent, S_IRUGO, rbd_parent_show, NULL);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003687
3688static struct attribute *rbd_attrs[] = {
3689 &dev_attr_size.attr,
Alex Elder34b13182012-07-13 20:35:12 -05003690 &dev_attr_features.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003691 &dev_attr_major.attr,
Ilya Dryomovdd82fff2013-12-13 15:28:57 +02003692 &dev_attr_minor.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003693 &dev_attr_client_id.attr,
3694 &dev_attr_pool.attr,
Alex Elder9bb2f332012-07-12 10:46:35 -05003695 &dev_attr_pool_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003696 &dev_attr_name.attr,
Alex Elder589d30e2012-07-10 20:30:11 -05003697 &dev_attr_image_id.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003698 &dev_attr_current_snap.attr,
Alex Elder86b00e02012-10-25 23:34:42 -05003699 &dev_attr_parent.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003700 &dev_attr_refresh.attr,
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003701 NULL
3702};
3703
3704static struct attribute_group rbd_attr_group = {
3705 .attrs = rbd_attrs,
3706};
3707
3708static const struct attribute_group *rbd_attr_groups[] = {
3709 &rbd_attr_group,
3710 NULL
3711};
3712
3713static void rbd_sysfs_dev_release(struct device *dev)
3714{
3715}
3716
3717static struct device_type rbd_device_type = {
3718 .name = "rbd",
3719 .groups = rbd_attr_groups,
3720 .release = rbd_sysfs_dev_release,
3721};
3722
Alex Elder8b8fb992012-10-26 17:25:24 -05003723static struct rbd_spec *rbd_spec_get(struct rbd_spec *spec)
3724{
3725 kref_get(&spec->kref);
3726
3727 return spec;
3728}
3729
3730static void rbd_spec_free(struct kref *kref);
3731static void rbd_spec_put(struct rbd_spec *spec)
3732{
3733 if (spec)
3734 kref_put(&spec->kref, rbd_spec_free);
3735}
3736
3737static struct rbd_spec *rbd_spec_alloc(void)
3738{
3739 struct rbd_spec *spec;
3740
3741 spec = kzalloc(sizeof (*spec), GFP_KERNEL);
3742 if (!spec)
3743 return NULL;
3744 kref_init(&spec->kref);
3745
Alex Elder8b8fb992012-10-26 17:25:24 -05003746 return spec;
3747}
3748
3749static void rbd_spec_free(struct kref *kref)
3750{
3751 struct rbd_spec *spec = container_of(kref, struct rbd_spec, kref);
3752
3753 kfree(spec->pool_name);
3754 kfree(spec->image_id);
3755 kfree(spec->image_name);
3756 kfree(spec->snap_name);
3757 kfree(spec);
3758}
3759
Alex Eldercc344fa2013-02-19 12:25:56 -06003760static struct rbd_device *rbd_dev_create(struct rbd_client *rbdc,
Alex Elderc53d5892012-10-25 23:34:42 -05003761 struct rbd_spec *spec)
3762{
3763 struct rbd_device *rbd_dev;
3764
3765 rbd_dev = kzalloc(sizeof (*rbd_dev), GFP_KERNEL);
3766 if (!rbd_dev)
3767 return NULL;
3768
3769 spin_lock_init(&rbd_dev->lock);
Alex Elder6d292902013-01-14 12:43:31 -06003770 rbd_dev->flags = 0;
Alex Eldera2acd002013-05-08 22:50:04 -05003771 atomic_set(&rbd_dev->parent_ref, 0);
Alex Elderc53d5892012-10-25 23:34:42 -05003772 INIT_LIST_HEAD(&rbd_dev->node);
Alex Elderc53d5892012-10-25 23:34:42 -05003773 init_rwsem(&rbd_dev->header_rwsem);
3774
3775 rbd_dev->spec = spec;
3776 rbd_dev->rbd_client = rbdc;
3777
Alex Elder0903e872012-11-14 12:25:19 -06003778 /* Initialize the layout used for all rbd requests */
3779
3780 rbd_dev->layout.fl_stripe_unit = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
3781 rbd_dev->layout.fl_stripe_count = cpu_to_le32(1);
3782 rbd_dev->layout.fl_object_size = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
3783 rbd_dev->layout.fl_pg_pool = cpu_to_le32((u32) spec->pool_id);
3784
Alex Elderc53d5892012-10-25 23:34:42 -05003785 return rbd_dev;
3786}
3787
3788static void rbd_dev_destroy(struct rbd_device *rbd_dev)
3789{
Alex Elderc53d5892012-10-25 23:34:42 -05003790 rbd_put_client(rbd_dev->rbd_client);
3791 rbd_spec_put(rbd_dev->spec);
3792 kfree(rbd_dev);
3793}
3794
Yehuda Sadehdfc56062010-11-19 14:51:04 -08003795/*
Alex Elder9d475de52012-07-03 16:01:19 -05003796 * Get the size and object order for an image snapshot, or if
3797 * snap_id is CEPH_NOSNAP, gets this information for the base
3798 * image.
3799 */
3800static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
3801 u8 *order, u64 *snap_size)
3802{
3803 __le64 snapid = cpu_to_le64(snap_id);
3804 int ret;
3805 struct {
3806 u8 order;
3807 __le64 size;
3808 } __attribute__ ((packed)) size_buf = { 0 };
3809
Alex Elder36be9a72013-01-19 00:30:28 -06003810 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder9d475de52012-07-03 16:01:19 -05003811 "rbd", "get_size",
Alex Elder41579762013-04-21 12:14:45 -05003812 &snapid, sizeof (snapid),
Alex Eldere2a58ee2013-04-30 00:44:33 -05003813 &size_buf, sizeof (size_buf));
Alex Elder36be9a72013-01-19 00:30:28 -06003814 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder9d475de52012-07-03 16:01:19 -05003815 if (ret < 0)
3816 return ret;
Alex Elder57385b52013-04-21 12:14:45 -05003817 if (ret < sizeof (size_buf))
3818 return -ERANGE;
Alex Elder9d475de52012-07-03 16:01:19 -05003819
Josh Durginc3545572013-08-28 17:08:10 -07003820 if (order) {
Alex Elderc86f86e2013-04-25 15:09:41 -05003821 *order = size_buf.order;
Josh Durginc3545572013-08-28 17:08:10 -07003822 dout(" order %u", (unsigned int)*order);
3823 }
Alex Elder9d475de52012-07-03 16:01:19 -05003824 *snap_size = le64_to_cpu(size_buf.size);
3825
Josh Durginc3545572013-08-28 17:08:10 -07003826 dout(" snap_id 0x%016llx snap_size = %llu\n",
3827 (unsigned long long)snap_id,
Alex Elder57385b52013-04-21 12:14:45 -05003828 (unsigned long long)*snap_size);
Alex Elder9d475de52012-07-03 16:01:19 -05003829
3830 return 0;
3831}
3832
3833static int rbd_dev_v2_image_size(struct rbd_device *rbd_dev)
3834{
3835 return _rbd_dev_v2_snap_size(rbd_dev, CEPH_NOSNAP,
3836 &rbd_dev->header.obj_order,
3837 &rbd_dev->header.image_size);
3838}
3839
Alex Elder1e130192012-07-03 16:01:19 -05003840static int rbd_dev_v2_object_prefix(struct rbd_device *rbd_dev)
3841{
3842 void *reply_buf;
3843 int ret;
3844 void *p;
3845
3846 reply_buf = kzalloc(RBD_OBJ_PREFIX_LEN_MAX, GFP_KERNEL);
3847 if (!reply_buf)
3848 return -ENOMEM;
3849
Alex Elder36be9a72013-01-19 00:30:28 -06003850 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder41579762013-04-21 12:14:45 -05003851 "rbd", "get_object_prefix", NULL, 0,
Alex Eldere2a58ee2013-04-30 00:44:33 -05003852 reply_buf, RBD_OBJ_PREFIX_LEN_MAX);
Alex Elder36be9a72013-01-19 00:30:28 -06003853 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder1e130192012-07-03 16:01:19 -05003854 if (ret < 0)
3855 goto out;
3856
3857 p = reply_buf;
3858 rbd_dev->header.object_prefix = ceph_extract_encoded_string(&p,
Alex Elder57385b52013-04-21 12:14:45 -05003859 p + ret, NULL, GFP_NOIO);
3860 ret = 0;
Alex Elder1e130192012-07-03 16:01:19 -05003861
3862 if (IS_ERR(rbd_dev->header.object_prefix)) {
3863 ret = PTR_ERR(rbd_dev->header.object_prefix);
3864 rbd_dev->header.object_prefix = NULL;
3865 } else {
3866 dout(" object_prefix = %s\n", rbd_dev->header.object_prefix);
3867 }
Alex Elder1e130192012-07-03 16:01:19 -05003868out:
3869 kfree(reply_buf);
3870
3871 return ret;
3872}
3873
Alex Elderb1b54022012-07-03 16:01:19 -05003874static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
3875 u64 *snap_features)
3876{
3877 __le64 snapid = cpu_to_le64(snap_id);
3878 struct {
3879 __le64 features;
3880 __le64 incompat;
Alex Elder41579762013-04-21 12:14:45 -05003881 } __attribute__ ((packed)) features_buf = { 0 };
Alex Elderd8891402012-10-09 13:50:17 -07003882 u64 incompat;
Alex Elderb1b54022012-07-03 16:01:19 -05003883 int ret;
3884
Alex Elder36be9a72013-01-19 00:30:28 -06003885 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elderb1b54022012-07-03 16:01:19 -05003886 "rbd", "get_features",
Alex Elder41579762013-04-21 12:14:45 -05003887 &snapid, sizeof (snapid),
Alex Eldere2a58ee2013-04-30 00:44:33 -05003888 &features_buf, sizeof (features_buf));
Alex Elder36be9a72013-01-19 00:30:28 -06003889 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elderb1b54022012-07-03 16:01:19 -05003890 if (ret < 0)
3891 return ret;
Alex Elder57385b52013-04-21 12:14:45 -05003892 if (ret < sizeof (features_buf))
3893 return -ERANGE;
Alex Elderd8891402012-10-09 13:50:17 -07003894
3895 incompat = le64_to_cpu(features_buf.incompat);
Alex Elder5cbf6f122013-04-11 09:29:48 -05003896 if (incompat & ~RBD_FEATURES_SUPPORTED)
Alex Elderb8f5c6e2012-11-01 08:39:26 -05003897 return -ENXIO;
Alex Elderd8891402012-10-09 13:50:17 -07003898
Alex Elderb1b54022012-07-03 16:01:19 -05003899 *snap_features = le64_to_cpu(features_buf.features);
3900
3901 dout(" snap_id 0x%016llx features = 0x%016llx incompat = 0x%016llx\n",
Alex Elder57385b52013-04-21 12:14:45 -05003902 (unsigned long long)snap_id,
3903 (unsigned long long)*snap_features,
3904 (unsigned long long)le64_to_cpu(features_buf.incompat));
Alex Elderb1b54022012-07-03 16:01:19 -05003905
3906 return 0;
3907}
3908
3909static int rbd_dev_v2_features(struct rbd_device *rbd_dev)
3910{
3911 return _rbd_dev_v2_snap_features(rbd_dev, CEPH_NOSNAP,
3912 &rbd_dev->header.features);
3913}
3914
Alex Elder86b00e02012-10-25 23:34:42 -05003915static int rbd_dev_v2_parent_info(struct rbd_device *rbd_dev)
3916{
3917 struct rbd_spec *parent_spec;
3918 size_t size;
3919 void *reply_buf = NULL;
3920 __le64 snapid;
3921 void *p;
3922 void *end;
Alex Elder642a2532013-05-06 17:40:33 -05003923 u64 pool_id;
Alex Elder86b00e02012-10-25 23:34:42 -05003924 char *image_id;
Alex Elder3b5cf2a2013-05-29 11:18:59 -05003925 u64 snap_id;
Alex Elder86b00e02012-10-25 23:34:42 -05003926 u64 overlap;
Alex Elder86b00e02012-10-25 23:34:42 -05003927 int ret;
3928
3929 parent_spec = rbd_spec_alloc();
3930 if (!parent_spec)
3931 return -ENOMEM;
3932
3933 size = sizeof (__le64) + /* pool_id */
3934 sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX + /* image_id */
3935 sizeof (__le64) + /* snap_id */
3936 sizeof (__le64); /* overlap */
3937 reply_buf = kmalloc(size, GFP_KERNEL);
3938 if (!reply_buf) {
3939 ret = -ENOMEM;
3940 goto out_err;
3941 }
3942
3943 snapid = cpu_to_le64(CEPH_NOSNAP);
Alex Elder36be9a72013-01-19 00:30:28 -06003944 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder86b00e02012-10-25 23:34:42 -05003945 "rbd", "get_parent",
Alex Elder41579762013-04-21 12:14:45 -05003946 &snapid, sizeof (snapid),
Alex Eldere2a58ee2013-04-30 00:44:33 -05003947 reply_buf, size);
Alex Elder36be9a72013-01-19 00:30:28 -06003948 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder86b00e02012-10-25 23:34:42 -05003949 if (ret < 0)
3950 goto out_err;
3951
Alex Elder86b00e02012-10-25 23:34:42 -05003952 p = reply_buf;
Alex Elder57385b52013-04-21 12:14:45 -05003953 end = reply_buf + ret;
3954 ret = -ERANGE;
Alex Elder642a2532013-05-06 17:40:33 -05003955 ceph_decode_64_safe(&p, end, pool_id, out_err);
Alex Elder392a9da2013-05-06 17:40:33 -05003956 if (pool_id == CEPH_NOPOOL) {
3957 /*
3958 * Either the parent never existed, or we have
3959 * record of it but the image got flattened so it no
3960 * longer has a parent. When the parent of a
3961 * layered image disappears we immediately set the
3962 * overlap to 0. The effect of this is that all new
3963 * requests will be treated as if the image had no
3964 * parent.
3965 */
3966 if (rbd_dev->parent_overlap) {
3967 rbd_dev->parent_overlap = 0;
3968 smp_mb();
3969 rbd_dev_parent_put(rbd_dev);
3970 pr_info("%s: clone image has been flattened\n",
3971 rbd_dev->disk->disk_name);
3972 }
3973
Alex Elder86b00e02012-10-25 23:34:42 -05003974 goto out; /* No parent? No problem. */
Alex Elder392a9da2013-05-06 17:40:33 -05003975 }
Alex Elder86b00e02012-10-25 23:34:42 -05003976
Alex Elder0903e872012-11-14 12:25:19 -06003977 /* The ceph file layout needs to fit pool id in 32 bits */
3978
3979 ret = -EIO;
Alex Elder642a2532013-05-06 17:40:33 -05003980 if (pool_id > (u64)U32_MAX) {
Alex Elderc0cd10db2013-04-26 09:43:47 -05003981 rbd_warn(NULL, "parent pool id too large (%llu > %u)\n",
Alex Elder642a2532013-05-06 17:40:33 -05003982 (unsigned long long)pool_id, U32_MAX);
Alex Elder57385b52013-04-21 12:14:45 -05003983 goto out_err;
Alex Elderc0cd10db2013-04-26 09:43:47 -05003984 }
Alex Elder0903e872012-11-14 12:25:19 -06003985
Alex Elder979ed482012-11-01 08:39:26 -05003986 image_id = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
Alex Elder86b00e02012-10-25 23:34:42 -05003987 if (IS_ERR(image_id)) {
3988 ret = PTR_ERR(image_id);
3989 goto out_err;
3990 }
Alex Elder3b5cf2a2013-05-29 11:18:59 -05003991 ceph_decode_64_safe(&p, end, snap_id, out_err);
Alex Elder86b00e02012-10-25 23:34:42 -05003992 ceph_decode_64_safe(&p, end, overlap, out_err);
3993
Alex Elder3b5cf2a2013-05-29 11:18:59 -05003994 /*
3995 * The parent won't change (except when the clone is
3996 * flattened, already handled that). So we only need to
3997 * record the parent spec we have not already done so.
3998 */
3999 if (!rbd_dev->parent_spec) {
4000 parent_spec->pool_id = pool_id;
4001 parent_spec->image_id = image_id;
4002 parent_spec->snap_id = snap_id;
Alex Elder70cf49c2013-05-06 17:40:33 -05004003 rbd_dev->parent_spec = parent_spec;
4004 parent_spec = NULL; /* rbd_dev now owns this */
Alex Elder3b5cf2a2013-05-29 11:18:59 -05004005 }
4006
4007 /*
4008 * We always update the parent overlap. If it's zero we
4009 * treat it specially.
4010 */
4011 rbd_dev->parent_overlap = overlap;
4012 smp_mb();
4013 if (!overlap) {
4014
4015 /* A null parent_spec indicates it's the initial probe */
4016
4017 if (parent_spec) {
4018 /*
4019 * The overlap has become zero, so the clone
4020 * must have been resized down to 0 at some
4021 * point. Treat this the same as a flatten.
4022 */
4023 rbd_dev_parent_put(rbd_dev);
4024 pr_info("%s: clone image now standalone\n",
4025 rbd_dev->disk->disk_name);
4026 } else {
4027 /*
4028 * For the initial probe, if we find the
4029 * overlap is zero we just pretend there was
4030 * no parent image.
4031 */
4032 rbd_warn(rbd_dev, "ignoring parent of "
4033 "clone with overlap 0\n");
4034 }
Alex Elder70cf49c2013-05-06 17:40:33 -05004035 }
Alex Elder86b00e02012-10-25 23:34:42 -05004036out:
4037 ret = 0;
4038out_err:
4039 kfree(reply_buf);
4040 rbd_spec_put(parent_spec);
4041
4042 return ret;
4043}
4044
Alex Eldercc070d52013-04-21 12:14:45 -05004045static int rbd_dev_v2_striping_info(struct rbd_device *rbd_dev)
4046{
4047 struct {
4048 __le64 stripe_unit;
4049 __le64 stripe_count;
4050 } __attribute__ ((packed)) striping_info_buf = { 0 };
4051 size_t size = sizeof (striping_info_buf);
4052 void *p;
4053 u64 obj_size;
4054 u64 stripe_unit;
4055 u64 stripe_count;
4056 int ret;
4057
4058 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
4059 "rbd", "get_stripe_unit_count", NULL, 0,
Alex Eldere2a58ee2013-04-30 00:44:33 -05004060 (char *)&striping_info_buf, size);
Alex Eldercc070d52013-04-21 12:14:45 -05004061 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
4062 if (ret < 0)
4063 return ret;
4064 if (ret < size)
4065 return -ERANGE;
4066
4067 /*
4068 * We don't actually support the "fancy striping" feature
4069 * (STRIPINGV2) yet, but if the striping sizes are the
4070 * defaults the behavior is the same as before. So find
4071 * out, and only fail if the image has non-default values.
4072 */
4073 ret = -EINVAL;
4074 obj_size = (u64)1 << rbd_dev->header.obj_order;
4075 p = &striping_info_buf;
4076 stripe_unit = ceph_decode_64(&p);
4077 if (stripe_unit != obj_size) {
4078 rbd_warn(rbd_dev, "unsupported stripe unit "
4079 "(got %llu want %llu)",
4080 stripe_unit, obj_size);
4081 return -EINVAL;
4082 }
4083 stripe_count = ceph_decode_64(&p);
4084 if (stripe_count != 1) {
4085 rbd_warn(rbd_dev, "unsupported stripe count "
4086 "(got %llu want 1)", stripe_count);
4087 return -EINVAL;
4088 }
Alex Elder500d0c0f2013-04-26 09:43:47 -05004089 rbd_dev->header.stripe_unit = stripe_unit;
4090 rbd_dev->header.stripe_count = stripe_count;
Alex Eldercc070d52013-04-21 12:14:45 -05004091
4092 return 0;
4093}
4094
Alex Elder9e15b772012-10-30 19:40:33 -05004095static char *rbd_dev_image_name(struct rbd_device *rbd_dev)
4096{
4097 size_t image_id_size;
4098 char *image_id;
4099 void *p;
4100 void *end;
4101 size_t size;
4102 void *reply_buf = NULL;
4103 size_t len = 0;
4104 char *image_name = NULL;
4105 int ret;
4106
4107 rbd_assert(!rbd_dev->spec->image_name);
4108
Alex Elder69e7a022012-11-01 08:39:26 -05004109 len = strlen(rbd_dev->spec->image_id);
4110 image_id_size = sizeof (__le32) + len;
Alex Elder9e15b772012-10-30 19:40:33 -05004111 image_id = kmalloc(image_id_size, GFP_KERNEL);
4112 if (!image_id)
4113 return NULL;
4114
4115 p = image_id;
Alex Elder41579762013-04-21 12:14:45 -05004116 end = image_id + image_id_size;
Alex Elder57385b52013-04-21 12:14:45 -05004117 ceph_encode_string(&p, end, rbd_dev->spec->image_id, (u32)len);
Alex Elder9e15b772012-10-30 19:40:33 -05004118
4119 size = sizeof (__le32) + RBD_IMAGE_NAME_LEN_MAX;
4120 reply_buf = kmalloc(size, GFP_KERNEL);
4121 if (!reply_buf)
4122 goto out;
4123
Alex Elder36be9a72013-01-19 00:30:28 -06004124 ret = rbd_obj_method_sync(rbd_dev, RBD_DIRECTORY,
Alex Elder9e15b772012-10-30 19:40:33 -05004125 "rbd", "dir_get_name",
4126 image_id, image_id_size,
Alex Eldere2a58ee2013-04-30 00:44:33 -05004127 reply_buf, size);
Alex Elder9e15b772012-10-30 19:40:33 -05004128 if (ret < 0)
4129 goto out;
4130 p = reply_buf;
Alex Elderf40eb342013-04-25 15:09:42 -05004131 end = reply_buf + ret;
4132
Alex Elder9e15b772012-10-30 19:40:33 -05004133 image_name = ceph_extract_encoded_string(&p, end, &len, GFP_KERNEL);
4134 if (IS_ERR(image_name))
4135 image_name = NULL;
4136 else
4137 dout("%s: name is %s len is %zd\n", __func__, image_name, len);
4138out:
4139 kfree(reply_buf);
4140 kfree(image_id);
4141
4142 return image_name;
4143}
4144
Alex Elder2ad3d712013-04-30 00:44:33 -05004145static u64 rbd_v1_snap_id_by_name(struct rbd_device *rbd_dev, const char *name)
4146{
4147 struct ceph_snap_context *snapc = rbd_dev->header.snapc;
4148 const char *snap_name;
4149 u32 which = 0;
4150
4151 /* Skip over names until we find the one we are looking for */
4152
4153 snap_name = rbd_dev->header.snap_names;
4154 while (which < snapc->num_snaps) {
4155 if (!strcmp(name, snap_name))
4156 return snapc->snaps[which];
4157 snap_name += strlen(snap_name) + 1;
4158 which++;
4159 }
4160 return CEPH_NOSNAP;
4161}
4162
4163static u64 rbd_v2_snap_id_by_name(struct rbd_device *rbd_dev, const char *name)
4164{
4165 struct ceph_snap_context *snapc = rbd_dev->header.snapc;
4166 u32 which;
4167 bool found = false;
4168 u64 snap_id;
4169
4170 for (which = 0; !found && which < snapc->num_snaps; which++) {
4171 const char *snap_name;
4172
4173 snap_id = snapc->snaps[which];
4174 snap_name = rbd_dev_v2_snap_name(rbd_dev, snap_id);
Josh Durginefadc982013-08-29 19:16:42 -07004175 if (IS_ERR(snap_name)) {
4176 /* ignore no-longer existing snapshots */
4177 if (PTR_ERR(snap_name) == -ENOENT)
4178 continue;
4179 else
4180 break;
4181 }
Alex Elder2ad3d712013-04-30 00:44:33 -05004182 found = !strcmp(name, snap_name);
4183 kfree(snap_name);
4184 }
4185 return found ? snap_id : CEPH_NOSNAP;
4186}
4187
4188/*
4189 * Assumes name is never RBD_SNAP_HEAD_NAME; returns CEPH_NOSNAP if
4190 * no snapshot by that name is found, or if an error occurs.
4191 */
4192static u64 rbd_snap_id_by_name(struct rbd_device *rbd_dev, const char *name)
4193{
4194 if (rbd_dev->image_format == 1)
4195 return rbd_v1_snap_id_by_name(rbd_dev, name);
4196
4197 return rbd_v2_snap_id_by_name(rbd_dev, name);
4198}
4199
Alex Elder9e15b772012-10-30 19:40:33 -05004200/*
Alex Elder2e9f7f12013-04-26 09:43:48 -05004201 * When an rbd image has a parent image, it is identified by the
4202 * pool, image, and snapshot ids (not names). This function fills
4203 * in the names for those ids. (It's OK if we can't figure out the
4204 * name for an image id, but the pool and snapshot ids should always
4205 * exist and have names.) All names in an rbd spec are dynamically
4206 * allocated.
Alex Eldere1d42132013-04-25 23:15:08 -05004207 *
4208 * When an image being mapped (not a parent) is probed, we have the
4209 * pool name and pool id, image name and image id, and the snapshot
4210 * name. The only thing we're missing is the snapshot id.
Alex Elder9e15b772012-10-30 19:40:33 -05004211 */
Alex Elder2e9f7f12013-04-26 09:43:48 -05004212static int rbd_dev_spec_update(struct rbd_device *rbd_dev)
Alex Elder9e15b772012-10-30 19:40:33 -05004213{
Alex Elder2e9f7f12013-04-26 09:43:48 -05004214 struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
4215 struct rbd_spec *spec = rbd_dev->spec;
4216 const char *pool_name;
4217 const char *image_name;
4218 const char *snap_name;
Alex Elder9e15b772012-10-30 19:40:33 -05004219 int ret;
4220
Alex Eldere1d42132013-04-25 23:15:08 -05004221 /*
4222 * An image being mapped will have the pool name (etc.), but
4223 * we need to look up the snapshot id.
4224 */
Alex Elder2e9f7f12013-04-26 09:43:48 -05004225 if (spec->pool_name) {
4226 if (strcmp(spec->snap_name, RBD_SNAP_HEAD_NAME)) {
Alex Elder2ad3d712013-04-30 00:44:33 -05004227 u64 snap_id;
Alex Eldere1d42132013-04-25 23:15:08 -05004228
Alex Elder2ad3d712013-04-30 00:44:33 -05004229 snap_id = rbd_snap_id_by_name(rbd_dev, spec->snap_name);
4230 if (snap_id == CEPH_NOSNAP)
Alex Eldere1d42132013-04-25 23:15:08 -05004231 return -ENOENT;
Alex Elder2ad3d712013-04-30 00:44:33 -05004232 spec->snap_id = snap_id;
Alex Eldere1d42132013-04-25 23:15:08 -05004233 } else {
Alex Elder2e9f7f12013-04-26 09:43:48 -05004234 spec->snap_id = CEPH_NOSNAP;
Alex Eldere1d42132013-04-25 23:15:08 -05004235 }
4236
4237 return 0;
4238 }
Alex Elder9e15b772012-10-30 19:40:33 -05004239
Alex Elder2e9f7f12013-04-26 09:43:48 -05004240 /* Get the pool name; we have to make our own copy of this */
Alex Elder9e15b772012-10-30 19:40:33 -05004241
Alex Elder2e9f7f12013-04-26 09:43:48 -05004242 pool_name = ceph_pg_pool_name_by_id(osdc->osdmap, spec->pool_id);
4243 if (!pool_name) {
4244 rbd_warn(rbd_dev, "no pool with id %llu", spec->pool_id);
Alex Elder935dc892012-11-01 10:17:15 -05004245 return -EIO;
4246 }
Alex Elder2e9f7f12013-04-26 09:43:48 -05004247 pool_name = kstrdup(pool_name, GFP_KERNEL);
4248 if (!pool_name)
Alex Elder9e15b772012-10-30 19:40:33 -05004249 return -ENOMEM;
4250
4251 /* Fetch the image name; tolerate failure here */
4252
Alex Elder2e9f7f12013-04-26 09:43:48 -05004253 image_name = rbd_dev_image_name(rbd_dev);
4254 if (!image_name)
Alex Elder06ecc6c2012-11-01 10:17:15 -05004255 rbd_warn(rbd_dev, "unable to get image name");
Alex Elder9e15b772012-10-30 19:40:33 -05004256
Alex Elder2e9f7f12013-04-26 09:43:48 -05004257 /* Look up the snapshot name, and make a copy */
Alex Elder9e15b772012-10-30 19:40:33 -05004258
Alex Elder2e9f7f12013-04-26 09:43:48 -05004259 snap_name = rbd_snap_name(rbd_dev, spec->snap_id);
Josh Durginda6a6b62013-09-04 17:57:31 -07004260 if (IS_ERR(snap_name)) {
4261 ret = PTR_ERR(snap_name);
Alex Elder9e15b772012-10-30 19:40:33 -05004262 goto out_err;
Alex Elder2e9f7f12013-04-26 09:43:48 -05004263 }
4264
4265 spec->pool_name = pool_name;
4266 spec->image_name = image_name;
4267 spec->snap_name = snap_name;
Alex Elder9e15b772012-10-30 19:40:33 -05004268
4269 return 0;
4270out_err:
Alex Elder2e9f7f12013-04-26 09:43:48 -05004271 kfree(image_name);
4272 kfree(pool_name);
Alex Elder9e15b772012-10-30 19:40:33 -05004273
4274 return ret;
4275}
4276
Alex Eldercc4a38bd2013-04-30 00:44:33 -05004277static int rbd_dev_v2_snap_context(struct rbd_device *rbd_dev)
Alex Elder35d489f2012-07-03 16:01:19 -05004278{
4279 size_t size;
4280 int ret;
4281 void *reply_buf;
4282 void *p;
4283 void *end;
4284 u64 seq;
4285 u32 snap_count;
4286 struct ceph_snap_context *snapc;
4287 u32 i;
4288
4289 /*
4290 * We'll need room for the seq value (maximum snapshot id),
4291 * snapshot count, and array of that many snapshot ids.
4292 * For now we have a fixed upper limit on the number we're
4293 * prepared to receive.
4294 */
4295 size = sizeof (__le64) + sizeof (__le32) +
4296 RBD_MAX_SNAP_COUNT * sizeof (__le64);
4297 reply_buf = kzalloc(size, GFP_KERNEL);
4298 if (!reply_buf)
4299 return -ENOMEM;
4300
Alex Elder36be9a72013-01-19 00:30:28 -06004301 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elder41579762013-04-21 12:14:45 -05004302 "rbd", "get_snapcontext", NULL, 0,
Alex Eldere2a58ee2013-04-30 00:44:33 -05004303 reply_buf, size);
Alex Elder36be9a72013-01-19 00:30:28 -06004304 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elder35d489f2012-07-03 16:01:19 -05004305 if (ret < 0)
4306 goto out;
4307
Alex Elder35d489f2012-07-03 16:01:19 -05004308 p = reply_buf;
Alex Elder57385b52013-04-21 12:14:45 -05004309 end = reply_buf + ret;
4310 ret = -ERANGE;
Alex Elder35d489f2012-07-03 16:01:19 -05004311 ceph_decode_64_safe(&p, end, seq, out);
4312 ceph_decode_32_safe(&p, end, snap_count, out);
4313
4314 /*
4315 * Make sure the reported number of snapshot ids wouldn't go
4316 * beyond the end of our buffer. But before checking that,
4317 * make sure the computed size of the snapshot context we
4318 * allocate is representable in a size_t.
4319 */
4320 if (snap_count > (SIZE_MAX - sizeof (struct ceph_snap_context))
4321 / sizeof (u64)) {
4322 ret = -EINVAL;
4323 goto out;
4324 }
4325 if (!ceph_has_room(&p, end, snap_count * sizeof (__le64)))
4326 goto out;
Alex Elder468521c2013-04-26 09:43:47 -05004327 ret = 0;
Alex Elder35d489f2012-07-03 16:01:19 -05004328
Alex Elder812164f82013-04-30 00:44:32 -05004329 snapc = ceph_create_snap_context(snap_count, GFP_KERNEL);
Alex Elder35d489f2012-07-03 16:01:19 -05004330 if (!snapc) {
4331 ret = -ENOMEM;
4332 goto out;
4333 }
Alex Elder35d489f2012-07-03 16:01:19 -05004334 snapc->seq = seq;
Alex Elder35d489f2012-07-03 16:01:19 -05004335 for (i = 0; i < snap_count; i++)
4336 snapc->snaps[i] = ceph_decode_64(&p);
4337
Alex Elder49ece552013-05-06 08:37:00 -05004338 ceph_put_snap_context(rbd_dev->header.snapc);
Alex Elder35d489f2012-07-03 16:01:19 -05004339 rbd_dev->header.snapc = snapc;
4340
4341 dout(" snap context seq = %llu, snap_count = %u\n",
Alex Elder57385b52013-04-21 12:14:45 -05004342 (unsigned long long)seq, (unsigned int)snap_count);
Alex Elder35d489f2012-07-03 16:01:19 -05004343out:
4344 kfree(reply_buf);
4345
Alex Elder57385b52013-04-21 12:14:45 -05004346 return ret;
Alex Elder35d489f2012-07-03 16:01:19 -05004347}
4348
Alex Elder54cac612013-04-30 00:44:33 -05004349static const char *rbd_dev_v2_snap_name(struct rbd_device *rbd_dev,
4350 u64 snap_id)
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004351{
4352 size_t size;
4353 void *reply_buf;
Alex Elder54cac612013-04-30 00:44:33 -05004354 __le64 snapid;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004355 int ret;
4356 void *p;
4357 void *end;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004358 char *snap_name;
4359
4360 size = sizeof (__le32) + RBD_MAX_SNAP_NAME_LEN;
4361 reply_buf = kmalloc(size, GFP_KERNEL);
4362 if (!reply_buf)
4363 return ERR_PTR(-ENOMEM);
4364
Alex Elder54cac612013-04-30 00:44:33 -05004365 snapid = cpu_to_le64(snap_id);
Alex Elder36be9a72013-01-19 00:30:28 -06004366 ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004367 "rbd", "get_snapshot_name",
Alex Elder54cac612013-04-30 00:44:33 -05004368 &snapid, sizeof (snapid),
Alex Eldere2a58ee2013-04-30 00:44:33 -05004369 reply_buf, size);
Alex Elder36be9a72013-01-19 00:30:28 -06004370 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elderf40eb342013-04-25 15:09:42 -05004371 if (ret < 0) {
4372 snap_name = ERR_PTR(ret);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004373 goto out;
Alex Elderf40eb342013-04-25 15:09:42 -05004374 }
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004375
4376 p = reply_buf;
Alex Elderf40eb342013-04-25 15:09:42 -05004377 end = reply_buf + ret;
Alex Eldere5c35532012-10-25 23:34:41 -05004378 snap_name = ceph_extract_encoded_string(&p, end, NULL, GFP_KERNEL);
Alex Elderf40eb342013-04-25 15:09:42 -05004379 if (IS_ERR(snap_name))
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004380 goto out;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004381
Alex Elderf40eb342013-04-25 15:09:42 -05004382 dout(" snap_id 0x%016llx snap_name = %s\n",
Alex Elder54cac612013-04-30 00:44:33 -05004383 (unsigned long long)snap_id, snap_name);
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004384out:
4385 kfree(reply_buf);
4386
Alex Elderf40eb342013-04-25 15:09:42 -05004387 return snap_name;
Alex Elderb8b1e2d2012-07-03 16:01:19 -05004388}
4389
Alex Elder2df3fac2013-05-06 09:51:30 -05004390static int rbd_dev_v2_header_info(struct rbd_device *rbd_dev)
Alex Elder117973f2012-08-31 17:29:55 -05004391{
Alex Elder2df3fac2013-05-06 09:51:30 -05004392 bool first_time = rbd_dev->header.object_prefix == NULL;
Alex Elder117973f2012-08-31 17:29:55 -05004393 int ret;
Alex Elder117973f2012-08-31 17:29:55 -05004394
Josh Durgin1617e402013-06-12 14:43:10 -07004395 ret = rbd_dev_v2_image_size(rbd_dev);
4396 if (ret)
Alex Eldercfbf6372013-05-31 17:40:45 -05004397 return ret;
Josh Durgin1617e402013-06-12 14:43:10 -07004398
Alex Elder2df3fac2013-05-06 09:51:30 -05004399 if (first_time) {
4400 ret = rbd_dev_v2_header_onetime(rbd_dev);
4401 if (ret)
Alex Eldercfbf6372013-05-31 17:40:45 -05004402 return ret;
Alex Elder2df3fac2013-05-06 09:51:30 -05004403 }
4404
Alex Elder642a2532013-05-06 17:40:33 -05004405 /*
4406 * If the image supports layering, get the parent info. We
4407 * need to probe the first time regardless. Thereafter we
4408 * only need to if there's a parent, to see if it has
4409 * disappeared due to the mapped image getting flattened.
4410 */
4411 if (rbd_dev->header.features & RBD_FEATURE_LAYERING &&
4412 (first_time || rbd_dev->parent_spec)) {
4413 bool warn;
4414
4415 ret = rbd_dev_v2_parent_info(rbd_dev);
4416 if (ret)
Alex Eldercfbf6372013-05-31 17:40:45 -05004417 return ret;
Alex Elder642a2532013-05-06 17:40:33 -05004418
4419 /*
4420 * Print a warning if this is the initial probe and
4421 * the image has a parent. Don't print it if the
4422 * image now being probed is itself a parent. We
4423 * can tell at this point because we won't know its
4424 * pool name yet (just its pool id).
4425 */
4426 warn = rbd_dev->parent_spec && rbd_dev->spec->pool_name;
4427 if (first_time && warn)
4428 rbd_warn(rbd_dev, "WARNING: kernel layering "
4429 "is EXPERIMENTAL!");
4430 }
4431
Alex Elder29334ba2013-05-06 07:40:30 -05004432 if (rbd_dev->spec->snap_id == CEPH_NOSNAP)
4433 if (rbd_dev->mapping.size != rbd_dev->header.image_size)
4434 rbd_dev->mapping.size = rbd_dev->header.image_size;
Alex Elder117973f2012-08-31 17:29:55 -05004435
Alex Eldercc4a38bd2013-04-30 00:44:33 -05004436 ret = rbd_dev_v2_snap_context(rbd_dev);
Alex Elder117973f2012-08-31 17:29:55 -05004437 dout("rbd_dev_v2_snap_context returned %d\n", ret);
Alex Elder117973f2012-08-31 17:29:55 -05004438
4439 return ret;
4440}
4441
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004442static int rbd_bus_add_dev(struct rbd_device *rbd_dev)
4443{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004444 struct device *dev;
Alex Eldercd789ab2012-08-30 00:16:38 -05004445 int ret;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004446
Alex Eldercd789ab2012-08-30 00:16:38 -05004447 dev = &rbd_dev->dev;
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004448 dev->bus = &rbd_bus_type;
4449 dev->type = &rbd_device_type;
4450 dev->parent = &rbd_root_dev;
Alex Elder200a6a82013-04-28 23:32:34 -05004451 dev->release = rbd_dev_device_release;
Alex Elderde71a292012-07-03 16:01:19 -05004452 dev_set_name(dev, "%d", rbd_dev->dev_id);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004453 ret = device_register(dev);
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004454
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004455 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07004456}
4457
Yehuda Sadehdfc56062010-11-19 14:51:04 -08004458static void rbd_bus_del_dev(struct rbd_device *rbd_dev)
4459{
4460 device_unregister(&rbd_dev->dev);
4461}
4462
Alex Elder1ddbe942012-01-29 13:57:44 -06004463/*
Alex Elder499afd52012-02-02 08:13:29 -06004464 * Get a unique rbd identifier for the given new rbd_dev, and add
Ilya Dryomovf8a22fc2013-12-13 15:28:57 +02004465 * the rbd_dev to the global list.
Alex Elder1ddbe942012-01-29 13:57:44 -06004466 */
Ilya Dryomovf8a22fc2013-12-13 15:28:57 +02004467static int rbd_dev_id_get(struct rbd_device *rbd_dev)
Alex Elderb7f23c32012-01-29 13:57:43 -06004468{
Ilya Dryomovf8a22fc2013-12-13 15:28:57 +02004469 int new_dev_id;
4470
Ilya Dryomov9b60e702013-12-13 15:28:57 +02004471 new_dev_id = ida_simple_get(&rbd_dev_id_ida,
4472 0, minor_to_rbd_dev_id(1 << MINORBITS),
4473 GFP_KERNEL);
Ilya Dryomovf8a22fc2013-12-13 15:28:57 +02004474 if (new_dev_id < 0)
4475 return new_dev_id;
4476
4477 rbd_dev->dev_id = new_dev_id;
Alex Elder499afd52012-02-02 08:13:29 -06004478
4479 spin_lock(&rbd_dev_list_lock);
4480 list_add_tail(&rbd_dev->node, &rbd_dev_list);
4481 spin_unlock(&rbd_dev_list_lock);
Ilya Dryomovf8a22fc2013-12-13 15:28:57 +02004482
Ilya Dryomov70eebd22013-12-13 15:28:56 +02004483 dout("rbd_dev %p given dev id %d\n", rbd_dev, rbd_dev->dev_id);
Ilya Dryomovf8a22fc2013-12-13 15:28:57 +02004484
4485 return 0;
Alex Elder1ddbe942012-01-29 13:57:44 -06004486}
Alex Elderb7f23c32012-01-29 13:57:43 -06004487
Alex Elder1ddbe942012-01-29 13:57:44 -06004488/*
Alex Elder499afd52012-02-02 08:13:29 -06004489 * Remove an rbd_dev from the global list, and record that its
4490 * identifier is no longer in use.
Alex Elder1ddbe942012-01-29 13:57:44 -06004491 */
Alex Eldere2839302012-08-29 17:11:06 -05004492static void rbd_dev_id_put(struct rbd_device *rbd_dev)
Alex Elder1ddbe942012-01-29 13:57:44 -06004493{
Alex Elder499afd52012-02-02 08:13:29 -06004494 spin_lock(&rbd_dev_list_lock);
4495 list_del_init(&rbd_dev->node);
4496 spin_unlock(&rbd_dev_list_lock);
Alex Elderb7f23c32012-01-29 13:57:43 -06004497
Ilya Dryomovf8a22fc2013-12-13 15:28:57 +02004498 ida_simple_remove(&rbd_dev_id_ida, rbd_dev->dev_id);
4499
4500 dout("rbd_dev %p released dev id %d\n", rbd_dev, rbd_dev->dev_id);
Alex Elderb7f23c32012-01-29 13:57:43 -06004501}
4502
Alex Eldera725f65e2012-02-02 08:13:30 -06004503/*
Alex Eldere28fff262012-02-02 08:13:30 -06004504 * Skips over white space at *buf, and updates *buf to point to the
4505 * first found non-space character (if any). Returns the length of
Alex Elder593a9e72012-02-07 12:03:37 -06004506 * the token (string of non-white space characters) found. Note
4507 * that *buf must be terminated with '\0'.
Alex Eldere28fff262012-02-02 08:13:30 -06004508 */
4509static inline size_t next_token(const char **buf)
4510{
4511 /*
4512 * These are the characters that produce nonzero for
4513 * isspace() in the "C" and "POSIX" locales.
4514 */
4515 const char *spaces = " \f\n\r\t\v";
4516
4517 *buf += strspn(*buf, spaces); /* Find start of token */
4518
4519 return strcspn(*buf, spaces); /* Return token length */
4520}
4521
4522/*
4523 * Finds the next token in *buf, and if the provided token buffer is
4524 * big enough, copies the found token into it. The result, if
Alex Elder593a9e72012-02-07 12:03:37 -06004525 * copied, is guaranteed to be terminated with '\0'. Note that *buf
4526 * must be terminated with '\0' on entry.
Alex Eldere28fff262012-02-02 08:13:30 -06004527 *
4528 * Returns the length of the token found (not including the '\0').
4529 * Return value will be 0 if no token is found, and it will be >=
4530 * token_size if the token would not fit.
4531 *
Alex Elder593a9e72012-02-07 12:03:37 -06004532 * The *buf pointer will be updated to point beyond the end of the
Alex Eldere28fff262012-02-02 08:13:30 -06004533 * found token. Note that this occurs even if the token buffer is
4534 * too small to hold it.
4535 */
4536static inline size_t copy_token(const char **buf,
4537 char *token,
4538 size_t token_size)
4539{
4540 size_t len;
4541
4542 len = next_token(buf);
4543 if (len < token_size) {
4544 memcpy(token, *buf, len);
4545 *(token + len) = '\0';
4546 }
4547 *buf += len;
4548
4549 return len;
4550}
4551
4552/*
Alex Elderea3352f2012-07-09 21:04:23 -05004553 * Finds the next token in *buf, dynamically allocates a buffer big
4554 * enough to hold a copy of it, and copies the token into the new
4555 * buffer. The copy is guaranteed to be terminated with '\0'. Note
4556 * that a duplicate buffer is created even for a zero-length token.
4557 *
4558 * Returns a pointer to the newly-allocated duplicate, or a null
4559 * pointer if memory for the duplicate was not available. If
4560 * the lenp argument is a non-null pointer, the length of the token
4561 * (not including the '\0') is returned in *lenp.
4562 *
4563 * If successful, the *buf pointer will be updated to point beyond
4564 * the end of the found token.
4565 *
4566 * Note: uses GFP_KERNEL for allocation.
4567 */
4568static inline char *dup_token(const char **buf, size_t *lenp)
4569{
4570 char *dup;
4571 size_t len;
4572
4573 len = next_token(buf);
Alex Elder4caf35f2012-11-01 08:39:27 -05004574 dup = kmemdup(*buf, len + 1, GFP_KERNEL);
Alex Elderea3352f2012-07-09 21:04:23 -05004575 if (!dup)
4576 return NULL;
Alex Elderea3352f2012-07-09 21:04:23 -05004577 *(dup + len) = '\0';
4578 *buf += len;
4579
4580 if (lenp)
4581 *lenp = len;
4582
4583 return dup;
4584}
4585
4586/*
Alex Elder859c31d2012-10-25 23:34:42 -05004587 * Parse the options provided for an "rbd add" (i.e., rbd image
4588 * mapping) request. These arrive via a write to /sys/bus/rbd/add,
4589 * and the data written is passed here via a NUL-terminated buffer.
4590 * Returns 0 if successful or an error code otherwise.
Alex Elderd22f76e2012-07-12 10:46:35 -05004591 *
Alex Elder859c31d2012-10-25 23:34:42 -05004592 * The information extracted from these options is recorded in
4593 * the other parameters which return dynamically-allocated
4594 * structures:
4595 * ceph_opts
4596 * The address of a pointer that will refer to a ceph options
4597 * structure. Caller must release the returned pointer using
4598 * ceph_destroy_options() when it is no longer needed.
4599 * rbd_opts
4600 * Address of an rbd options pointer. Fully initialized by
4601 * this function; caller must release with kfree().
4602 * spec
4603 * Address of an rbd image specification pointer. Fully
4604 * initialized by this function based on parsed options.
4605 * Caller must release with rbd_spec_put().
4606 *
4607 * The options passed take this form:
4608 * <mon_addrs> <options> <pool_name> <image_name> [<snap_id>]
4609 * where:
4610 * <mon_addrs>
4611 * A comma-separated list of one or more monitor addresses.
4612 * A monitor address is an ip address, optionally followed
4613 * by a port number (separated by a colon).
4614 * I.e.: ip1[:port1][,ip2[:port2]...]
4615 * <options>
4616 * A comma-separated list of ceph and/or rbd options.
4617 * <pool_name>
4618 * The name of the rados pool containing the rbd image.
4619 * <image_name>
4620 * The name of the image in that pool to map.
4621 * <snap_id>
4622 * An optional snapshot id. If provided, the mapping will
4623 * present data from the image at the time that snapshot was
4624 * created. The image head is used if no snapshot id is
4625 * provided. Snapshot mappings are always read-only.
Alex Eldera725f65e2012-02-02 08:13:30 -06004626 */
Alex Elder859c31d2012-10-25 23:34:42 -05004627static int rbd_add_parse_args(const char *buf,
Alex Elderdc79b112012-10-25 23:34:41 -05004628 struct ceph_options **ceph_opts,
Alex Elder859c31d2012-10-25 23:34:42 -05004629 struct rbd_options **opts,
4630 struct rbd_spec **rbd_spec)
Alex Eldera725f65e2012-02-02 08:13:30 -06004631{
Alex Elderd22f76e2012-07-12 10:46:35 -05004632 size_t len;
Alex Elder859c31d2012-10-25 23:34:42 -05004633 char *options;
Alex Elder0ddebc02012-10-25 23:34:41 -05004634 const char *mon_addrs;
Alex Elderecb4dc222013-04-26 09:43:47 -05004635 char *snap_name;
Alex Elder0ddebc02012-10-25 23:34:41 -05004636 size_t mon_addrs_size;
Alex Elder859c31d2012-10-25 23:34:42 -05004637 struct rbd_spec *spec = NULL;
Alex Elder4e9afeba2012-10-25 23:34:41 -05004638 struct rbd_options *rbd_opts = NULL;
Alex Elder859c31d2012-10-25 23:34:42 -05004639 struct ceph_options *copts;
Alex Elderdc79b112012-10-25 23:34:41 -05004640 int ret;
Alex Eldere28fff262012-02-02 08:13:30 -06004641
4642 /* The first four tokens are required */
4643
Alex Elder7ef32142012-02-02 08:13:30 -06004644 len = next_token(&buf);
Alex Elder4fb5d6712012-11-01 10:17:15 -05004645 if (!len) {
4646 rbd_warn(NULL, "no monitor address(es) provided");
4647 return -EINVAL;
4648 }
Alex Elder0ddebc02012-10-25 23:34:41 -05004649 mon_addrs = buf;
Alex Elderf28e5652012-10-25 23:34:41 -05004650 mon_addrs_size = len + 1;
Alex Elder7ef32142012-02-02 08:13:30 -06004651 buf += len;
Alex Eldera725f65e2012-02-02 08:13:30 -06004652
Alex Elderdc79b112012-10-25 23:34:41 -05004653 ret = -EINVAL;
Alex Elderf28e5652012-10-25 23:34:41 -05004654 options = dup_token(&buf, NULL);
4655 if (!options)
Alex Elderdc79b112012-10-25 23:34:41 -05004656 return -ENOMEM;
Alex Elder4fb5d6712012-11-01 10:17:15 -05004657 if (!*options) {
4658 rbd_warn(NULL, "no options provided");
4659 goto out_err;
4660 }
Alex Eldera725f65e2012-02-02 08:13:30 -06004661
Alex Elder859c31d2012-10-25 23:34:42 -05004662 spec = rbd_spec_alloc();
4663 if (!spec)
Alex Elderf28e5652012-10-25 23:34:41 -05004664 goto out_mem;
Alex Elder859c31d2012-10-25 23:34:42 -05004665
4666 spec->pool_name = dup_token(&buf, NULL);
4667 if (!spec->pool_name)
4668 goto out_mem;
Alex Elder4fb5d6712012-11-01 10:17:15 -05004669 if (!*spec->pool_name) {
4670 rbd_warn(NULL, "no pool name provided");
4671 goto out_err;
4672 }
Alex Eldere28fff262012-02-02 08:13:30 -06004673
Alex Elder69e7a022012-11-01 08:39:26 -05004674 spec->image_name = dup_token(&buf, NULL);
Alex Elder859c31d2012-10-25 23:34:42 -05004675 if (!spec->image_name)
Alex Elderf28e5652012-10-25 23:34:41 -05004676 goto out_mem;
Alex Elder4fb5d6712012-11-01 10:17:15 -05004677 if (!*spec->image_name) {
4678 rbd_warn(NULL, "no image name provided");
4679 goto out_err;
4680 }
Alex Eldere28fff262012-02-02 08:13:30 -06004681
Alex Elderf28e5652012-10-25 23:34:41 -05004682 /*
4683 * Snapshot name is optional; default is to use "-"
4684 * (indicating the head/no snapshot).
4685 */
Alex Elder3feeb8942012-08-31 17:29:52 -05004686 len = next_token(&buf);
Alex Elder820a5f32012-07-09 21:04:24 -05004687 if (!len) {
Alex Elder3feeb8942012-08-31 17:29:52 -05004688 buf = RBD_SNAP_HEAD_NAME; /* No snapshot supplied */
4689 len = sizeof (RBD_SNAP_HEAD_NAME) - 1;
Alex Elderf28e5652012-10-25 23:34:41 -05004690 } else if (len > RBD_MAX_SNAP_NAME_LEN) {
Alex Elderdc79b112012-10-25 23:34:41 -05004691 ret = -ENAMETOOLONG;
Alex Elderf28e5652012-10-25 23:34:41 -05004692 goto out_err;
Alex Elder849b4262012-07-09 21:04:24 -05004693 }
Alex Elderecb4dc222013-04-26 09:43:47 -05004694 snap_name = kmemdup(buf, len + 1, GFP_KERNEL);
4695 if (!snap_name)
Alex Elderf28e5652012-10-25 23:34:41 -05004696 goto out_mem;
Alex Elderecb4dc222013-04-26 09:43:47 -05004697 *(snap_name + len) = '\0';
4698 spec->snap_name = snap_name;
Alex Eldere5c35532012-10-25 23:34:41 -05004699
Alex Elder0ddebc02012-10-25 23:34:41 -05004700 /* Initialize all rbd options to the defaults */
Alex Eldere28fff262012-02-02 08:13:30 -06004701
Alex Elder4e9afeba2012-10-25 23:34:41 -05004702 rbd_opts = kzalloc(sizeof (*rbd_opts), GFP_KERNEL);
4703 if (!rbd_opts)
4704 goto out_mem;
4705
4706 rbd_opts->read_only = RBD_READ_ONLY_DEFAULT;
Alex Elderd22f76e2012-07-12 10:46:35 -05004707
Alex Elder859c31d2012-10-25 23:34:42 -05004708 copts = ceph_parse_options(options, mon_addrs,
Alex Elder0ddebc02012-10-25 23:34:41 -05004709 mon_addrs + mon_addrs_size - 1,
Alex Elder4e9afeba2012-10-25 23:34:41 -05004710 parse_rbd_opts_token, rbd_opts);
Alex Elder859c31d2012-10-25 23:34:42 -05004711 if (IS_ERR(copts)) {
4712 ret = PTR_ERR(copts);
Alex Elderdc79b112012-10-25 23:34:41 -05004713 goto out_err;
4714 }
Alex Elder859c31d2012-10-25 23:34:42 -05004715 kfree(options);
4716
4717 *ceph_opts = copts;
Alex Elder4e9afeba2012-10-25 23:34:41 -05004718 *opts = rbd_opts;
Alex Elder859c31d2012-10-25 23:34:42 -05004719 *rbd_spec = spec;
Alex Elder0ddebc02012-10-25 23:34:41 -05004720
Alex Elderdc79b112012-10-25 23:34:41 -05004721 return 0;
Alex Elderf28e5652012-10-25 23:34:41 -05004722out_mem:
Alex Elderdc79b112012-10-25 23:34:41 -05004723 ret = -ENOMEM;
Alex Elderd22f76e2012-07-12 10:46:35 -05004724out_err:
Alex Elder859c31d2012-10-25 23:34:42 -05004725 kfree(rbd_opts);
4726 rbd_spec_put(spec);
Alex Elderf28e5652012-10-25 23:34:41 -05004727 kfree(options);
Alex Elderd22f76e2012-07-12 10:46:35 -05004728
Alex Elderdc79b112012-10-25 23:34:41 -05004729 return ret;
Alex Eldera725f65e2012-02-02 08:13:30 -06004730}
4731
Alex Elder589d30e2012-07-10 20:30:11 -05004732/*
Ilya Dryomov30ba1f02014-05-13 11:19:27 +04004733 * Return pool id (>= 0) or a negative error code.
4734 */
4735static int rbd_add_get_pool_id(struct rbd_client *rbdc, const char *pool_name)
4736{
4737 u64 newest_epoch;
4738 unsigned long timeout = rbdc->client->options->mount_timeout * HZ;
4739 int tries = 0;
4740 int ret;
4741
4742again:
4743 ret = ceph_pg_poolid_by_name(rbdc->client->osdc.osdmap, pool_name);
4744 if (ret == -ENOENT && tries++ < 1) {
4745 ret = ceph_monc_do_get_version(&rbdc->client->monc, "osdmap",
4746 &newest_epoch);
4747 if (ret < 0)
4748 return ret;
4749
4750 if (rbdc->client->osdc.osdmap->epoch < newest_epoch) {
4751 ceph_monc_request_next_osdmap(&rbdc->client->monc);
4752 (void) ceph_monc_wait_osdmap(&rbdc->client->monc,
4753 newest_epoch, timeout);
4754 goto again;
4755 } else {
4756 /* the osdmap we have is new enough */
4757 return -ENOENT;
4758 }
4759 }
4760
4761 return ret;
4762}
4763
4764/*
Alex Elder589d30e2012-07-10 20:30:11 -05004765 * An rbd format 2 image has a unique identifier, distinct from the
4766 * name given to it by the user. Internally, that identifier is
4767 * what's used to specify the names of objects related to the image.
4768 *
4769 * A special "rbd id" object is used to map an rbd image name to its
4770 * id. If that object doesn't exist, then there is no v2 rbd image
4771 * with the supplied name.
4772 *
4773 * This function will record the given rbd_dev's image_id field if
4774 * it can be determined, and in that case will return 0. If any
4775 * errors occur a negative errno will be returned and the rbd_dev's
4776 * image_id field will be unchanged (and should be NULL).
4777 */
4778static int rbd_dev_image_id(struct rbd_device *rbd_dev)
4779{
4780 int ret;
4781 size_t size;
4782 char *object_name;
4783 void *response;
Alex Elderc0fba362013-04-25 23:15:08 -05004784 char *image_id;
Alex Elder2f82ee52012-10-30 19:40:33 -05004785
Alex Elder589d30e2012-07-10 20:30:11 -05004786 /*
Alex Elder2c0d0a12012-10-30 19:40:33 -05004787 * When probing a parent image, the image id is already
4788 * known (and the image name likely is not). There's no
Alex Elderc0fba362013-04-25 23:15:08 -05004789 * need to fetch the image id again in this case. We
4790 * do still need to set the image format though.
Alex Elder2c0d0a12012-10-30 19:40:33 -05004791 */
Alex Elderc0fba362013-04-25 23:15:08 -05004792 if (rbd_dev->spec->image_id) {
4793 rbd_dev->image_format = *rbd_dev->spec->image_id ? 2 : 1;
4794
Alex Elder2c0d0a12012-10-30 19:40:33 -05004795 return 0;
Alex Elderc0fba362013-04-25 23:15:08 -05004796 }
Alex Elder2c0d0a12012-10-30 19:40:33 -05004797
4798 /*
Alex Elder589d30e2012-07-10 20:30:11 -05004799 * First, see if the format 2 image id file exists, and if
4800 * so, get the image's persistent id from it.
4801 */
Alex Elder69e7a022012-11-01 08:39:26 -05004802 size = sizeof (RBD_ID_PREFIX) + strlen(rbd_dev->spec->image_name);
Alex Elder589d30e2012-07-10 20:30:11 -05004803 object_name = kmalloc(size, GFP_NOIO);
4804 if (!object_name)
4805 return -ENOMEM;
Alex Elder0d7dbfc2012-10-25 23:34:41 -05004806 sprintf(object_name, "%s%s", RBD_ID_PREFIX, rbd_dev->spec->image_name);
Alex Elder589d30e2012-07-10 20:30:11 -05004807 dout("rbd id object name is %s\n", object_name);
4808
4809 /* Response will be an encoded string, which includes a length */
4810
4811 size = sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX;
4812 response = kzalloc(size, GFP_NOIO);
4813 if (!response) {
4814 ret = -ENOMEM;
4815 goto out;
4816 }
4817
Alex Elderc0fba362013-04-25 23:15:08 -05004818 /* If it doesn't exist we'll assume it's a format 1 image */
4819
Alex Elder36be9a72013-01-19 00:30:28 -06004820 ret = rbd_obj_method_sync(rbd_dev, object_name,
Alex Elder41579762013-04-21 12:14:45 -05004821 "rbd", "get_id", NULL, 0,
Alex Eldere2a58ee2013-04-30 00:44:33 -05004822 response, RBD_IMAGE_ID_LEN_MAX);
Alex Elder36be9a72013-01-19 00:30:28 -06004823 dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
Alex Elderc0fba362013-04-25 23:15:08 -05004824 if (ret == -ENOENT) {
4825 image_id = kstrdup("", GFP_KERNEL);
4826 ret = image_id ? 0 : -ENOMEM;
4827 if (!ret)
4828 rbd_dev->image_format = 1;
4829 } else if (ret > sizeof (__le32)) {
4830 void *p = response;
Alex Elder589d30e2012-07-10 20:30:11 -05004831
Alex Elderc0fba362013-04-25 23:15:08 -05004832 image_id = ceph_extract_encoded_string(&p, p + ret,
Alex Elder979ed482012-11-01 08:39:26 -05004833 NULL, GFP_NOIO);
Duan Jiong461f7582014-04-11 16:38:12 +08004834 ret = PTR_ERR_OR_ZERO(image_id);
Alex Elderc0fba362013-04-25 23:15:08 -05004835 if (!ret)
4836 rbd_dev->image_format = 2;
Alex Elder589d30e2012-07-10 20:30:11 -05004837 } else {
Alex Elderc0fba362013-04-25 23:15:08 -05004838 ret = -EINVAL;
4839 }
4840
4841 if (!ret) {
4842 rbd_dev->spec->image_id = image_id;
4843 dout("image_id is %s\n", image_id);
Alex Elder589d30e2012-07-10 20:30:11 -05004844 }
4845out:
4846 kfree(response);
4847 kfree(object_name);
4848
4849 return ret;
4850}
4851
Alex Elder3abef3b2013-05-13 20:35:37 -05004852/*
4853 * Undo whatever state changes are made by v1 or v2 header info
4854 * call.
4855 */
Alex Elder6fd48b32013-04-28 23:32:34 -05004856static void rbd_dev_unprobe(struct rbd_device *rbd_dev)
4857{
4858 struct rbd_image_header *header;
4859
Alex Elder392a9da2013-05-06 17:40:33 -05004860 /* Drop parent reference unless it's already been done (or none) */
4861
4862 if (rbd_dev->parent_overlap)
4863 rbd_dev_parent_put(rbd_dev);
Alex Elder6fd48b32013-04-28 23:32:34 -05004864
4865 /* Free dynamic fields from the header, then zero it out */
4866
4867 header = &rbd_dev->header;
Alex Elder812164f82013-04-30 00:44:32 -05004868 ceph_put_snap_context(header->snapc);
Alex Elder6fd48b32013-04-28 23:32:34 -05004869 kfree(header->snap_sizes);
4870 kfree(header->snap_names);
4871 kfree(header->object_prefix);
4872 memset(header, 0, sizeof (*header));
4873}
4874
Alex Elder2df3fac2013-05-06 09:51:30 -05004875static int rbd_dev_v2_header_onetime(struct rbd_device *rbd_dev)
Alex Eldera30b71b2012-07-10 20:30:11 -05004876{
4877 int ret;
Alex Eldera30b71b2012-07-10 20:30:11 -05004878
Alex Elder1e130192012-07-03 16:01:19 -05004879 ret = rbd_dev_v2_object_prefix(rbd_dev);
Alex Elder57385b52013-04-21 12:14:45 -05004880 if (ret)
Alex Elder1e130192012-07-03 16:01:19 -05004881 goto out_err;
Alex Elderb1b54022012-07-03 16:01:19 -05004882
Alex Elder2df3fac2013-05-06 09:51:30 -05004883 /*
4884 * Get the and check features for the image. Currently the
4885 * features are assumed to never change.
4886 */
Alex Elderb1b54022012-07-03 16:01:19 -05004887 ret = rbd_dev_v2_features(rbd_dev);
Alex Elder57385b52013-04-21 12:14:45 -05004888 if (ret)
Alex Elderb1b54022012-07-03 16:01:19 -05004889 goto out_err;
Alex Elder35d489f2012-07-03 16:01:19 -05004890
Alex Eldercc070d52013-04-21 12:14:45 -05004891 /* If the image supports fancy striping, get its parameters */
4892
4893 if (rbd_dev->header.features & RBD_FEATURE_STRIPINGV2) {
4894 ret = rbd_dev_v2_striping_info(rbd_dev);
4895 if (ret < 0)
4896 goto out_err;
4897 }
Alex Elder2df3fac2013-05-06 09:51:30 -05004898 /* No support for crypto and compression type format 2 images */
Alex Eldera30b71b2012-07-10 20:30:11 -05004899
Alex Elder35152972012-08-31 17:29:55 -05004900 return 0;
Alex Elder9d475de52012-07-03 16:01:19 -05004901out_err:
Alex Elder642a2532013-05-06 17:40:33 -05004902 rbd_dev->header.features = 0;
Alex Elder1e130192012-07-03 16:01:19 -05004903 kfree(rbd_dev->header.object_prefix);
4904 rbd_dev->header.object_prefix = NULL;
Alex Elder9d475de52012-07-03 16:01:19 -05004905
4906 return ret;
Alex Eldera30b71b2012-07-10 20:30:11 -05004907}
4908
Alex Elder124afba2013-04-26 15:44:36 -05004909static int rbd_dev_probe_parent(struct rbd_device *rbd_dev)
Alex Elder83a06262012-10-30 15:47:17 -05004910{
Alex Elder2f82ee52012-10-30 19:40:33 -05004911 struct rbd_device *parent = NULL;
Alex Elder124afba2013-04-26 15:44:36 -05004912 struct rbd_spec *parent_spec;
4913 struct rbd_client *rbdc;
4914 int ret;
4915
4916 if (!rbd_dev->parent_spec)
4917 return 0;
4918 /*
4919 * We need to pass a reference to the client and the parent
4920 * spec when creating the parent rbd_dev. Images related by
4921 * parent/child relationships always share both.
4922 */
4923 parent_spec = rbd_spec_get(rbd_dev->parent_spec);
4924 rbdc = __rbd_get_client(rbd_dev->rbd_client);
4925
4926 ret = -ENOMEM;
4927 parent = rbd_dev_create(rbdc, parent_spec);
4928 if (!parent)
4929 goto out_err;
4930
Alex Elder1f3ef782013-05-06 17:40:33 -05004931 ret = rbd_dev_image_probe(parent, false);
Alex Elder124afba2013-04-26 15:44:36 -05004932 if (ret < 0)
4933 goto out_err;
4934 rbd_dev->parent = parent;
Alex Eldera2acd002013-05-08 22:50:04 -05004935 atomic_set(&rbd_dev->parent_ref, 1);
Alex Elder124afba2013-04-26 15:44:36 -05004936
4937 return 0;
4938out_err:
4939 if (parent) {
Alex Elderfb65d2282013-05-08 22:50:04 -05004940 rbd_dev_unparent(rbd_dev);
Alex Elder124afba2013-04-26 15:44:36 -05004941 kfree(rbd_dev->header_name);
4942 rbd_dev_destroy(parent);
4943 } else {
4944 rbd_put_client(rbdc);
4945 rbd_spec_put(parent_spec);
4946 }
4947
4948 return ret;
4949}
4950
Alex Elder200a6a82013-04-28 23:32:34 -05004951static int rbd_dev_device_setup(struct rbd_device *rbd_dev)
Alex Elder124afba2013-04-26 15:44:36 -05004952{
Alex Elder83a06262012-10-30 15:47:17 -05004953 int ret;
Alex Elder83a06262012-10-30 15:47:17 -05004954
Ilya Dryomovf8a22fc2013-12-13 15:28:57 +02004955 /* Get an id and fill in device name. */
Alex Elder83a06262012-10-30 15:47:17 -05004956
Ilya Dryomovf8a22fc2013-12-13 15:28:57 +02004957 ret = rbd_dev_id_get(rbd_dev);
4958 if (ret)
4959 return ret;
4960
Alex Elder83a06262012-10-30 15:47:17 -05004961 BUILD_BUG_ON(DEV_NAME_LEN
4962 < sizeof (RBD_DRV_NAME) + MAX_INT_FORMAT_WIDTH);
4963 sprintf(rbd_dev->name, "%s%d", RBD_DRV_NAME, rbd_dev->dev_id);
4964
Ilya Dryomov9b60e702013-12-13 15:28:57 +02004965 /* Record our major and minor device numbers. */
Alex Elder83a06262012-10-30 15:47:17 -05004966
Ilya Dryomov9b60e702013-12-13 15:28:57 +02004967 if (!single_major) {
4968 ret = register_blkdev(0, rbd_dev->name);
4969 if (ret < 0)
4970 goto err_out_id;
4971
4972 rbd_dev->major = ret;
4973 rbd_dev->minor = 0;
4974 } else {
4975 rbd_dev->major = rbd_major;
4976 rbd_dev->minor = rbd_dev_id_to_minor(rbd_dev->dev_id);
4977 }
Alex Elder83a06262012-10-30 15:47:17 -05004978
4979 /* Set up the blkdev mapping. */
4980
4981 ret = rbd_init_disk(rbd_dev);
4982 if (ret)
4983 goto err_out_blkdev;
4984
Alex Elderf35a4de2013-05-06 09:51:29 -05004985 ret = rbd_dev_mapping_set(rbd_dev);
Alex Elder83a06262012-10-30 15:47:17 -05004986 if (ret)
4987 goto err_out_disk;
Alex Elderf35a4de2013-05-06 09:51:29 -05004988 set_capacity(rbd_dev->disk, rbd_dev->mapping.size / SECTOR_SIZE);
4989
4990 ret = rbd_bus_add_dev(rbd_dev);
4991 if (ret)
4992 goto err_out_mapping;
Alex Elder83a06262012-10-30 15:47:17 -05004993
Alex Elder83a06262012-10-30 15:47:17 -05004994 /* Everything's ready. Announce the disk to the world. */
4995
Alex Elder129b79d2013-04-26 15:44:36 -05004996 set_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags);
Alex Elder83a06262012-10-30 15:47:17 -05004997 add_disk(rbd_dev->disk);
4998
4999 pr_info("%s: added with size 0x%llx\n", rbd_dev->disk->disk_name,
5000 (unsigned long long) rbd_dev->mapping.size);
5001
5002 return ret;
Alex Elder2f82ee52012-10-30 19:40:33 -05005003
Alex Elderf35a4de2013-05-06 09:51:29 -05005004err_out_mapping:
5005 rbd_dev_mapping_clear(rbd_dev);
Alex Elder83a06262012-10-30 15:47:17 -05005006err_out_disk:
5007 rbd_free_disk(rbd_dev);
5008err_out_blkdev:
Ilya Dryomov9b60e702013-12-13 15:28:57 +02005009 if (!single_major)
5010 unregister_blkdev(rbd_dev->major, rbd_dev->name);
Alex Elder83a06262012-10-30 15:47:17 -05005011err_out_id:
5012 rbd_dev_id_put(rbd_dev);
Alex Elderd1cf5782013-04-27 09:59:30 -05005013 rbd_dev_mapping_clear(rbd_dev);
Alex Elder83a06262012-10-30 15:47:17 -05005014
5015 return ret;
5016}
5017
Alex Elder332bb122013-04-27 09:59:30 -05005018static int rbd_dev_header_name(struct rbd_device *rbd_dev)
5019{
5020 struct rbd_spec *spec = rbd_dev->spec;
5021 size_t size;
5022
5023 /* Record the header object name for this rbd image. */
5024
5025 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
5026
5027 if (rbd_dev->image_format == 1)
5028 size = strlen(spec->image_name) + sizeof (RBD_SUFFIX);
5029 else
5030 size = sizeof (RBD_HEADER_PREFIX) + strlen(spec->image_id);
5031
5032 rbd_dev->header_name = kmalloc(size, GFP_KERNEL);
5033 if (!rbd_dev->header_name)
5034 return -ENOMEM;
5035
5036 if (rbd_dev->image_format == 1)
5037 sprintf(rbd_dev->header_name, "%s%s",
5038 spec->image_name, RBD_SUFFIX);
5039 else
5040 sprintf(rbd_dev->header_name, "%s%s",
5041 RBD_HEADER_PREFIX, spec->image_id);
5042 return 0;
5043}
5044
Alex Elder200a6a82013-04-28 23:32:34 -05005045static void rbd_dev_image_release(struct rbd_device *rbd_dev)
5046{
Alex Elder6fd48b32013-04-28 23:32:34 -05005047 rbd_dev_unprobe(rbd_dev);
Alex Elder200a6a82013-04-28 23:32:34 -05005048 kfree(rbd_dev->header_name);
Alex Elder6fd48b32013-04-28 23:32:34 -05005049 rbd_dev->header_name = NULL;
5050 rbd_dev->image_format = 0;
5051 kfree(rbd_dev->spec->image_id);
5052 rbd_dev->spec->image_id = NULL;
5053
Alex Elder200a6a82013-04-28 23:32:34 -05005054 rbd_dev_destroy(rbd_dev);
5055}
5056
Alex Eldera30b71b2012-07-10 20:30:11 -05005057/*
5058 * Probe for the existence of the header object for the given rbd
Alex Elder1f3ef782013-05-06 17:40:33 -05005059 * device. If this image is the one being mapped (i.e., not a
5060 * parent), initiate a watch on its header object before using that
5061 * object to get detailed information about the rbd image.
Alex Eldera30b71b2012-07-10 20:30:11 -05005062 */
Alex Elder1f3ef782013-05-06 17:40:33 -05005063static int rbd_dev_image_probe(struct rbd_device *rbd_dev, bool mapping)
Alex Eldera30b71b2012-07-10 20:30:11 -05005064{
5065 int ret;
5066
5067 /*
Alex Elder3abef3b2013-05-13 20:35:37 -05005068 * Get the id from the image id object. Unless there's an
5069 * error, rbd_dev->spec->image_id will be filled in with
5070 * a dynamically-allocated string, and rbd_dev->image_format
5071 * will be set to either 1 or 2.
Alex Eldera30b71b2012-07-10 20:30:11 -05005072 */
5073 ret = rbd_dev_image_id(rbd_dev);
5074 if (ret)
Alex Elderc0fba362013-04-25 23:15:08 -05005075 return ret;
5076 rbd_assert(rbd_dev->spec->image_id);
5077 rbd_assert(rbd_image_format_valid(rbd_dev->image_format));
5078
Alex Elder332bb122013-04-27 09:59:30 -05005079 ret = rbd_dev_header_name(rbd_dev);
5080 if (ret)
5081 goto err_out_format;
5082
Alex Elder1f3ef782013-05-06 17:40:33 -05005083 if (mapping) {
Ilya Dryomovfca27062013-12-16 18:02:40 +02005084 ret = rbd_dev_header_watch_sync(rbd_dev);
Alex Elder1f3ef782013-05-06 17:40:33 -05005085 if (ret)
5086 goto out_header_name;
5087 }
Alex Elderb644de22013-04-27 09:59:31 -05005088
Alex Elderc0fba362013-04-25 23:15:08 -05005089 if (rbd_dev->image_format == 1)
Alex Elder99a41eb2013-05-06 09:51:30 -05005090 ret = rbd_dev_v1_header_info(rbd_dev);
Alex Eldera30b71b2012-07-10 20:30:11 -05005091 else
Alex Elder2df3fac2013-05-06 09:51:30 -05005092 ret = rbd_dev_v2_header_info(rbd_dev);
Alex Elder5655c4d2013-04-25 23:15:08 -05005093 if (ret)
Alex Elderb644de22013-04-27 09:59:31 -05005094 goto err_out_watch;
Alex Elder83a06262012-10-30 15:47:17 -05005095
Alex Elder9bb81c92013-04-27 09:59:30 -05005096 ret = rbd_dev_spec_update(rbd_dev);
5097 if (ret)
Alex Elder33dca392013-04-30 00:44:33 -05005098 goto err_out_probe;
Alex Elder9bb81c92013-04-27 09:59:30 -05005099
5100 ret = rbd_dev_probe_parent(rbd_dev);
Alex Elder30d60ba2013-05-06 09:51:30 -05005101 if (ret)
5102 goto err_out_probe;
Alex Elder83a06262012-10-30 15:47:17 -05005103
Alex Elder30d60ba2013-05-06 09:51:30 -05005104 dout("discovered format %u image, header name is %s\n",
5105 rbd_dev->image_format, rbd_dev->header_name);
5106
5107 return 0;
Alex Elder6fd48b32013-04-28 23:32:34 -05005108err_out_probe:
5109 rbd_dev_unprobe(rbd_dev);
Alex Elderb644de22013-04-27 09:59:31 -05005110err_out_watch:
Ilya Dryomovfca27062013-12-16 18:02:40 +02005111 if (mapping)
5112 rbd_dev_header_unwatch_sync(rbd_dev);
Alex Elder332bb122013-04-27 09:59:30 -05005113out_header_name:
5114 kfree(rbd_dev->header_name);
5115 rbd_dev->header_name = NULL;
5116err_out_format:
5117 rbd_dev->image_format = 0;
Alex Elder5655c4d2013-04-25 23:15:08 -05005118 kfree(rbd_dev->spec->image_id);
5119 rbd_dev->spec->image_id = NULL;
5120
5121 dout("probe failed, returning %d\n", ret);
5122
5123 return ret;
Alex Eldera30b71b2012-07-10 20:30:11 -05005124}
5125
Ilya Dryomov9b60e702013-12-13 15:28:57 +02005126static ssize_t do_rbd_add(struct bus_type *bus,
5127 const char *buf,
5128 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005129{
Alex Eldercb8627c2012-07-09 21:04:23 -05005130 struct rbd_device *rbd_dev = NULL;
Alex Elderdc79b112012-10-25 23:34:41 -05005131 struct ceph_options *ceph_opts = NULL;
Alex Elder4e9afeba2012-10-25 23:34:41 -05005132 struct rbd_options *rbd_opts = NULL;
Alex Elder859c31d2012-10-25 23:34:42 -05005133 struct rbd_spec *spec = NULL;
Alex Elder9d3997f2012-10-25 23:34:42 -05005134 struct rbd_client *rbdc;
Alex Elder51344a32013-05-06 07:40:30 -05005135 bool read_only;
Alex Elder27cc2592012-02-02 08:13:30 -06005136 int rc = -ENOMEM;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005137
5138 if (!try_module_get(THIS_MODULE))
5139 return -ENODEV;
5140
Alex Eldera725f65e2012-02-02 08:13:30 -06005141 /* parse add command */
Alex Elder859c31d2012-10-25 23:34:42 -05005142 rc = rbd_add_parse_args(buf, &ceph_opts, &rbd_opts, &spec);
Alex Elderdc79b112012-10-25 23:34:41 -05005143 if (rc < 0)
Alex Elderbd4ba652012-10-25 23:34:42 -05005144 goto err_out_module;
Alex Elder51344a32013-05-06 07:40:30 -05005145 read_only = rbd_opts->read_only;
5146 kfree(rbd_opts);
5147 rbd_opts = NULL; /* done with this */
Alex Eldera725f65e2012-02-02 08:13:30 -06005148
Alex Elder9d3997f2012-10-25 23:34:42 -05005149 rbdc = rbd_get_client(ceph_opts);
5150 if (IS_ERR(rbdc)) {
5151 rc = PTR_ERR(rbdc);
Alex Elder0ddebc02012-10-25 23:34:41 -05005152 goto err_out_args;
Alex Elder9d3997f2012-10-25 23:34:42 -05005153 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005154
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005155 /* pick the pool */
Ilya Dryomov30ba1f02014-05-13 11:19:27 +04005156 rc = rbd_add_get_pool_id(rbdc, spec->pool_name);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005157 if (rc < 0)
5158 goto err_out_client;
Alex Elderc0cd10db2013-04-26 09:43:47 -05005159 spec->pool_id = (u64)rc;
Alex Elder859c31d2012-10-25 23:34:42 -05005160
Alex Elder0903e872012-11-14 12:25:19 -06005161 /* The ceph file layout needs to fit pool id in 32 bits */
5162
Alex Elderc0cd10db2013-04-26 09:43:47 -05005163 if (spec->pool_id > (u64)U32_MAX) {
5164 rbd_warn(NULL, "pool id too large (%llu > %u)\n",
5165 (unsigned long long)spec->pool_id, U32_MAX);
Alex Elder0903e872012-11-14 12:25:19 -06005166 rc = -EIO;
5167 goto err_out_client;
5168 }
5169
Alex Elderc53d5892012-10-25 23:34:42 -05005170 rbd_dev = rbd_dev_create(rbdc, spec);
Alex Elderbd4ba652012-10-25 23:34:42 -05005171 if (!rbd_dev)
5172 goto err_out_client;
Alex Elderc53d5892012-10-25 23:34:42 -05005173 rbdc = NULL; /* rbd_dev now owns this */
5174 spec = NULL; /* rbd_dev now owns this */
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005175
Alex Elder1f3ef782013-05-06 17:40:33 -05005176 rc = rbd_dev_image_probe(rbd_dev, true);
Alex Eldera30b71b2012-07-10 20:30:11 -05005177 if (rc < 0)
Alex Elderc53d5892012-10-25 23:34:42 -05005178 goto err_out_rbd_dev;
Alex Elder05fd6f62012-08-29 17:11:07 -05005179
Alex Elder7ce4eef2013-05-06 17:40:33 -05005180 /* If we are mapping a snapshot it must be marked read-only */
5181
5182 if (rbd_dev->spec->snap_id != CEPH_NOSNAP)
5183 read_only = true;
5184 rbd_dev->mapping.read_only = read_only;
5185
Alex Elderb536f692013-04-28 23:32:34 -05005186 rc = rbd_dev_device_setup(rbd_dev);
Alex Elder3abef3b2013-05-13 20:35:37 -05005187 if (rc) {
Ilya Dryomove37180c2013-12-16 18:02:41 +02005188 /*
5189 * rbd_dev_header_unwatch_sync() can't be moved into
5190 * rbd_dev_image_release() without refactoring, see
5191 * commit 1f3ef78861ac.
5192 */
5193 rbd_dev_header_unwatch_sync(rbd_dev);
Alex Elder3abef3b2013-05-13 20:35:37 -05005194 rbd_dev_image_release(rbd_dev);
5195 goto err_out_module;
5196 }
Alex Elderb536f692013-04-28 23:32:34 -05005197
Alex Elder3abef3b2013-05-13 20:35:37 -05005198 return count;
5199
Alex Elderc53d5892012-10-25 23:34:42 -05005200err_out_rbd_dev:
5201 rbd_dev_destroy(rbd_dev);
Alex Elderbd4ba652012-10-25 23:34:42 -05005202err_out_client:
Alex Elder9d3997f2012-10-25 23:34:42 -05005203 rbd_put_client(rbdc);
Alex Elder0ddebc02012-10-25 23:34:41 -05005204err_out_args:
Alex Elder859c31d2012-10-25 23:34:42 -05005205 rbd_spec_put(spec);
Alex Elderbd4ba652012-10-25 23:34:42 -05005206err_out_module:
5207 module_put(THIS_MODULE);
Alex Elder27cc2592012-02-02 08:13:30 -06005208
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005209 dout("Error adding device %s\n", buf);
Alex Elder27cc2592012-02-02 08:13:30 -06005210
Alex Elderc0cd10db2013-04-26 09:43:47 -05005211 return (ssize_t)rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005212}
5213
Ilya Dryomov9b60e702013-12-13 15:28:57 +02005214static ssize_t rbd_add(struct bus_type *bus,
5215 const char *buf,
5216 size_t count)
5217{
5218 if (single_major)
5219 return -EINVAL;
5220
5221 return do_rbd_add(bus, buf, count);
5222}
5223
5224static ssize_t rbd_add_single_major(struct bus_type *bus,
5225 const char *buf,
5226 size_t count)
5227{
5228 return do_rbd_add(bus, buf, count);
5229}
5230
Alex Elder200a6a82013-04-28 23:32:34 -05005231static void rbd_dev_device_release(struct device *dev)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005232{
Alex Elder593a9e72012-02-07 12:03:37 -06005233 struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005234
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005235 rbd_free_disk(rbd_dev);
Alex Elder200a6a82013-04-28 23:32:34 -05005236 clear_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags);
Alex Elder6d80b132013-05-06 07:40:30 -05005237 rbd_dev_mapping_clear(rbd_dev);
Ilya Dryomov9b60e702013-12-13 15:28:57 +02005238 if (!single_major)
5239 unregister_blkdev(rbd_dev->major, rbd_dev->name);
Alex Eldere2839302012-08-29 17:11:06 -05005240 rbd_dev_id_put(rbd_dev);
Alex Elderd1cf5782013-04-27 09:59:30 -05005241 rbd_dev_mapping_clear(rbd_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005242}
5243
Alex Elder05a46af2013-04-26 15:44:36 -05005244static void rbd_dev_remove_parent(struct rbd_device *rbd_dev)
5245{
Alex Elderad945fc2013-04-26 15:44:36 -05005246 while (rbd_dev->parent) {
Alex Elder05a46af2013-04-26 15:44:36 -05005247 struct rbd_device *first = rbd_dev;
5248 struct rbd_device *second = first->parent;
5249 struct rbd_device *third;
5250
5251 /*
5252 * Follow to the parent with no grandparent and
5253 * remove it.
5254 */
5255 while (second && (third = second->parent)) {
5256 first = second;
5257 second = third;
5258 }
Alex Elderad945fc2013-04-26 15:44:36 -05005259 rbd_assert(second);
Alex Elder8ad42cd2013-04-28 23:32:34 -05005260 rbd_dev_image_release(second);
Alex Elderad945fc2013-04-26 15:44:36 -05005261 first->parent = NULL;
5262 first->parent_overlap = 0;
5263
5264 rbd_assert(first->parent_spec);
Alex Elder05a46af2013-04-26 15:44:36 -05005265 rbd_spec_put(first->parent_spec);
5266 first->parent_spec = NULL;
Alex Elder05a46af2013-04-26 15:44:36 -05005267 }
5268}
5269
Ilya Dryomov9b60e702013-12-13 15:28:57 +02005270static ssize_t do_rbd_remove(struct bus_type *bus,
5271 const char *buf,
5272 size_t count)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005273{
5274 struct rbd_device *rbd_dev = NULL;
Alex Elder751cc0e2013-05-31 15:17:01 -05005275 struct list_head *tmp;
5276 int dev_id;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005277 unsigned long ul;
Alex Elder82a442d2013-05-31 17:40:44 -05005278 bool already = false;
Alex Elder0d8189e2013-04-27 09:59:30 -05005279 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005280
Jingoo Hanbb8e0e82013-09-11 14:20:07 -07005281 ret = kstrtoul(buf, 10, &ul);
Alex Elder0d8189e2013-04-27 09:59:30 -05005282 if (ret)
5283 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005284
5285 /* convert to int; abort if we lost anything in the conversion */
Alex Elder751cc0e2013-05-31 15:17:01 -05005286 dev_id = (int)ul;
5287 if (dev_id != ul)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005288 return -EINVAL;
5289
Alex Elder751cc0e2013-05-31 15:17:01 -05005290 ret = -ENOENT;
5291 spin_lock(&rbd_dev_list_lock);
5292 list_for_each(tmp, &rbd_dev_list) {
5293 rbd_dev = list_entry(tmp, struct rbd_device, node);
5294 if (rbd_dev->dev_id == dev_id) {
5295 ret = 0;
5296 break;
5297 }
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005298 }
Alex Elder751cc0e2013-05-31 15:17:01 -05005299 if (!ret) {
5300 spin_lock_irq(&rbd_dev->lock);
5301 if (rbd_dev->open_count)
5302 ret = -EBUSY;
5303 else
Alex Elder82a442d2013-05-31 17:40:44 -05005304 already = test_and_set_bit(RBD_DEV_FLAG_REMOVING,
5305 &rbd_dev->flags);
Alex Elder751cc0e2013-05-31 15:17:01 -05005306 spin_unlock_irq(&rbd_dev->lock);
5307 }
5308 spin_unlock(&rbd_dev_list_lock);
Alex Elder82a442d2013-05-31 17:40:44 -05005309 if (ret < 0 || already)
Alex Elder1ba0f1e2013-05-31 15:17:01 -05005310 return ret;
Alex Elder751cc0e2013-05-31 15:17:01 -05005311
Ilya Dryomovfca27062013-12-16 18:02:40 +02005312 rbd_dev_header_unwatch_sync(rbd_dev);
Josh Durgin9abc5992013-08-29 17:31:03 -07005313 /*
5314 * flush remaining watch callbacks - these must be complete
5315 * before the osd_client is shutdown
5316 */
5317 dout("%s: flushing notifies", __func__);
5318 ceph_osdc_flush_notifies(&rbd_dev->rbd_client->client->osdc);
Ilya Dryomovfca27062013-12-16 18:02:40 +02005319
Josh Durgin98752012013-08-29 17:26:31 -07005320 /*
5321 * Don't free anything from rbd_dev->disk until after all
5322 * notifies are completely processed. Otherwise
5323 * rbd_bus_del_dev() will race with rbd_watch_cb(), resulting
5324 * in a potential use after free of rbd_dev->disk or rbd_dev.
5325 */
5326 rbd_bus_del_dev(rbd_dev);
Alex Elder8ad42cd2013-04-28 23:32:34 -05005327 rbd_dev_image_release(rbd_dev);
Alex Elder79ab7552013-04-28 23:32:34 -05005328 module_put(THIS_MODULE);
Alex Elderaafb2302012-09-06 16:00:54 -05005329
Alex Elder1ba0f1e2013-05-31 15:17:01 -05005330 return count;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005331}
5332
Ilya Dryomov9b60e702013-12-13 15:28:57 +02005333static ssize_t rbd_remove(struct bus_type *bus,
5334 const char *buf,
5335 size_t count)
5336{
5337 if (single_major)
5338 return -EINVAL;
5339
5340 return do_rbd_remove(bus, buf, count);
5341}
5342
5343static ssize_t rbd_remove_single_major(struct bus_type *bus,
5344 const char *buf,
5345 size_t count)
5346{
5347 return do_rbd_remove(bus, buf, count);
5348}
5349
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005350/*
5351 * create control files in sysfs
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005352 * /sys/bus/rbd/...
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005353 */
5354static int rbd_sysfs_init(void)
5355{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005356 int ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005357
Alex Elderfed4c142012-02-07 12:03:36 -06005358 ret = device_register(&rbd_root_dev);
Alex Elder21079782012-01-24 10:08:36 -06005359 if (ret < 0)
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005360 return ret;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005361
Alex Elderfed4c142012-02-07 12:03:36 -06005362 ret = bus_register(&rbd_bus_type);
5363 if (ret < 0)
5364 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005365
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005366 return ret;
5367}
5368
5369static void rbd_sysfs_cleanup(void)
5370{
Yehuda Sadehdfc56062010-11-19 14:51:04 -08005371 bus_unregister(&rbd_bus_type);
Alex Elderfed4c142012-02-07 12:03:36 -06005372 device_unregister(&rbd_root_dev);
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005373}
5374
Alex Elder1c2a9df2013-05-01 12:43:03 -05005375static int rbd_slab_init(void)
5376{
5377 rbd_assert(!rbd_img_request_cache);
5378 rbd_img_request_cache = kmem_cache_create("rbd_img_request",
5379 sizeof (struct rbd_img_request),
5380 __alignof__(struct rbd_img_request),
5381 0, NULL);
Alex Elder868311b2013-05-01 12:43:03 -05005382 if (!rbd_img_request_cache)
5383 return -ENOMEM;
5384
5385 rbd_assert(!rbd_obj_request_cache);
5386 rbd_obj_request_cache = kmem_cache_create("rbd_obj_request",
5387 sizeof (struct rbd_obj_request),
5388 __alignof__(struct rbd_obj_request),
5389 0, NULL);
Alex Elder78c2a442013-05-01 12:43:04 -05005390 if (!rbd_obj_request_cache)
5391 goto out_err;
5392
5393 rbd_assert(!rbd_segment_name_cache);
5394 rbd_segment_name_cache = kmem_cache_create("rbd_segment_name",
Ilya Dryomov2d0ebc52014-01-27 17:40:18 +02005395 CEPH_MAX_OID_NAME_LEN + 1, 1, 0, NULL);
Alex Elder78c2a442013-05-01 12:43:04 -05005396 if (rbd_segment_name_cache)
Alex Elder1c2a9df2013-05-01 12:43:03 -05005397 return 0;
Alex Elder78c2a442013-05-01 12:43:04 -05005398out_err:
5399 if (rbd_obj_request_cache) {
5400 kmem_cache_destroy(rbd_obj_request_cache);
5401 rbd_obj_request_cache = NULL;
5402 }
Alex Elder1c2a9df2013-05-01 12:43:03 -05005403
Alex Elder868311b2013-05-01 12:43:03 -05005404 kmem_cache_destroy(rbd_img_request_cache);
5405 rbd_img_request_cache = NULL;
5406
Alex Elder1c2a9df2013-05-01 12:43:03 -05005407 return -ENOMEM;
5408}
5409
5410static void rbd_slab_exit(void)
5411{
Alex Elder78c2a442013-05-01 12:43:04 -05005412 rbd_assert(rbd_segment_name_cache);
5413 kmem_cache_destroy(rbd_segment_name_cache);
5414 rbd_segment_name_cache = NULL;
5415
Alex Elder868311b2013-05-01 12:43:03 -05005416 rbd_assert(rbd_obj_request_cache);
5417 kmem_cache_destroy(rbd_obj_request_cache);
5418 rbd_obj_request_cache = NULL;
5419
Alex Elder1c2a9df2013-05-01 12:43:03 -05005420 rbd_assert(rbd_img_request_cache);
5421 kmem_cache_destroy(rbd_img_request_cache);
5422 rbd_img_request_cache = NULL;
5423}
5424
Alex Eldercc344fa2013-02-19 12:25:56 -06005425static int __init rbd_init(void)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005426{
5427 int rc;
5428
Alex Elder1e32d342013-01-30 11:13:33 -06005429 if (!libceph_compatible(NULL)) {
5430 rbd_warn(NULL, "libceph incompatibility (quitting)");
Alex Elder1e32d342013-01-30 11:13:33 -06005431 return -EINVAL;
5432 }
Ilya Dryomove1b4d962013-12-13 15:28:57 +02005433
Alex Elder1c2a9df2013-05-01 12:43:03 -05005434 rc = rbd_slab_init();
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005435 if (rc)
5436 return rc;
Ilya Dryomove1b4d962013-12-13 15:28:57 +02005437
Ilya Dryomov9b60e702013-12-13 15:28:57 +02005438 if (single_major) {
5439 rbd_major = register_blkdev(0, RBD_DRV_NAME);
5440 if (rbd_major < 0) {
5441 rc = rbd_major;
5442 goto err_out_slab;
5443 }
5444 }
5445
Alex Elder1c2a9df2013-05-01 12:43:03 -05005446 rc = rbd_sysfs_init();
5447 if (rc)
Ilya Dryomov9b60e702013-12-13 15:28:57 +02005448 goto err_out_blkdev;
Alex Elder1c2a9df2013-05-01 12:43:03 -05005449
Ilya Dryomov9b60e702013-12-13 15:28:57 +02005450 if (single_major)
5451 pr_info("loaded (major %d)\n", rbd_major);
5452 else
5453 pr_info("loaded\n");
5454
Ilya Dryomove1b4d962013-12-13 15:28:57 +02005455 return 0;
5456
Ilya Dryomov9b60e702013-12-13 15:28:57 +02005457err_out_blkdev:
5458 if (single_major)
5459 unregister_blkdev(rbd_major, RBD_DRV_NAME);
Ilya Dryomove1b4d962013-12-13 15:28:57 +02005460err_out_slab:
5461 rbd_slab_exit();
Alex Elder1c2a9df2013-05-01 12:43:03 -05005462 return rc;
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005463}
5464
Alex Eldercc344fa2013-02-19 12:25:56 -06005465static void __exit rbd_exit(void)
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005466{
5467 rbd_sysfs_cleanup();
Ilya Dryomov9b60e702013-12-13 15:28:57 +02005468 if (single_major)
5469 unregister_blkdev(rbd_major, RBD_DRV_NAME);
Alex Elder1c2a9df2013-05-01 12:43:03 -05005470 rbd_slab_exit();
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005471}
5472
5473module_init(rbd_init);
5474module_exit(rbd_exit);
5475
Alex Elderd552c612013-05-31 20:13:09 -05005476MODULE_AUTHOR("Alex Elder <elder@inktank.com>");
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005477MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
5478MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005479/* following authorship retained from original osdblk.c */
5480MODULE_AUTHOR("Jeff Garzik <jeff@garzik.org>");
5481
Ilya Dryomov90da2582013-12-13 15:28:56 +02005482MODULE_DESCRIPTION("RADOS Block Device (RBD) driver");
Yehuda Sadeh602adf42010-08-12 16:11:25 -07005483MODULE_LICENSE("GPL");