Merge tag 'ceph-for-4.17-rc1' of git://github.com/ceph/ceph-client

Pull ceph updates from Ilya Dryomov: "The big ticket items are: - support for rbd "fancy" striping (myself). The striping feature bit is now fully implemented, allowing mapping v2 images with non-default striping patterns. This completes support for --image-format 2. - CephFS quota support (Luis Henriques and Zheng Yan). This set is based on the new SnapRealm code in the upcoming v13.y.z ("Mimic") release. Quota handling will be rejected on older filesystems. - memory usage improvements in CephFS (Chengguang Xu). Directory specific bits have been split out of ceph_file_info and some effort went into improving cap reservation code to avoid OOM crashes. Also included a bunch of assorted fixes all over the place from Chengguang and others" * tag 'ceph-for-4.17-rc1' of git://github.com/ceph/ceph-client: (67 commits) ceph: quota: report root dir quota usage in statfs ceph: quota: add counter for snaprealms with quota ceph: quota: cache inode pointer in ceph_snap_realm ceph: fix root quota realm check ceph: don't check quota for snap inode ceph: quota: update MDS when max_bytes is approaching ceph: quota: support for ceph.quota.max_bytes ceph: quota: don't allow cross-quota renames ceph: quota: support for ceph.quota.max_files ceph: quota: add initial infrastructure to support cephfs quotas rbd: remove VLA usage rbd: fix spelling mistake: "reregisteration" -> "reregistration" ceph: rename function drop_leases() to a more descriptive name ceph: fix invalid point dereference for error case in mdsc destroy ceph: return proper bool type to caller instead of pointer ceph: optimize memory usage ceph: optimize mds session register libceph, ceph: add __init attribution to init funcitons ceph: filter out used flags when printing unused open flags ceph: don't wait on writeback when there is no more dirty pages ...

Linus Torvalds committed 8 years ago

Commit b284d4d2 parents a7726f6 9122eed35 files · +2558 −1920Browse files

Unified · Split

35 files

Documentation/filesystems/ceph.txt +16 −0
drivers/block/rbd.c +980 −1472
fs/ceph/Makefile +1 −1
fs/ceph/addr.c +32 −31
fs/ceph/cache.c +2 −2
fs/ceph/caps.c +97 −31
fs/ceph/debugfs.c +4 −4
fs/ceph/dir.c +112 −92
fs/ceph/file.c +87 −30
fs/ceph/inode.c +15 −11
fs/ceph/ioctl.c +4 −9
fs/ceph/locks.c +10 −10
fs/ceph/mds_client.c +58 −29
fs/ceph/mds_client.h +4 −0
fs/ceph/quota.c +361 −0
fs/ceph/snap.c +2 −0
fs/ceph/super.c +39 −11
fs/ceph/super.h +42 −0
fs/ceph/xattr.c +44 −0
include/linux/ceph/ceph_features.h +1 −0
include/linux/ceph/ceph_fs.h +17 −0
include/linux/ceph/libceph.h +1 −0
include/linux/ceph/messenger.h +93 −8
include/linux/ceph/osd_client.h +14 −5
include/linux/ceph/osdmap.h +0 −6
include/linux/ceph/striper.h +69 −0
net/ceph/Makefile +1 −0
net/ceph/ceph_common.c +7 −1
net/ceph/crypto.c +4 −2
net/ceph/debugfs.c +7 −10
net/ceph/messenger.c +119 −69
net/ceph/mon_client.c +1 −1
net/ceph/osd_client.c +53 −14
net/ceph/osdmap.c +0 −71
net/ceph/striper.c +261 −0

Documentation/filesystems/ceph.txt+16−0

@@ -62,6 +62,18 @@ subdirectories, and a summation of all nested file sizes. This makes · 61 unmodified lines
62	62	the identification of large disk space consumers relatively quick, as
63	63	no 'du' or similar recursive scan of the file system is required.
64	64
	65	+Finally, Ceph also allows quotas to be set on any directory in the system.
	66	+The quota can restrict the number of bytes or the number of files stored
	67	+beneath that point in the directory hierarchy. Quotas can be set using
	68	+extended attributes 'ceph.quota.max_files' and 'ceph.quota.max_bytes', eg:
	69	+
	70	+ setfattr -n ceph.quota.max_bytes -v 100000000 /some/dir
	71	+ getfattr -n ceph.quota.max_bytes /some/dir
	72	+
	73	+A limitation of the current quotas implementation is that it relies on the
	74	+cooperation of the client mounting the file system to stop writers when a
	75	+limit is reached. A modified or adversarial client cannot be prevented
	76	+from writing as much data as it needs.
65	77
66	78	Mount Syntax
67	79	============
@@ -137,6 +149,10 @@ Mount Options · 69 unmodified lines
137	149	noasyncreaddir
138	150	Do not use the dcache as above for readdir.
139	151
	152	+ noquotadf
	153	+ Report overall filesystem usage in statfs instead of using the root
	154	+ directory quota.
	155	+
140	156	More Information
141	157	================
142	158

drivers/block/rbd.c+980−1472

@@ -32,6 +32,7 @@ · 31 unmodified lines
32	32	#include <linux/ceph/osd_client.h>
33	33	#include <linux/ceph/mon_client.h>
34	34	#include <linux/ceph/cls_lock_client.h>
	35	+#include <linux/ceph/striper.h>
35	36	#include <linux/ceph/decode.h>
36	37	#include <linux/parser.h>
37	38	#include <linux/bsearch.h>
@@ -200,95 +201,81 @@ struct rbd_client { · 162 unmodified lines
200	201	};
201	202
202	203	struct rbd_img_request;
203		−typedef void (rbd_img_callback_t)(struct rbd_img_request );
204		−
205		−#define BAD_WHICH U32_MAX /* Good which or bad which, which? */
206		−
207		−struct rbd_obj_request;
208		−typedef void (rbd_obj_callback_t)(struct rbd_obj_request );
209	204
210	205	enum obj_request_type {
211		− OBJ_REQUEST_NODATA, OBJ_REQUEST_BIO, OBJ_REQUEST_PAGES
	206	+ OBJ_REQUEST_NODATA = 1,
	207	+ OBJ_REQUEST_BIO, /* pointer into provided bio (list) */
	208	+ OBJ_REQUEST_BVECS, /* pointer into provided bio_vec array */
	209	+ OBJ_REQUEST_OWN_BVECS, /* private bio_vec array, doesn't own pages */
212	210	};
213	211
214	212	enum obj_operation_type {
	213	+ OBJ_OP_READ = 1,
215	214	OBJ_OP_WRITE,
216		− OBJ_OP_READ,
217	215	OBJ_OP_DISCARD,
218	216	};
219	217
220		−enum obj_req_flags {
221		− OBJ_REQ_DONE, /* completion flag: not done = 0, done = 1 */
222		− OBJ_REQ_IMG_DATA, /* object usage: standalone = 0, image = 1 */
223		− OBJ_REQ_KNOWN, /* EXISTS flag valid: no = 0, yes = 1 */
224		− OBJ_REQ_EXISTS, /* target exists: no = 0, yes = 1 */
	218	+/*
	219	+ * Writes go through the following state machine to deal with
	220	+ * layering:
	221	+ *
	222	+ * need copyup
	223	+ * RBD_OBJ_WRITE_GUARD ---------------> RBD_OBJ_WRITE_COPYUP
	224	+ * \| ^ \|
	225	+ * v \------------------------------/
	226	+ * done
	227	+ * ^
	228	+ * \|
	229	+ * RBD_OBJ_WRITE_FLAT
	230	+ *
	231	+ * Writes start in RBD_OBJ_WRITE_GUARD or _FLAT, depending on whether
	232	+ * there is a parent or not.
	233	+ */
	234	+enum rbd_obj_write_state {
	235	+ RBD_OBJ_WRITE_FLAT = 1,
	236	+ RBD_OBJ_WRITE_GUARD,
	237	+ RBD_OBJ_WRITE_COPYUP,
225	238	};
226	239
227	240	struct rbd_obj_request {
228		− u64 object_no;
229		− u64 offset; /* object start byte */
230		− u64 length; /* bytes from offset */
231		− unsigned long flags;
232		−
233		− /*
234		− * An object request associated with an image will have its
235		− * img_data flag set; a standalone object request will not.
236		− *
237		− * A standalone object request will have which == BAD_WHICH
238		− * and a null obj_request pointer.
239		− *
240		− * An object request initiated in support of a layered image
241		− * object (to check for its existence before a write) will
242		− * have which == BAD_WHICH and a non-null obj_request pointer.
243		− *
244		− * Finally, an object request for rbd image data will have
245		− * which != BAD_WHICH, and will have a non-null img_request
246		− * pointer. The value of which will be in the range
247		− * 0..(img_request->obj_request_count-1).
248		− */
	241	+ struct ceph_object_extent ex;
249	242	union {
250		− struct rbd_obj_request obj_request; / STAT op */
251		− struct {
252		− struct rbd_img_request *img_request;
253		− u64 img_offset;
254		− /* links for img_request->obj_requests list */
255		− struct list_head links;
256		− };
	243	+ bool tried_parent; /* for reads */
	244	+ enum rbd_obj_write_state write_state; /* for writes */
257	245	};
258		− u32 which; /* posn image request list */
259	246
260		− enum obj_request_type type;
	247	+ struct rbd_img_request *img_request;
	248	+ struct ceph_file_extent *img_extents;
	249	+ u32 num_img_extents;
	250	+
261	251	union {
262		− struct bio *bio_list;
	252	+ struct ceph_bio_iter bio_pos;
263	253	struct {
264		− struct page **pages;
265		− u32 page_count;
	254	+ struct ceph_bvec_iter bvec_pos;
	255	+ u32 bvec_count;
	256	+ u32 bvec_idx;
266	257	};
267	258	};
268		− struct page **copyup_pages;
269		− u32 copyup_page_count;
	259	+ struct bio_vec *copyup_bvecs;
	260	+ u32 copyup_bvec_count;
270	261
271	262	struct ceph_osd_request *osd_req;
272	263
273	264	u64 xferred; /* bytes transferred */
274	265	int result;
275	266
276		− rbd_obj_callback_t callback;
277		−
278	267	struct kref kref;
279	268	};
280	269
281	270	enum img_req_flags {
282		− IMG_REQ_WRITE, /* I/O direction: read = 0, write = 1 */
283	271	IMG_REQ_CHILD, /* initiator: block = 0, child image = 1 */
284	272	IMG_REQ_LAYERED, /* ENOENT handling: normal = 0, layered = 1 */
285		− IMG_REQ_DISCARD, /* discard: normal = 0, discard request = 1 */
286	273	};
287	274
288	275	struct rbd_img_request {
289	276	struct rbd_device *rbd_dev;
290		− u64 offset; /* starting image byte offset */
291		− u64 length; /* byte count from offset */
	277	+ enum obj_operation_type op_type;
	278	+ enum obj_request_type data_type;
292	279	unsigned long flags;
293	280	union {
294	281	u64 snap_id; /* for reads */
@@ -298,26 +285,21 @@ struct rbd_img_request { · 3 unmodified lines
298	285	struct request rq; / block request */
299	286	struct rbd_obj_request obj_request; / obj req initiator */
300	287	};
301		− struct page **copyup_pages;
302		− u32 copyup_page_count;
303		− spinlock_t completion_lock;/* protects next_completion */
304		− u32 next_completion;
305		− rbd_img_callback_t callback;
	288	+ spinlock_t completion_lock;
306	289	u64 xferred;/* aggregate bytes transferred */
307	290	int result; /* first nonzero obj_request result */
308	291
	292	+ struct list_head object_extents; /* obj_req.ex structs */
309	293	u32 obj_request_count;
310		− struct list_head obj_requests; /* rbd_obj_request structs */
	294	+ u32 pending_count;
311	295
312	296	struct kref kref;
313	297	};
314	298
315	299	#define for_each_obj_request(ireq, oreq) \
316		− list_for_each_entry(oreq, &(ireq)->obj_requests, links)
317		−#define for_each_obj_request_from(ireq, oreq) \
318		− list_for_each_entry_from(oreq, &(ireq)->obj_requests, links)
	300	+ list_for_each_entry(oreq, &(ireq)->object_extents, ex.oe_item)
319	301	#define for_each_obj_request_safe(ireq, oreq, n) \
320		− list_for_each_entry_safe_reverse(oreq, n, &(ireq)->obj_requests, links)
	302	+ list_for_each_entry_safe(oreq, n, &(ireq)->object_extents, ex.oe_item)
321	303
322	304	enum rbd_watch_state {
323	305	RBD_WATCH_STATE_UNREGISTERED,
@@ -433,8 +415,6 @@ static DEFINE_SPINLOCK(rbd_client_list_lock); · 109 unmodified lines
433	415	static struct kmem_cache *rbd_img_request_cache;
434	416	static struct kmem_cache *rbd_obj_request_cache;
435	417
436		−static struct bio_set *rbd_bio_clone;
437		−
438	418	static int rbd_major;
439	419	static DEFINE_IDA(rbd_dev_id_ida);
440	420
@@ -447,8 +427,6 @@ static bool single_major = true; · 6 unmodified lines
447	427	module_param(single_major, bool, S_IRUGO);
448	428	MODULE_PARM_DESC(single_major, "Use a single major number for all rbd devices (default: true)");
449	429
450		−static int rbd_img_request_submit(struct rbd_img_request *img_request);
451		−
452	430	static ssize_t rbd_add(struct bus_type bus, const char buf,
453	431	size_t count);
454	432	static ssize_t rbd_remove(struct bus_type bus, const char buf,
@@ -458,7 +436,6 @@ static ssize_t rbd_add_single_major(struct bus_type bus, const char buf, · 3 unmodified lines
458	436	static ssize_t rbd_remove_single_major(struct bus_type bus, const char buf,
459	437	size_t count);
460	438	static int rbd_dev_image_probe(struct rbd_device *rbd_dev, int depth);
461		−static void rbd_spec_put(struct rbd_spec *spec);
462	439
463	440	static int rbd_dev_id_to_minor(int dev_id)
464	441	{
@@ -577,9 +554,6 @@ void rbd_warn(struct rbd_device rbd_dev, const char fmt, ...) · 112 unmodified lines
577	554	# define rbd_assert(expr) ((void) 0)
578	555	#endif /* !RBD_DEBUG */
579	556
580		−static void rbd_osd_copyup_callback(struct rbd_obj_request *obj_request);
581		−static int rbd_img_obj_request_submit(struct rbd_obj_request *obj_request);
582		−static void rbd_img_parent_read(struct rbd_obj_request *obj_request);
583	557	static void rbd_dev_remove_parent(struct rbd_device *rbd_dev);
584	558
585	559	static int rbd_dev_refresh(struct rbd_device *rbd_dev);
@@ -856,26 +830,6 @@ static char* obj_op_name(enum obj_operation_type op_type) · 270 unmodified lines
856	830	}
857	831	}
858	832
859		−/*
860		− * Get a ceph client with specific addr and configuration, if one does
861		− * not exist create it. Either way, ceph_opts is consumed by this
862		− * function.
863		− */
864		−static struct rbd_client rbd_get_client(struct ceph_options ceph_opts)
865		−{
866		− struct rbd_client *rbdc;
867		−
868		− mutex_lock_nested(&client_mutex, SINGLE_DEPTH_NESTING);
869		− rbdc = rbd_client_find(ceph_opts);
870		− if (rbdc) /* using an existing client */
871		− ceph_destroy_options(ceph_opts);
872		− else
873		− rbdc = rbd_client_create(ceph_opts);
874		− mutex_unlock(&client_mutex);
875		−
876		− return rbdc;
877		−}
878		−
879	833	/*
880	834	* Destroy ceph client
881	835	*
@@ -904,6 +858,56 @@ static void rbd_put_client(struct rbd_client *rbdc) · 22 unmodified lines
904	858	kref_put(&rbdc->kref, rbd_client_release);
905	859	}
906	860
	861	+static int wait_for_latest_osdmap(struct ceph_client *client)
	862	+{
	863	+ u64 newest_epoch;
	864	+ int ret;
	865	+
	866	+ ret = ceph_monc_get_version(&client->monc, "osdmap", &newest_epoch);
	867	+ if (ret)
	868	+ return ret;
	869	+
	870	+ if (client->osdc.osdmap->epoch >= newest_epoch)
	871	+ return 0;
	872	+
	873	+ ceph_osdc_maybe_request_map(&client->osdc);
	874	+ return ceph_monc_wait_osdmap(&client->monc, newest_epoch,
	875	+ client->options->mount_timeout);
	876	+}
	877	+
	878	+/*
	879	+ * Get a ceph client with specific addr and configuration, if one does
	880	+ * not exist create it. Either way, ceph_opts is consumed by this
	881	+ * function.
	882	+ */
	883	+static struct rbd_client rbd_get_client(struct ceph_options ceph_opts)
	884	+{
	885	+ struct rbd_client *rbdc;
	886	+ int ret;
	887	+
	888	+ mutex_lock_nested(&client_mutex, SINGLE_DEPTH_NESTING);
	889	+ rbdc = rbd_client_find(ceph_opts);
	890	+ if (rbdc) {
	891	+ ceph_destroy_options(ceph_opts);
	892	+
	893	+ /*
	894	+ * Using an existing client. Make sure ->pg_pools is up to
	895	+ * date before we look up the pool id in do_rbd_add().
	896	+ */
	897	+ ret = wait_for_latest_osdmap(rbdc->client);
	898	+ if (ret) {
	899	+ rbd_warn(NULL, "failed to get latest osdmap: %d", ret);
	900	+ rbd_put_client(rbdc);
	901	+ rbdc = ERR_PTR(ret);
	902	+ }
	903	+ } else {
	904	+ rbdc = rbd_client_create(ceph_opts);
	905	+ }
	906	+ mutex_unlock(&client_mutex);
	907	+
	908	+ return rbdc;
	909	+}
	910	+
907	911	static bool rbd_image_format_valid(u32 image_format)
908	912	{
909	913	return image_format == 1 \|\| image_format == 2;
@@ -1223,272 +1227,59 @@ static void rbd_dev_mapping_clear(struct rbd_device *rbd_dev) · 313 unmodified lines
1223	1227	rbd_dev->mapping.features = 0;
1224	1228	}
1225	1229
1226		−static u64 rbd_segment_offset(struct rbd_device *rbd_dev, u64 offset)
1227		−{
1228		− u64 segment_size = rbd_obj_bytes(&rbd_dev->header);
1229		−
1230		− return offset & (segment_size - 1);
1231		−}
1232		−
1233		−static u64 rbd_segment_length(struct rbd_device *rbd_dev,
1234		− u64 offset, u64 length)
1235		−{
1236		− u64 segment_size = rbd_obj_bytes(&rbd_dev->header);
1237		−
1238		− offset &= segment_size - 1;
1239		−
1240		− rbd_assert(length <= U64_MAX - offset);
1241		− if (offset + length > segment_size)
1242		− length = segment_size - offset;
1243		−
1244		− return length;
1245		−}
1246		−
1247		−/*
1248		− * bio helpers
1249		− */
1250		−
1251		−static void bio_chain_put(struct bio *chain)
1252		−{
1253		− struct bio *tmp;
1254		−
1255		− while (chain) {
1256		− tmp = chain;
1257		− chain = chain->bi_next;
1258		− bio_put(tmp);
1259		− }
1260		−}
1261		−
1262		−/*
1263		− * zeros a bio chain, starting at specific offset
1264		− */
1265		−static void zero_bio_chain(struct bio *chain, int start_ofs)
	1230	+static void zero_bvec(struct bio_vec *bv)
1266	1231	{
1267		− struct bio_vec bv;
1268		− struct bvec_iter iter;
1269		− unsigned long flags;
1270	1232	void *buf;
1271		− int pos = 0;
1272		−
1273		− while (chain) {
1274		− bio_for_each_segment(bv, chain, iter) {
1275		− if (pos + bv.bv_len > start_ofs) {
1276		− int remainder = max(start_ofs - pos, 0);
1277		− buf = bvec_kmap_irq(&bv, &flags);
1278		− memset(buf + remainder, 0,
1279		− bv.bv_len - remainder);
1280		− flush_dcache_page(bv.bv_page);
1281		− bvec_kunmap_irq(buf, &flags);
1282		− }
1283		− pos += bv.bv_len;
1284		− }
	1233	+ unsigned long flags;
1285	1234
1286		− chain = chain->bi_next;
1287		− }
	1235	+ buf = bvec_kmap_irq(bv, &flags);
	1236	+ memset(buf, 0, bv->bv_len);
	1237	+ flush_dcache_page(bv->bv_page);
	1238	+ bvec_kunmap_irq(buf, &flags);
1288	1239	}
1289	1240
1290		−/*
1291		− * similar to zero_bio_chain(), zeros data defined by a page array,
1292		− * starting at the given byte offset from the start of the array and
1293		− * continuing up to the given end offset. The pages array is
1294		− * assumed to be big enough to hold all bytes up to the end.
1295		− */
1296		−static void zero_pages(struct page **pages, u64 offset, u64 end)
	1241	+static void zero_bios(struct ceph_bio_iter *bio_pos, u32 off, u32 bytes)
1297	1242	{
1298		− struct page **page = &pages[offset >> PAGE_SHIFT];
1299		−
1300		− rbd_assert(end > offset);
1301		− rbd_assert(end - offset <= (u64)SIZE_MAX);
1302		− while (offset < end) {
1303		− size_t page_offset;
1304		− size_t length;
1305		− unsigned long flags;
1306		− void *kaddr;
1307		−
1308		− page_offset = offset & ~PAGE_MASK;
1309		− length = min_t(size_t, PAGE_SIZE - page_offset, end - offset);
1310		− local_irq_save(flags);
1311		− kaddr = kmap_atomic(*page);
1312		− memset(kaddr + page_offset, 0, length);
1313		− flush_dcache_page(*page);
1314		− kunmap_atomic(kaddr);
1315		− local_irq_restore(flags);
	1243	+ struct ceph_bio_iter it = *bio_pos;
1316	1244
1317		− offset += length;
1318		− page++;
1319		− }
	1245	+ ceph_bio_iter_advance(&it, off);
	1246	+ ceph_bio_iter_advance_step(&it, bytes, ({
	1247	+ zero_bvec(&bv);
	1248	+ }));
1320	1249	}
1321	1250
1322		−/*
1323		− * Clone a portion of a bio, starting at the given byte offset
1324		− * and continuing for the number of bytes indicated.
1325		− */
1326		−static struct bio bio_clone_range(struct bio bio_src,
1327		− unsigned int offset,
1328		− unsigned int len,
1329		− gfp_t gfpmask)
	1251	+static void zero_bvecs(struct ceph_bvec_iter *bvec_pos, u32 off, u32 bytes)
1330	1252	{
1331		− struct bio *bio;
1332		−
1333		− bio = bio_clone_fast(bio_src, gfpmask, rbd_bio_clone);
1334		− if (!bio)
1335		− return NULL; /* ENOMEM */
	1253	+ struct ceph_bvec_iter it = *bvec_pos;
1336	1254
1337		− bio_advance(bio, offset);
1338		− bio->bi_iter.bi_size = len;
1339		−
1340		− return bio;
	1255	+ ceph_bvec_iter_advance(&it, off);
	1256	+ ceph_bvec_iter_advance_step(&it, bytes, ({
	1257	+ zero_bvec(&bv);
	1258	+ }));
1341	1259	}
1342	1260
1343	1261	/*
1344		− * Clone a portion of a bio chain, starting at the given byte offset
1345		− * into the first bio in the source chain and continuing for the
1346		− * number of bytes indicated. The result is another bio chain of
1347		− * exactly the given length, or a null pointer on error.
1348		− *
1349		− * The bio_src and offset parameters are both in-out. On entry they
1350		− * refer to the first source bio and the offset into that bio where
1351		− * the start of data to be cloned is located.
	1262	+ * Zero a range in @obj_req data buffer defined by a bio (list) or
	1263	+ * (private) bio_vec array.
1352	1264	*
1353		− * On return, bio_src is updated to refer to the bio in the source
1354		− * chain that contains first un-cloned byte, and *offset will
1355		− * contain the offset of that byte within that bio.
1356		− */
1357		−static struct bio bio_chain_clone_range(struct bio *bio_src,
1358		− unsigned int *offset,
1359		− unsigned int len,
1360		− gfp_t gfpmask)
1361		−{
1362		− struct bio bi = bio_src;
1363		− unsigned int off = *offset;
1364		− struct bio *chain = NULL;
1365		− struct bio **end;
1366		−
1367		− /* Build up a chain of clone bios up to the limit */
1368		−
1369		− if (!bi \|\| off >= bi->bi_iter.bi_size \|\| !len)
1370		− return NULL; /* Nothing to clone */
1371		−
1372		− end = &chain;
1373		− while (len) {
1374		− unsigned int bi_size;
1375		− struct bio *bio;
1376		−
1377		− if (!bi) {
1378		− rbd_warn(NULL, "bio_chain exhausted with %u left", len);
1379		− goto out_err; /* EINVAL; ran out of bio's */
1380		− }
1381		− bi_size = min_t(unsigned int, bi->bi_iter.bi_size - off, len);
1382		− bio = bio_clone_range(bi, off, bi_size, gfpmask);
1383		− if (!bio)
1384		− goto out_err; /* ENOMEM */
1385		−
1386		− *end = bio;
1387		− end = &bio->bi_next;
1388		−
1389		− off += bi_size;
1390		− if (off == bi->bi_iter.bi_size) {
1391		− bi = bi->bi_next;
1392		− off = 0;
1393		− }
1394		− len -= bi_size;
1395		− }
1396		− *bio_src = bi;
1397		− *offset = off;
1398		−
1399		− return chain;
1400		−out_err:
1401		− bio_chain_put(chain);
1402		−
1403		− return NULL;
1404		−}
1405		−
1406		−/*
1407		− * The default/initial value for all object request flags is 0. For
1408		− * each flag, once its value is set to 1 it is never reset to 0
1409		− * again.
	1265	+ * @off is relative to the start of the data buffer.
1410	1266	*/
1411		−static void obj_request_img_data_set(struct rbd_obj_request *obj_request)
1412		−{
1413		− if (test_and_set_bit(OBJ_REQ_IMG_DATA, &obj_request->flags)) {
1414		− struct rbd_device *rbd_dev;
1415		−
1416		− rbd_dev = obj_request->img_request->rbd_dev;
1417		− rbd_warn(rbd_dev, "obj_request %p already marked img_data",
1418		− obj_request);
1419		− }
1420		−}
1421		−
1422		−static bool obj_request_img_data_test(struct rbd_obj_request *obj_request)
	1267	+static void rbd_obj_zero_range(struct rbd_obj_request *obj_req, u32 off,
	1268	+ u32 bytes)
1423	1269	{
1424		− smp_mb();
1425		− return test_bit(OBJ_REQ_IMG_DATA, &obj_request->flags) != 0;
1426		−}
1427		−
1428		−static void obj_request_done_set(struct rbd_obj_request *obj_request)
1429		−{
1430		− if (test_and_set_bit(OBJ_REQ_DONE, &obj_request->flags)) {
1431		− struct rbd_device *rbd_dev = NULL;
1432		−
1433		− if (obj_request_img_data_test(obj_request))
1434		− rbd_dev = obj_request->img_request->rbd_dev;
1435		− rbd_warn(rbd_dev, "obj_request %p already marked done",
1436		− obj_request);
	1270	+ switch (obj_req->img_request->data_type) {
	1271	+ case OBJ_REQUEST_BIO:
	1272	+ zero_bios(&obj_req->bio_pos, off, bytes);
	1273	+ break;
	1274	+ case OBJ_REQUEST_BVECS:
	1275	+ case OBJ_REQUEST_OWN_BVECS:
	1276	+ zero_bvecs(&obj_req->bvec_pos, off, bytes);
	1277	+ break;
	1278	+ default:
	1279	+ rbd_assert(0);
1437	1280	}
1438	1281	}
1439	1282
1440		−static bool obj_request_done_test(struct rbd_obj_request *obj_request)
1441		−{
1442		− smp_mb();
1443		− return test_bit(OBJ_REQ_DONE, &obj_request->flags) != 0;
1444		−}
1445		−
1446		−/*
1447		− * This sets the KNOWN flag after (possibly) setting the EXISTS
1448		− * flag. The latter is set based on the "exists" value provided.
1449		− *
1450		− * Note that for our purposes once an object exists it never goes
1451		− * away again. It's possible that the response from two existence
1452		− * checks are separated by the creation of the target object, and
1453		− * the first ("doesn't exist") response arrives after the second
1454		− * ("does exist"). In that case we ignore the second one.
1455		− */
1456		−static void obj_request_existence_set(struct rbd_obj_request *obj_request,
1457		− bool exists)
1458		−{
1459		− if (exists)
1460		− set_bit(OBJ_REQ_EXISTS, &obj_request->flags);
1461		− set_bit(OBJ_REQ_KNOWN, &obj_request->flags);
1462		− smp_mb();
1463		−}
1464		−
1465		−static bool obj_request_known_test(struct rbd_obj_request *obj_request)
1466		−{
1467		− smp_mb();
1468		− return test_bit(OBJ_REQ_KNOWN, &obj_request->flags) != 0;
1469		−}
1470		−
1471		−static bool obj_request_exists_test(struct rbd_obj_request *obj_request)
1472		−{
1473		− smp_mb();
1474		− return test_bit(OBJ_REQ_EXISTS, &obj_request->flags) != 0;
1475		−}
1476		−
1477		−static bool obj_request_overlaps_parent(struct rbd_obj_request *obj_request)
1478		−{
1479		− struct rbd_device *rbd_dev = obj_request->img_request->rbd_dev;
1480		−
1481		− return obj_request->img_offset <
1482		− round_up(rbd_dev->parent_overlap, rbd_obj_bytes(&rbd_dev->header));
1483		−}
1484		−
1485		−static void rbd_obj_request_get(struct rbd_obj_request *obj_request)
1486		−{
1487		− dout("%s: obj %p (was %d)\n", __func__, obj_request,
1488		− kref_read(&obj_request->kref));
1489		− kref_get(&obj_request->kref);
1490		−}
1491		−
1492	1283	static void rbd_obj_request_destroy(struct kref *kref);
1493	1284	static void rbd_obj_request_put(struct rbd_obj_request *obj_request)
1494	1285	{
@@ -1505,18 +1296,13 @@ static void rbd_img_request_get(struct rbd_img_request *img_request) · 10 unmodified lines
1505	1296	kref_get(&img_request->kref);
1506	1297	}
1507	1298
1508		−static bool img_request_child_test(struct rbd_img_request *img_request);
1509		−static void rbd_parent_request_destroy(struct kref *kref);
1510	1299	static void rbd_img_request_destroy(struct kref *kref);
1511	1300	static void rbd_img_request_put(struct rbd_img_request *img_request)
1512	1301	{
1513	1302	rbd_assert(img_request != NULL);
1514	1303	dout("%s: img %p (was %d)\n", __func__, img_request,
1515	1304	kref_read(&img_request->kref));
1516		− if (img_request_child_test(img_request))
1517		− kref_put(&img_request->kref, rbd_parent_request_destroy);
1518		− else
1519		− kref_put(&img_request->kref, rbd_img_request_destroy);
	1305	+ kref_put(&img_request->kref, rbd_img_request_destroy);
1520	1306	}
1521	1307
1522	1308	static inline void rbd_img_obj_request_add(struct rbd_img_request *img_request,
@@ -1526,139 +1312,37 @@ static inline void rbd_img_obj_request_add(struct rbd_img_request *img_request, · 3 unmodified lines
1526	1312
1527	1313	/* Image request now owns object's original reference */
1528	1314	obj_request->img_request = img_request;
1529		− obj_request->which = img_request->obj_request_count;
1530		− rbd_assert(!obj_request_img_data_test(obj_request));
1531		− obj_request_img_data_set(obj_request);
1532		− rbd_assert(obj_request->which != BAD_WHICH);
1533	1315	img_request->obj_request_count++;
1534		− list_add_tail(&obj_request->links, &img_request->obj_requests);
1535		− dout("%s: img %p obj %p w=%u\n", __func__, img_request, obj_request,
1536		− obj_request->which);
	1316	+ img_request->pending_count++;
	1317	+ dout("%s: img %p obj %p\n", __func__, img_request, obj_request);
1537	1318	}
1538	1319
1539	1320	static inline void rbd_img_obj_request_del(struct rbd_img_request *img_request,
1540	1321	struct rbd_obj_request *obj_request)
1541	1322	{
1542		− rbd_assert(obj_request->which != BAD_WHICH);
1543		−
1544		− dout("%s: img %p obj %p w=%u\n", __func__, img_request, obj_request,
1545		− obj_request->which);
1546		− list_del(&obj_request->links);
	1323	+ dout("%s: img %p obj %p\n", __func__, img_request, obj_request);
	1324	+ list_del(&obj_request->ex.oe_item);
1547	1325	rbd_assert(img_request->obj_request_count > 0);
1548	1326	img_request->obj_request_count--;
1549		− rbd_assert(obj_request->which == img_request->obj_request_count);
1550		− obj_request->which = BAD_WHICH;
1551		− rbd_assert(obj_request_img_data_test(obj_request));
1552	1327	rbd_assert(obj_request->img_request == img_request);
1553		− obj_request->img_request = NULL;
1554		− obj_request->callback = NULL;
1555	1328	rbd_obj_request_put(obj_request);
1556	1329	}
1557	1330
1558		−static bool obj_request_type_valid(enum obj_request_type type)
1559		−{
1560		− switch (type) {
1561		− case OBJ_REQUEST_NODATA:
1562		− case OBJ_REQUEST_BIO:
1563		− case OBJ_REQUEST_PAGES:
1564		− return true;
1565		− default:
1566		− return false;
1567		− }
1568		−}
1569		−
1570		−static void rbd_img_obj_callback(struct rbd_obj_request *obj_request);
1571		−
1572	1331	static void rbd_obj_request_submit(struct rbd_obj_request *obj_request)
1573	1332	{
1574	1333	struct ceph_osd_request *osd_req = obj_request->osd_req;
1575	1334
1576	1335	dout("%s %p object_no %016llx %llu~%llu osd_req %p\n", __func__,
1577		− obj_request, obj_request->object_no, obj_request->offset,
1578		− obj_request->length, osd_req);
1579		− if (obj_request_img_data_test(obj_request)) {
1580		− WARN_ON(obj_request->callback != rbd_img_obj_callback);
1581		− rbd_img_request_get(obj_request->img_request);
1582		− }
	1336	+ obj_request, obj_request->ex.oe_objno, obj_request->ex.oe_off,
	1337	+ obj_request->ex.oe_len, osd_req);
1583	1338	ceph_osdc_start_request(osd_req->r_osdc, osd_req, false);
1584	1339	}
1585	1340
1586		−static void rbd_img_request_complete(struct rbd_img_request *img_request)
1587		−{
1588		−
1589		− dout("%s: img %p\n", __func__, img_request);
1590		−
1591		− /*
1592		− * If no error occurred, compute the aggregate transfer
1593		− * count for the image request. We could instead use
1594		− * atomic64_cmpxchg() to update it as each object request
1595		− * completes; not clear which way is better off hand.
1596		− */
1597		− if (!img_request->result) {
1598		− struct rbd_obj_request *obj_request;
1599		− u64 xferred = 0;
1600		−
1601		− for_each_obj_request(img_request, obj_request)
1602		− xferred += obj_request->xferred;
1603		− img_request->xferred = xferred;
1604		− }
1605		−
1606		− if (img_request->callback)
1607		− img_request->callback(img_request);
1608		− else
1609		− rbd_img_request_put(img_request);
1610		−}
1611		−
1612	1341	/*
1613	1342	* The default/initial value for all image request flags is 0. Each
1614	1343	* is conditionally set to 1 at image request initialization time
1615	1344	* and currently never change thereafter.
1616	1345	*/
1617		−static void img_request_write_set(struct rbd_img_request *img_request)
1618		−{
1619		− set_bit(IMG_REQ_WRITE, &img_request->flags);
1620		− smp_mb();
1621		−}
1622		−
1623		−static bool img_request_write_test(struct rbd_img_request *img_request)
1624		−{
1625		− smp_mb();
1626		− return test_bit(IMG_REQ_WRITE, &img_request->flags) != 0;
1627		−}
1628		−
1629		−/*
1630		− * Set the discard flag when the img_request is an discard request
1631		− */
1632		−static void img_request_discard_set(struct rbd_img_request *img_request)
1633		−{
1634		− set_bit(IMG_REQ_DISCARD, &img_request->flags);
1635		− smp_mb();
1636		−}
1637		−
1638		−static bool img_request_discard_test(struct rbd_img_request *img_request)
1639		−{
1640		− smp_mb();
1641		− return test_bit(IMG_REQ_DISCARD, &img_request->flags) != 0;
1642		−}
1643		−
1644		−static void img_request_child_set(struct rbd_img_request *img_request)
1645		−{
1646		− set_bit(IMG_REQ_CHILD, &img_request->flags);
1647		− smp_mb();
1648		−}
1649		−
1650		−static void img_request_child_clear(struct rbd_img_request *img_request)
1651		−{
1652		− clear_bit(IMG_REQ_CHILD, &img_request->flags);
1653		− smp_mb();
1654		−}
1655		−
1656		−static bool img_request_child_test(struct rbd_img_request *img_request)
1657		−{
1658		− smp_mb();
1659		− return test_bit(IMG_REQ_CHILD, &img_request->flags) != 0;
1660		−}
1661		−
1662	1346	static void img_request_layered_set(struct rbd_img_request *img_request)
1663	1347	{
1664	1348	set_bit(IMG_REQ_LAYERED, &img_request->flags);
@@ -1677,209 +1361,70 @@ static bool img_request_layered_test(struct rbd_img_request *img_request) · 12 unmodified lines
1677	1361	return test_bit(IMG_REQ_LAYERED, &img_request->flags) != 0;
1678	1362	}
1679	1363
1680		−static enum obj_operation_type
1681		−rbd_img_request_op_type(struct rbd_img_request *img_request)
1682		−{
1683		− if (img_request_write_test(img_request))
1684		− return OBJ_OP_WRITE;
1685		− else if (img_request_discard_test(img_request))
1686		− return OBJ_OP_DISCARD;
1687		− else
1688		− return OBJ_OP_READ;
1689		−}
1690		−
1691		−static void
1692		−rbd_img_obj_request_read_callback(struct rbd_obj_request *obj_request)
	1364	+static bool rbd_obj_is_entire(struct rbd_obj_request *obj_req)
1693	1365	{
1694		− u64 xferred = obj_request->xferred;
1695		− u64 length = obj_request->length;
	1366	+ struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
1696	1367
1697		− dout("%s: obj %p img %p result %d %llu/%llu\n", __func__,
1698		− obj_request, obj_request->img_request, obj_request->result,
1699		− xferred, length);
1700		− /*
1701		− * ENOENT means a hole in the image. We zero-fill the entire
1702		− * length of the request. A short read also implies zero-fill
1703		− * to the end of the request. An error requires the whole
1704		− * length of the request to be reported finished with an error
1705		− * to the block layer. In each case we update the xferred
1706		− * count to indicate the whole request was satisfied.
1707		− */
1708		− rbd_assert(obj_request->type != OBJ_REQUEST_NODATA);
1709		− if (obj_request->result == -ENOENT) {
1710		− if (obj_request->type == OBJ_REQUEST_BIO)
1711		− zero_bio_chain(obj_request->bio_list, 0);
1712		− else
1713		− zero_pages(obj_request->pages, 0, length);
1714		− obj_request->result = 0;
1715		− } else if (xferred < length && !obj_request->result) {
1716		− if (obj_request->type == OBJ_REQUEST_BIO)
1717		− zero_bio_chain(obj_request->bio_list, xferred);
1718		− else
1719		− zero_pages(obj_request->pages, xferred, length);
1720		− }
1721		− obj_request->xferred = length;
1722		− obj_request_done_set(obj_request);
	1368	+ return !obj_req->ex.oe_off &&
	1369	+ obj_req->ex.oe_len == rbd_dev->layout.object_size;
1723	1370	}
1724	1371
1725		−static void rbd_obj_request_complete(struct rbd_obj_request *obj_request)
	1372	+static bool rbd_obj_is_tail(struct rbd_obj_request *obj_req)
1726	1373	{
1727		− dout("%s: obj %p cb %p\n", __func__, obj_request,
1728		− obj_request->callback);
1729		− obj_request->callback(obj_request);
1730		−}
	1374	+ struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
1731	1375
1732		−static void rbd_obj_request_error(struct rbd_obj_request *obj_request, int err)
1733		−{
1734		− obj_request->result = err;
1735		− obj_request->xferred = 0;
1736		− /*
1737		− * kludge - mirror rbd_obj_request_submit() to match a put in
1738		− * rbd_img_obj_callback()
1739		− */
1740		− if (obj_request_img_data_test(obj_request)) {
1741		− WARN_ON(obj_request->callback != rbd_img_obj_callback);
1742		− rbd_img_request_get(obj_request->img_request);
1743		− }
1744		− obj_request_done_set(obj_request);
1745		− rbd_obj_request_complete(obj_request);
	1376	+ return obj_req->ex.oe_off + obj_req->ex.oe_len ==
	1377	+ rbd_dev->layout.object_size;
1746	1378	}
1747	1379
1748		−static void rbd_osd_read_callback(struct rbd_obj_request *obj_request)
	1380	+static u64 rbd_obj_img_extents_bytes(struct rbd_obj_request *obj_req)
1749	1381	{
1750		− struct rbd_img_request *img_request = NULL;
1751		− struct rbd_device *rbd_dev = NULL;
1752		− bool layered = false;
1753		−
1754		− if (obj_request_img_data_test(obj_request)) {
1755		− img_request = obj_request->img_request;
1756		− layered = img_request && img_request_layered_test(img_request);
1757		− rbd_dev = img_request->rbd_dev;
1758		− }
1759		−
1760		− dout("%s: obj %p img %p result %d %llu/%llu\n", __func__,
1761		− obj_request, img_request, obj_request->result,
1762		− obj_request->xferred, obj_request->length);
1763		− if (layered && obj_request->result == -ENOENT &&
1764		− obj_request->img_offset < rbd_dev->parent_overlap)
1765		− rbd_img_parent_read(obj_request);
1766		− else if (img_request)
1767		− rbd_img_obj_request_read_callback(obj_request);
1768		− else
1769		− obj_request_done_set(obj_request);
	1382	+ return ceph_file_extents_bytes(obj_req->img_extents,
	1383	+ obj_req->num_img_extents);
1770	1384	}
1771	1385
1772		−static void rbd_osd_write_callback(struct rbd_obj_request *obj_request)
	1386	+static bool rbd_img_is_write(struct rbd_img_request *img_req)
1773	1387	{
1774		− dout("%s: obj %p result %d %llu\n", __func__, obj_request,
1775		− obj_request->result, obj_request->length);
1776		− /*
1777		− * There is no such thing as a successful short write. Set
1778		− * it to our originally-requested length.
1779		− */
1780		− obj_request->xferred = obj_request->length;
1781		− obj_request_done_set(obj_request);
1782		−}
1783		−
1784		−static void rbd_osd_discard_callback(struct rbd_obj_request *obj_request)
1785		−{
1786		− dout("%s: obj %p result %d %llu\n", __func__, obj_request,
1787		− obj_request->result, obj_request->length);
1788		− /*
1789		− * There is no such thing as a successful short discard. Set
1790		− * it to our originally-requested length.
1791		− */
1792		− obj_request->xferred = obj_request->length;
1793		− /* discarding a non-existent object is not a problem */
1794		− if (obj_request->result == -ENOENT)
1795		− obj_request->result = 0;
1796		− obj_request_done_set(obj_request);
	1388	+ switch (img_req->op_type) {
	1389	+ case OBJ_OP_READ:
	1390	+ return false;
	1391	+ case OBJ_OP_WRITE:
	1392	+ case OBJ_OP_DISCARD:
	1393	+ return true;
	1394	+ default:
	1395	+ rbd_assert(0);
	1396	+ }
1797	1397	}
1798	1398
1799		−/*
1800		− * For a simple stat call there's nothing to do. We'll do more if
1801		− * this is part of a write sequence for a layered image.
1802		− */
1803		−static void rbd_osd_stat_callback(struct rbd_obj_request *obj_request)
1804		−{
1805		− dout("%s: obj %p\n", __func__, obj_request);
1806		− obj_request_done_set(obj_request);
1807		−}
1808		−
1809		−static void rbd_osd_call_callback(struct rbd_obj_request *obj_request)
1810		−{
1811		− dout("%s: obj %p\n", __func__, obj_request);
1812		−
1813		− if (obj_request_img_data_test(obj_request))
1814		− rbd_osd_copyup_callback(obj_request);
1815		− else
1816		− obj_request_done_set(obj_request);
1817		−}
	1399	+static void rbd_obj_handle_request(struct rbd_obj_request *obj_req);
1818	1400
1819	1401	static void rbd_osd_req_callback(struct ceph_osd_request *osd_req)
1820	1402	{
1821		− struct rbd_obj_request *obj_request = osd_req->r_priv;
1822		− u16 opcode;
	1403	+ struct rbd_obj_request *obj_req = osd_req->r_priv;
1823	1404
1824		− dout("%s: osd_req %p\n", __func__, osd_req);
1825		− rbd_assert(osd_req == obj_request->osd_req);
1826		− if (obj_request_img_data_test(obj_request)) {
1827		− rbd_assert(obj_request->img_request);
1828		− rbd_assert(obj_request->which != BAD_WHICH);
1829		− } else {
1830		− rbd_assert(obj_request->which == BAD_WHICH);
1831		− }
	1405	+ dout("%s osd_req %p result %d for obj_req %p\n", __func__, osd_req,
	1406	+ osd_req->r_result, obj_req);
	1407	+ rbd_assert(osd_req == obj_req->osd_req);
1832	1408
1833		− if (osd_req->r_result < 0)
1834		− obj_request->result = osd_req->r_result;
1835		−
1836		− /*
1837		− * We support a 64-bit length, but ultimately it has to be
1838		− * passed to the block layer, which just supports a 32-bit
1839		− * length field.
1840		− */
1841		− obj_request->xferred = osd_req->r_ops[0].outdata_len;
1842		− rbd_assert(obj_request->xferred < (u64)UINT_MAX);
1843		−
1844		− opcode = osd_req->r_ops[0].op;
1845		− switch (opcode) {
1846		− case CEPH_OSD_OP_READ:
1847		− rbd_osd_read_callback(obj_request);
1848		− break;
1849		− case CEPH_OSD_OP_SETALLOCHINT:
1850		− rbd_assert(osd_req->r_ops[1].op == CEPH_OSD_OP_WRITE \|\|
1851		− osd_req->r_ops[1].op == CEPH_OSD_OP_WRITEFULL);
1852		− /* fall through */
1853		− case CEPH_OSD_OP_WRITE:
1854		− case CEPH_OSD_OP_WRITEFULL:
1855		− rbd_osd_write_callback(obj_request);
1856		− break;
1857		− case CEPH_OSD_OP_STAT:
1858		− rbd_osd_stat_callback(obj_request);
1859		− break;
1860		− case CEPH_OSD_OP_DELETE:
1861		− case CEPH_OSD_OP_TRUNCATE:
1862		− case CEPH_OSD_OP_ZERO:
1863		− rbd_osd_discard_callback(obj_request);
1864		− break;
1865		− case CEPH_OSD_OP_CALL:
1866		− rbd_osd_call_callback(obj_request);
1867		− break;
1868		− default:
1869		− rbd_warn(NULL, "unexpected OSD op: object_no %016llx opcode %d",
1870		− obj_request->object_no, opcode);
1871		− break;
1872		− }
	1409	+ obj_req->result = osd_req->r_result < 0 ? osd_req->r_result : 0;
	1410	+ if (!obj_req->result && !rbd_img_is_write(obj_req->img_request))
	1411	+ obj_req->xferred = osd_req->r_result;
	1412	+ else
	1413	+ /*
	1414	+ * Writes aren't allowed to return a data payload. In some
	1415	+ * guarded write cases (e.g. stat + zero on an empty object)
	1416	+ * a stat response makes it through, but we don't care.
	1417	+ */
	1418	+ obj_req->xferred = 0;
1873	1419
1874		− if (obj_request_done_test(obj_request))
1875		− rbd_obj_request_complete(obj_request);
	1420	+ rbd_obj_handle_request(obj_req);
1876	1421	}
1877	1422
1878	1423	static void rbd_osd_req_format_read(struct rbd_obj_request *obj_request)
1879	1424	{
1880	1425	struct ceph_osd_request *osd_req = obj_request->osd_req;
1881	1426
1882		− rbd_assert(obj_request_img_data_test(obj_request));
	1427	+ osd_req->r_flags = CEPH_OSD_FLAG_READ;
1883	1428	osd_req->r_snapid = obj_request->img_request->snap_id;
1884	1429	}
1885	1430
@@ -1887,32 +1432,33 @@ static void rbd_osd_req_format_write(struct rbd_obj_request *obj_request) · 1 unmodified line
1887	1432	{
1888	1433	struct ceph_osd_request *osd_req = obj_request->osd_req;
1889	1434
	1435	+ osd_req->r_flags = CEPH_OSD_FLAG_WRITE;
1890	1436	ktime_get_real_ts(&osd_req->r_mtime);
1891		− osd_req->r_data_offset = obj_request->offset;
	1437	+ osd_req->r_data_offset = obj_request->ex.oe_off;
1892	1438	}
1893	1439
1894	1440	static struct ceph_osd_request *
1895		−__rbd_osd_req_create(struct rbd_device *rbd_dev,
1896		− struct ceph_snap_context *snapc,
1897		− int num_ops, unsigned int flags,
1898		− struct rbd_obj_request *obj_request)
	1441	+rbd_osd_req_create(struct rbd_obj_request *obj_req, unsigned int num_ops)
1899	1442	{
	1443	+ struct rbd_img_request *img_req = obj_req->img_request;
	1444	+ struct rbd_device *rbd_dev = img_req->rbd_dev;
1900	1445	struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
1901	1446	struct ceph_osd_request *req;
1902	1447	const char *name_format = rbd_dev->image_format == 1 ?
1903	1448	RBD_V1_DATA_FORMAT : RBD_V2_DATA_FORMAT;
1904	1449
1905		− req = ceph_osdc_alloc_request(osdc, snapc, num_ops, false, GFP_NOIO);
	1450	+ req = ceph_osdc_alloc_request(osdc,
	1451	+ (rbd_img_is_write(img_req) ? img_req->snapc : NULL),
	1452	+ num_ops, false, GFP_NOIO);
1906	1453	if (!req)
1907	1454	return NULL;
1908	1455
1909		− req->r_flags = flags;
1910	1456	req->r_callback = rbd_osd_req_callback;
1911		− req->r_priv = obj_request;
	1457	+ req->r_priv = obj_req;
1912	1458
1913	1459	req->r_base_oloc.pool = rbd_dev->layout.pool_id;
1914	1460	if (ceph_oid_aprintf(&req->r_base_oid, GFP_NOIO, name_format,
1915		− rbd_dev->header.object_prefix, obj_request->object_no))
	1461	+ rbd_dev->header.object_prefix, obj_req->ex.oe_objno))
1916	1462	goto err_req;
1917	1463
1918	1464	if (ceph_osdc_alloc_messages(req, GFP_NOIO))
@@ -1925,83 +1471,20 @@ err_req: · 6 unmodified lines
1925	1471	return NULL;
1926	1472	}
1927	1473
1928		−/*
1929		− * Create an osd request. A read request has one osd op (read).
1930		− * A write request has either one (watch) or two (hint+write) osd ops.
1931		− * (All rbd data writes are prefixed with an allocation hint op, but
1932		− * technically osd watch is a write request, hence this distinction.)
1933		− */
1934		−static struct ceph_osd_request *rbd_osd_req_create(
1935		− struct rbd_device *rbd_dev,
1936		− enum obj_operation_type op_type,
1937		− unsigned int num_ops,
1938		− struct rbd_obj_request *obj_request)
1939		−{
1940		− struct ceph_snap_context *snapc = NULL;
1941		−
1942		− if (obj_request_img_data_test(obj_request) &&
1943		− (op_type == OBJ_OP_DISCARD \|\| op_type == OBJ_OP_WRITE)) {
1944		− struct rbd_img_request *img_request = obj_request->img_request;
1945		− if (op_type == OBJ_OP_WRITE) {
1946		− rbd_assert(img_request_write_test(img_request));
1947		− } else {
1948		− rbd_assert(img_request_discard_test(img_request));
1949		− }
1950		− snapc = img_request->snapc;
1951		− }
1952		−
1953		− rbd_assert(num_ops == 1 \|\| ((op_type == OBJ_OP_WRITE) && num_ops == 2));
1954		−
1955		− return __rbd_osd_req_create(rbd_dev, snapc, num_ops,
1956		− (op_type == OBJ_OP_WRITE \|\| op_type == OBJ_OP_DISCARD) ?
1957		− CEPH_OSD_FLAG_WRITE : CEPH_OSD_FLAG_READ, obj_request);
1958		−}
1959		−
1960		−/*
1961		− * Create a copyup osd request based on the information in the object
1962		− * request supplied. A copyup request has two or three osd ops, a
1963		− * copyup method call, potentially a hint op, and a write or truncate
1964		− * or zero op.
1965		− */
1966		−static struct ceph_osd_request *
1967		−rbd_osd_req_create_copyup(struct rbd_obj_request *obj_request)
1968		−{
1969		− struct rbd_img_request *img_request;
1970		− int num_osd_ops = 3;
1971		−
1972		− rbd_assert(obj_request_img_data_test(obj_request));
1973		− img_request = obj_request->img_request;
1974		− rbd_assert(img_request);
1975		− rbd_assert(img_request_write_test(img_request) \|\|
1976		− img_request_discard_test(img_request));
1977		−
1978		− if (img_request_discard_test(img_request))
1979		− num_osd_ops = 2;
1980		−
1981		− return __rbd_osd_req_create(img_request->rbd_dev,
1982		− img_request->snapc, num_osd_ops,
1983		− CEPH_OSD_FLAG_WRITE, obj_request);
1984		−}
1985		−
1986	1474	static void rbd_osd_req_destroy(struct ceph_osd_request *osd_req)
1987	1475	{
1988	1476	ceph_osdc_put_request(osd_req);
1989	1477	}
1990	1478
1991		−static struct rbd_obj_request *
1992		−rbd_obj_request_create(enum obj_request_type type)
	1479	+static struct rbd_obj_request *rbd_obj_request_create(void)
1993	1480	{
1994	1481	struct rbd_obj_request *obj_request;
1995	1482
1996		− rbd_assert(obj_request_type_valid(type));
1997		−
1998	1483	obj_request = kmem_cache_zalloc(rbd_obj_request_cache, GFP_NOIO);
1999	1484	if (!obj_request)
2000	1485	return NULL;
2001	1486
2002		− obj_request->which = BAD_WHICH;
2003		− obj_request->type = type;
2004		− INIT_LIST_HEAD(&obj_request->links);
	1487	+ ceph_object_extent_init(&obj_request->ex);
2005	1488	kref_init(&obj_request->kref);
2006	1489
2007	1490	dout("%s %p\n", __func__, obj_request);
@@ -2011,32 +1494,34 @@ rbd_obj_request_create(enum obj_request_type type) · 3 unmodified lines
2011	1494	static void rbd_obj_request_destroy(struct kref *kref)
2012	1495	{
2013	1496	struct rbd_obj_request *obj_request;
	1497	+ u32 i;
2014	1498
2015	1499	obj_request = container_of(kref, struct rbd_obj_request, kref);
2016	1500
2017	1501	dout("%s: obj %p\n", __func__, obj_request);
2018	1502
2019		− rbd_assert(obj_request->img_request == NULL);
2020		− rbd_assert(obj_request->which == BAD_WHICH);
2021		−
2022	1503	if (obj_request->osd_req)
2023	1504	rbd_osd_req_destroy(obj_request->osd_req);
2024	1505
2025		− rbd_assert(obj_request_type_valid(obj_request->type));
2026		− switch (obj_request->type) {
	1506	+ switch (obj_request->img_request->data_type) {
2027	1507	case OBJ_REQUEST_NODATA:
2028		− break; /* Nothing to do */
2029	1508	case OBJ_REQUEST_BIO:
2030		− if (obj_request->bio_list)
2031		− bio_chain_put(obj_request->bio_list);
2032		− break;
2033		− case OBJ_REQUEST_PAGES:
2034		− /* img_data requests don't own their page array */
2035		− if (obj_request->pages &&
2036		− !obj_request_img_data_test(obj_request))
2037		− ceph_release_page_vector(obj_request->pages,
2038		− obj_request->page_count);
	1509	+ case OBJ_REQUEST_BVECS:
	1510	+ break; /* Nothing to do */
	1511	+ case OBJ_REQUEST_OWN_BVECS:
	1512	+ kfree(obj_request->bvec_pos.bvecs);
2039	1513	break;
	1514	+ default:
	1515	+ rbd_assert(0);
	1516	+ }
	1517	+
	1518	+ kfree(obj_request->img_extents);
	1519	+ if (obj_request->copyup_bvecs) {
	1520	+ for (i = 0; i < obj_request->copyup_bvec_count; i++) {
	1521	+ if (obj_request->copyup_bvecs[i].bv_page)
	1522	+ __free_page(obj_request->copyup_bvecs[i].bv_page);
	1523	+ }
	1524	+ kfree(obj_request->copyup_bvecs);
2040	1525	}
2041	1526
2042	1527	kmem_cache_free(rbd_obj_request_cache, obj_request);
@@ -2111,7 +1596,6 @@ static bool rbd_dev_parent_get(struct rbd_device *rbd_dev) · 68 unmodified lines
2111	1596	*/
2112	1597	static struct rbd_img_request *rbd_img_request_create(
2113	1598	struct rbd_device *rbd_dev,
2114		− u64 offset, u64 length,
2115	1599	enum obj_operation_type op_type,
2116	1600	struct ceph_snap_context *snapc)
2117	1601	{
@@ -2122,27 +1606,21 @@ static struct rbd_img_request *rbd_img_request_create( · 4 unmodified lines
2122	1606	return NULL;
2123	1607
2124	1608	img_request->rbd_dev = rbd_dev;
2125		− img_request->offset = offset;
2126		− img_request->length = length;
2127		− if (op_type == OBJ_OP_DISCARD) {
2128		− img_request_discard_set(img_request);
2129		− img_request->snapc = snapc;
2130		− } else if (op_type == OBJ_OP_WRITE) {
2131		− img_request_write_set(img_request);
2132		− img_request->snapc = snapc;
2133		− } else {
	1609	+ img_request->op_type = op_type;
	1610	+ if (!rbd_img_is_write(img_request))
2134	1611	img_request->snap_id = rbd_dev->spec->snap_id;
2135		− }
	1612	+ else
	1613	+ img_request->snapc = snapc;
	1614	+
2136	1615	if (rbd_dev_parent_get(rbd_dev))
2137	1616	img_request_layered_set(img_request);
2138	1617
2139	1618	spin_lock_init(&img_request->completion_lock);
2140		− INIT_LIST_HEAD(&img_request->obj_requests);
	1619	+ INIT_LIST_HEAD(&img_request->object_extents);
2141	1620	kref_init(&img_request->kref);
2142	1621
2143		− dout("%s: rbd_dev %p %s %llu/%llu -> img %p\n", __func__, rbd_dev,
2144		− obj_op_name(op_type), offset, length, img_request);
2145		−
	1622	+ dout("%s: rbd_dev %p %s -> img %p\n", __func__, rbd_dev,
	1623	+ obj_op_name(op_type), img_request);
2146	1624	return img_request;
2147	1625	}
2148	1626
@@ -2165,829 +1643,934 @@ static void rbd_img_request_destroy(struct kref *kref) · 16 unmodified lines
2165	1643	rbd_dev_parent_put(img_request->rbd_dev);
2166	1644	}
2167	1645
2168		− if (img_request_write_test(img_request) \|\|
2169		− img_request_discard_test(img_request))
	1646	+ if (rbd_img_is_write(img_request))
2170	1647	ceph_put_snap_context(img_request->snapc);
2171	1648
2172	1649	kmem_cache_free(rbd_img_request_cache, img_request);
2173	1650	}
2174	1651
2175		−static struct rbd_img_request *rbd_parent_request_create(
2176		− struct rbd_obj_request *obj_request,
2177		− u64 img_offset, u64 length)
	1652	+static void prune_extents(struct ceph_file_extent *img_extents,
	1653	+ u32 *num_img_extents, u64 overlap)
2178	1654	{
2179		− struct rbd_img_request *parent_request;
2180		− struct rbd_device *rbd_dev;
	1655	+ u32 cnt = *num_img_extents;
2181	1656
2182		− rbd_assert(obj_request->img_request);
2183		− rbd_dev = obj_request->img_request->rbd_dev;
	1657	+ /* drop extents completely beyond the overlap */
	1658	+ while (cnt && img_extents[cnt - 1].fe_off >= overlap)
	1659	+ cnt--;
2184	1660
2185		− parent_request = rbd_img_request_create(rbd_dev->parent, img_offset,
2186		− length, OBJ_OP_READ, NULL);
2187		− if (!parent_request)
2188		− return NULL;
	1661	+ if (cnt) {
	1662	+ struct ceph_file_extent *ex = &img_extents[cnt - 1];
2189	1663
2190		− img_request_child_set(parent_request);
2191		− rbd_obj_request_get(obj_request);
2192		− parent_request->obj_request = obj_request;
	1664	+ /* trim final overlapping extent */
	1665	+ if (ex->fe_off + ex->fe_len > overlap)
	1666	+ ex->fe_len = overlap - ex->fe_off;
	1667	+ }
2193	1668
2194		− return parent_request;
	1669	+ *num_img_extents = cnt;
2195	1670	}
2196	1671
2197		−static void rbd_parent_request_destroy(struct kref *kref)
	1672	+/*
	1673	+ * Determine the byte range(s) covered by either just the object extent
	1674	+ * or the entire object in the parent image.
	1675	+ */
	1676	+static int rbd_obj_calc_img_extents(struct rbd_obj_request *obj_req,
	1677	+ bool entire)
2198	1678	{
2199		− struct rbd_img_request *parent_request;
2200		− struct rbd_obj_request *orig_request;
	1679	+ struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
	1680	+ int ret;
2201	1681
2202		− parent_request = container_of(kref, struct rbd_img_request, kref);
2203		− orig_request = parent_request->obj_request;
	1682	+ if (!rbd_dev->parent_overlap)
	1683	+ return 0;
2204	1684
2205		− parent_request->obj_request = NULL;
2206		− rbd_obj_request_put(orig_request);
2207		− img_request_child_clear(parent_request);
	1685	+ ret = ceph_extent_to_file(&rbd_dev->layout, obj_req->ex.oe_objno,
	1686	+ entire ? 0 : obj_req->ex.oe_off,
	1687	+ entire ? rbd_dev->layout.object_size :
	1688	+ obj_req->ex.oe_len,
	1689	+ &obj_req->img_extents,
	1690	+ &obj_req->num_img_extents);
	1691	+ if (ret)
	1692	+ return ret;
2208	1693
2209		− rbd_img_request_destroy(kref);
	1694	+ prune_extents(obj_req->img_extents, &obj_req->num_img_extents,
	1695	+ rbd_dev->parent_overlap);
	1696	+ return 0;
2210	1697	}
2211	1698
2212		−static bool rbd_img_obj_end_request(struct rbd_obj_request *obj_request)
	1699	+static void rbd_osd_req_setup_data(struct rbd_obj_request *obj_req, u32 which)
2213	1700	{
2214		− struct rbd_img_request *img_request;
2215		− unsigned int xferred;
2216		− int result;
2217		− bool more;
2218		−
2219		− rbd_assert(obj_request_img_data_test(obj_request));
2220		− img_request = obj_request->img_request;
2221		−
2222		− rbd_assert(obj_request->xferred <= (u64)UINT_MAX);
2223		− xferred = (unsigned int)obj_request->xferred;
2224		− result = obj_request->result;
2225		− if (result) {
2226		− struct rbd_device *rbd_dev = img_request->rbd_dev;
2227		− enum obj_operation_type op_type;
2228		−
2229		− if (img_request_discard_test(img_request))
2230		− op_type = OBJ_OP_DISCARD;
2231		− else if (img_request_write_test(img_request))
2232		− op_type = OBJ_OP_WRITE;
2233		− else
2234		− op_type = OBJ_OP_READ;
2235		−
2236		− rbd_warn(rbd_dev, "%s %llx at %llx (%llx)",
2237		− obj_op_name(op_type), obj_request->length,
2238		− obj_request->img_offset, obj_request->offset);
2239		− rbd_warn(rbd_dev, " result %d xferred %x",
2240		− result, xferred);
2241		− if (!img_request->result)
2242		− img_request->result = result;
2243		− /*
2244		− * Need to end I/O on the entire obj_request worth of
2245		− * bytes in case of error.
2246		− */
2247		− xferred = obj_request->length;
	1701	+ switch (obj_req->img_request->data_type) {
	1702	+ case OBJ_REQUEST_BIO:
	1703	+ osd_req_op_extent_osd_data_bio(obj_req->osd_req, which,
	1704	+ &obj_req->bio_pos,
	1705	+ obj_req->ex.oe_len);
	1706	+ break;
	1707	+ case OBJ_REQUEST_BVECS:
	1708	+ case OBJ_REQUEST_OWN_BVECS:
	1709	+ rbd_assert(obj_req->bvec_pos.iter.bi_size ==
	1710	+ obj_req->ex.oe_len);
	1711	+ rbd_assert(obj_req->bvec_idx == obj_req->bvec_count);
	1712	+ osd_req_op_extent_osd_data_bvec_pos(obj_req->osd_req, which,
	1713	+ &obj_req->bvec_pos);
	1714	+ break;
	1715	+ default:
	1716	+ rbd_assert(0);
2248	1717	}
	1718	+}
2249	1719
2250		− if (img_request_child_test(img_request)) {
2251		− rbd_assert(img_request->obj_request != NULL);
2252		− more = obj_request->which < img_request->obj_request_count - 1;
2253		− } else {
2254		− blk_status_t status = errno_to_blk_status(result);
	1720	+static int rbd_obj_setup_read(struct rbd_obj_request *obj_req)
	1721	+{
	1722	+ obj_req->osd_req = rbd_osd_req_create(obj_req, 1);
	1723	+ if (!obj_req->osd_req)
	1724	+ return -ENOMEM;
2255	1725
2256		− rbd_assert(img_request->rq != NULL);
	1726	+ osd_req_op_extent_init(obj_req->osd_req, 0, CEPH_OSD_OP_READ,
	1727	+ obj_req->ex.oe_off, obj_req->ex.oe_len, 0, 0);
	1728	+ rbd_osd_req_setup_data(obj_req, 0);
2257	1729
2258		− more = blk_update_request(img_request->rq, status, xferred);
2259		− if (!more)
2260		− __blk_mq_end_request(img_request->rq, status);
2261		− }
	1730	+ rbd_osd_req_format_read(obj_req);
	1731	+ return 0;
	1732	+}
	1733	+
	1734	+static int __rbd_obj_setup_stat(struct rbd_obj_request *obj_req,
	1735	+ unsigned int which)
	1736	+{
	1737	+ struct page **pages;
2262	1738
2263		− return more;
	1739	+ /*
	1740	+ * The response data for a STAT call consists of:
	1741	+ * le64 length;
	1742	+ * struct {
	1743	+ * le32 tv_sec;
	1744	+ * le32 tv_nsec;
	1745	+ * } mtime;
	1746	+ */
	1747	+ pages = ceph_alloc_page_vector(1, GFP_NOIO);
	1748	+ if (IS_ERR(pages))
	1749	+ return PTR_ERR(pages);
	1750	+
	1751	+ osd_req_op_init(obj_req->osd_req, which, CEPH_OSD_OP_STAT, 0);
	1752	+ osd_req_op_raw_data_in_pages(obj_req->osd_req, which, pages,
	1753	+ 8 + sizeof(struct ceph_timespec),
	1754	+ 0, false, true);
	1755	+ return 0;
2264	1756	}
2265	1757
2266		−static void rbd_img_obj_callback(struct rbd_obj_request *obj_request)
	1758	+static void __rbd_obj_setup_write(struct rbd_obj_request *obj_req,
	1759	+ unsigned int which)
2267	1760	{
2268		− struct rbd_img_request *img_request;
2269		− u32 which = obj_request->which;
2270		− bool more = true;
	1761	+ struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
	1762	+ u16 opcode;
2271	1763
2272		− rbd_assert(obj_request_img_data_test(obj_request));
2273		− img_request = obj_request->img_request;
	1764	+ osd_req_op_alloc_hint_init(obj_req->osd_req, which++,
	1765	+ rbd_dev->layout.object_size,
	1766	+ rbd_dev->layout.object_size);
2274	1767
2275		− dout("%s: img %p obj %p\n", __func__, img_request, obj_request);
2276		− rbd_assert(img_request != NULL);
2277		− rbd_assert(img_request->obj_request_count > 0);
2278		− rbd_assert(which != BAD_WHICH);
2279		− rbd_assert(which < img_request->obj_request_count);
	1768	+ if (rbd_obj_is_entire(obj_req))
	1769	+ opcode = CEPH_OSD_OP_WRITEFULL;
	1770	+ else
	1771	+ opcode = CEPH_OSD_OP_WRITE;
2280	1772
2281		− spin_lock_irq(&img_request->completion_lock);
2282		− if (which != img_request->next_completion)
2283		− goto out;
	1773	+ osd_req_op_extent_init(obj_req->osd_req, which, opcode,
	1774	+ obj_req->ex.oe_off, obj_req->ex.oe_len, 0, 0);
	1775	+ rbd_osd_req_setup_data(obj_req, which++);
2284	1776
2285		− for_each_obj_request_from(img_request, obj_request) {
2286		− rbd_assert(more);
2287		− rbd_assert(which < img_request->obj_request_count);
	1777	+ rbd_assert(which == obj_req->osd_req->r_num_ops);
	1778	+ rbd_osd_req_format_write(obj_req);
	1779	+}
2288	1780
2289		− if (!obj_request_done_test(obj_request))
2290		− break;
2291		− more = rbd_img_obj_end_request(obj_request);
2292		− which++;
	1781	+static int rbd_obj_setup_write(struct rbd_obj_request *obj_req)
	1782	+{
	1783	+ unsigned int num_osd_ops, which = 0;
	1784	+ int ret;
	1785	+
	1786	+ /* reverse map the entire object onto the parent */
	1787	+ ret = rbd_obj_calc_img_extents(obj_req, true);
	1788	+ if (ret)
	1789	+ return ret;
	1790	+
	1791	+ if (obj_req->num_img_extents) {
	1792	+ obj_req->write_state = RBD_OBJ_WRITE_GUARD;
	1793	+ num_osd_ops = 3; /* stat + setallochint + write/writefull */
	1794	+ } else {
	1795	+ obj_req->write_state = RBD_OBJ_WRITE_FLAT;
	1796	+ num_osd_ops = 2; /* setallochint + write/writefull */
2293	1797	}
2294	1798
2295		− rbd_assert(more ^ (which == img_request->obj_request_count));
2296		− img_request->next_completion = which;
2297		−out:
2298		− spin_unlock_irq(&img_request->completion_lock);
2299		− rbd_img_request_put(img_request);
	1799	+ obj_req->osd_req = rbd_osd_req_create(obj_req, num_osd_ops);
	1800	+ if (!obj_req->osd_req)
	1801	+ return -ENOMEM;
2300	1802
2301		− if (!more)
2302		− rbd_img_request_complete(img_request);
	1803	+ if (obj_req->num_img_extents) {
	1804	+ ret = __rbd_obj_setup_stat(obj_req, which++);
	1805	+ if (ret)
	1806	+ return ret;
	1807	+ }
	1808	+
	1809	+ __rbd_obj_setup_write(obj_req, which);
	1810	+ return 0;
2303	1811	}
2304	1812
2305		−/*
2306		− * Add individual osd ops to the given ceph_osd_request and prepare
2307		− * them for submission. num_ops is the current number of
2308		− * osd operations already to the object request.
2309		− */
2310		−static void rbd_img_obj_request_fill(struct rbd_obj_request *obj_request,
2311		− struct ceph_osd_request *osd_request,
2312		− enum obj_operation_type op_type,
2313		− unsigned int num_ops)
2314		−{
2315		− struct rbd_img_request *img_request = obj_request->img_request;
2316		− struct rbd_device *rbd_dev = img_request->rbd_dev;
2317		− u64 object_size = rbd_obj_bytes(&rbd_dev->header);
2318		− u64 offset = obj_request->offset;
2319		− u64 length = obj_request->length;
2320		− u64 img_end;
	1813	+static void __rbd_obj_setup_discard(struct rbd_obj_request *obj_req,
	1814	+ unsigned int which)
	1815	+{
2321	1816	u16 opcode;
2322	1817
2323		− if (op_type == OBJ_OP_DISCARD) {
2324		− if (!offset && length == object_size &&
2325		− (!img_request_layered_test(img_request) \|\|
2326		− !obj_request_overlaps_parent(obj_request))) {
2327		− opcode = CEPH_OSD_OP_DELETE;
2328		− } else if ((offset + length == object_size)) {
	1818	+ if (rbd_obj_is_entire(obj_req)) {
	1819	+ if (obj_req->num_img_extents) {
	1820	+ osd_req_op_init(obj_req->osd_req, which++,
	1821	+ CEPH_OSD_OP_CREATE, 0);
2329	1822	opcode = CEPH_OSD_OP_TRUNCATE;
2330	1823	} else {
2331		− down_read(&rbd_dev->header_rwsem);
2332		− img_end = rbd_dev->header.image_size;
2333		− up_read(&rbd_dev->header_rwsem);
2334		−
2335		− if (obj_request->img_offset + length == img_end)
2336		− opcode = CEPH_OSD_OP_TRUNCATE;
2337		− else
2338		− opcode = CEPH_OSD_OP_ZERO;
	1824	+ osd_req_op_init(obj_req->osd_req, which++,
	1825	+ CEPH_OSD_OP_DELETE, 0);
	1826	+ opcode = 0;
2339	1827	}
2340		− } else if (op_type == OBJ_OP_WRITE) {
2341		− if (!offset && length == object_size)
2342		− opcode = CEPH_OSD_OP_WRITEFULL;
2343		− else
2344		− opcode = CEPH_OSD_OP_WRITE;
2345		− osd_req_op_alloc_hint_init(osd_request, num_ops,
2346		− object_size, object_size);
2347		− num_ops++;
	1828	+ } else if (rbd_obj_is_tail(obj_req)) {
	1829	+ opcode = CEPH_OSD_OP_TRUNCATE;
2348	1830	} else {
2349		− opcode = CEPH_OSD_OP_READ;
	1831	+ opcode = CEPH_OSD_OP_ZERO;
2350	1832	}
2351	1833
2352		− if (opcode == CEPH_OSD_OP_DELETE)
2353		− osd_req_op_init(osd_request, num_ops, opcode, 0);
2354		− else
2355		− osd_req_op_extent_init(osd_request, num_ops, opcode,
2356		− offset, length, 0, 0);
2357		−
2358		− if (obj_request->type == OBJ_REQUEST_BIO)
2359		− osd_req_op_extent_osd_data_bio(osd_request, num_ops,
2360		− obj_request->bio_list, length);
2361		− else if (obj_request->type == OBJ_REQUEST_PAGES)
2362		− osd_req_op_extent_osd_data_pages(osd_request, num_ops,
2363		− obj_request->pages, length,
2364		− offset & ~PAGE_MASK, false, false);
2365		−
2366		− /* Discards are also writes */
2367		− if (op_type == OBJ_OP_WRITE \|\| op_type == OBJ_OP_DISCARD)
2368		− rbd_osd_req_format_write(obj_request);
2369		− else
2370		− rbd_osd_req_format_read(obj_request);
	1834	+ if (opcode)
	1835	+ osd_req_op_extent_init(obj_req->osd_req, which++, opcode,
	1836	+ obj_req->ex.oe_off, obj_req->ex.oe_len,
	1837	+ 0, 0);
	1838	+
	1839	+ rbd_assert(which == obj_req->osd_req->r_num_ops);
	1840	+ rbd_osd_req_format_write(obj_req);
2371	1841	}
2372	1842
2373		−/*
2374		− * Split up an image request into one or more object requests, each
2375		− * to a different object. The "type" parameter indicates whether
2376		− * "data_desc" is the pointer to the head of a list of bio
2377		− * structures, or the base of a page array. In either case this
2378		− * function assumes data_desc describes memory sufficient to hold
2379		− * all data described by the image request.
2380		− */
2381		−static int rbd_img_request_fill(struct rbd_img_request *img_request,
2382		− enum obj_request_type type,
2383		− void *data_desc)
	1843	+static int rbd_obj_setup_discard(struct rbd_obj_request *obj_req)
2384	1844	{
2385		− struct rbd_device *rbd_dev = img_request->rbd_dev;
2386		− struct rbd_obj_request *obj_request = NULL;
2387		− struct rbd_obj_request *next_obj_request;
2388		− struct bio *bio_list = NULL;
2389		− unsigned int bio_offset = 0;
2390		− struct page **pages = NULL;
2391		− enum obj_operation_type op_type;
2392		− u64 img_offset;
2393		− u64 resid;
2394		−
2395		− dout("%s: img %p type %d data_desc %p\n", __func__, img_request,
2396		− (int)type, data_desc);
	1845	+ unsigned int num_osd_ops, which = 0;
	1846	+ int ret;
2397	1847
2398		− img_offset = img_request->offset;
2399		− resid = img_request->length;
2400		− rbd_assert(resid > 0);
2401		− op_type = rbd_img_request_op_type(img_request);
	1848	+ /* reverse map the entire object onto the parent */
	1849	+ ret = rbd_obj_calc_img_extents(obj_req, true);
	1850	+ if (ret)
	1851	+ return ret;
2402	1852
2403		− if (type == OBJ_REQUEST_BIO) {
2404		− bio_list = data_desc;
2405		− rbd_assert(img_offset ==
2406		− bio_list->bi_iter.bi_sector << SECTOR_SHIFT);
2407		− } else if (type == OBJ_REQUEST_PAGES) {
2408		− pages = data_desc;
	1853	+ if (rbd_obj_is_entire(obj_req)) {
	1854	+ obj_req->write_state = RBD_OBJ_WRITE_FLAT;
	1855	+ if (obj_req->num_img_extents)
	1856	+ num_osd_ops = 2; /* create + truncate */
	1857	+ else
	1858	+ num_osd_ops = 1; /* delete */
	1859	+ } else {
	1860	+ if (obj_req->num_img_extents) {
	1861	+ obj_req->write_state = RBD_OBJ_WRITE_GUARD;
	1862	+ num_osd_ops = 2; /* stat + truncate/zero */
	1863	+ } else {
	1864	+ obj_req->write_state = RBD_OBJ_WRITE_FLAT;
	1865	+ num_osd_ops = 1; /* truncate/zero */
	1866	+ }
2409	1867	}
2410	1868
2411		− while (resid) {
2412		− struct ceph_osd_request *osd_req;
2413		− u64 object_no = img_offset >> rbd_dev->header.obj_order;
2414		− u64 offset = rbd_segment_offset(rbd_dev, img_offset);
2415		− u64 length = rbd_segment_length(rbd_dev, img_offset, resid);
2416		−
2417		− obj_request = rbd_obj_request_create(type);
2418		− if (!obj_request)
2419		− goto out_unwind;
2420		−
2421		− obj_request->object_no = object_no;
2422		− obj_request->offset = offset;
2423		− obj_request->length = length;
2424		−
2425		− /*
2426		− * set obj_request->img_request before creating the
2427		− * osd_request so that it gets the right snapc
2428		− */
2429		− rbd_img_obj_request_add(img_request, obj_request);
2430		−
2431		− if (type == OBJ_REQUEST_BIO) {
2432		− unsigned int clone_size;
2433		−
2434		− rbd_assert(length <= (u64)UINT_MAX);
2435		− clone_size = (unsigned int)length;
2436		− obj_request->bio_list =
2437		− bio_chain_clone_range(&bio_list,
2438		− &bio_offset,
2439		− clone_size,
2440		− GFP_NOIO);
2441		− if (!obj_request->bio_list)
2442		− goto out_unwind;
2443		− } else if (type == OBJ_REQUEST_PAGES) {
2444		− unsigned int page_count;
2445		−
2446		− obj_request->pages = pages;
2447		− page_count = (u32)calc_pages_for(offset, length);
2448		− obj_request->page_count = page_count;
2449		− if ((offset + length) & ~PAGE_MASK)
2450		− page_count--; /* more on last page */
2451		− pages += page_count;
2452		− }
	1869	+ obj_req->osd_req = rbd_osd_req_create(obj_req, num_osd_ops);
	1870	+ if (!obj_req->osd_req)
	1871	+ return -ENOMEM;
2453	1872
2454		− osd_req = rbd_osd_req_create(rbd_dev, op_type,
2455		− (op_type == OBJ_OP_WRITE) ? 2 : 1,
2456		− obj_request);
2457		− if (!osd_req)
2458		− goto out_unwind;
	1873	+ if (!rbd_obj_is_entire(obj_req) && obj_req->num_img_extents) {
	1874	+ ret = __rbd_obj_setup_stat(obj_req, which++);
	1875	+ if (ret)
	1876	+ return ret;
	1877	+ }
2459	1878
2460		− obj_request->osd_req = osd_req;
2461		− obj_request->callback = rbd_img_obj_callback;
2462		− obj_request->img_offset = img_offset;
	1879	+ __rbd_obj_setup_discard(obj_req, which);
	1880	+ return 0;
	1881	+}
2463	1882
2464		− rbd_img_obj_request_fill(obj_request, osd_req, op_type, 0);
	1883	+/*
	1884	+ * For each object request in @img_req, allocate an OSD request, add
	1885	+ * individual OSD ops and prepare them for submission. The number of
	1886	+ * OSD ops depends on op_type and the overlap point (if any).
	1887	+ */
	1888	+static int __rbd_img_fill_request(struct rbd_img_request *img_req)
	1889	+{
	1890	+ struct rbd_obj_request *obj_req;
	1891	+ int ret;
2465	1892
2466		− img_offset += length;
2467		− resid -= length;
	1893	+ for_each_obj_request(img_req, obj_req) {
	1894	+ switch (img_req->op_type) {
	1895	+ case OBJ_OP_READ:
	1896	+ ret = rbd_obj_setup_read(obj_req);
	1897	+ break;
	1898	+ case OBJ_OP_WRITE:
	1899	+ ret = rbd_obj_setup_write(obj_req);
	1900	+ break;
	1901	+ case OBJ_OP_DISCARD:
	1902	+ ret = rbd_obj_setup_discard(obj_req);
	1903	+ break;
	1904	+ default:
	1905	+ rbd_assert(0);
	1906	+ }
	1907	+ if (ret)
	1908	+ return ret;
2468	1909	}
2469	1910
2470	1911	return 0;
	1912	+}
2471	1913
2472		−out_unwind:
2473		− for_each_obj_request_safe(img_request, obj_request, next_obj_request)
2474		− rbd_img_obj_request_del(img_request, obj_request);
	1914	+union rbd_img_fill_iter {
	1915	+ struct ceph_bio_iter bio_iter;
	1916	+ struct ceph_bvec_iter bvec_iter;
	1917	+};
2475	1918
2476		− return -ENOMEM;
2477		−}
	1919	+struct rbd_img_fill_ctx {
	1920	+ enum obj_request_type pos_type;
	1921	+ union rbd_img_fill_iter *pos;
	1922	+ union rbd_img_fill_iter iter;
	1923	+ ceph_object_extent_fn_t set_pos_fn;
	1924	+ ceph_object_extent_fn_t count_fn;
	1925	+ ceph_object_extent_fn_t copy_fn;
	1926	+};
2478	1927
2479		−static void
2480		−rbd_osd_copyup_callback(struct rbd_obj_request *obj_request)
	1928	+static struct ceph_object_extent alloc_object_extent(void arg)
2481	1929	{
2482		− struct rbd_img_request *img_request;
2483		− struct rbd_device *rbd_dev;
2484		− struct page **pages;
2485		− u32 page_count;
	1930	+ struct rbd_img_request *img_req = arg;
	1931	+ struct rbd_obj_request *obj_req;
2486	1932
2487		− dout("%s: obj %p\n", __func__, obj_request);
	1933	+ obj_req = rbd_obj_request_create();
	1934	+ if (!obj_req)
	1935	+ return NULL;
2488	1936
2489		− rbd_assert(obj_request->type == OBJ_REQUEST_BIO \|\|
2490		− obj_request->type == OBJ_REQUEST_NODATA);
2491		− rbd_assert(obj_request_img_data_test(obj_request));
2492		− img_request = obj_request->img_request;
2493		− rbd_assert(img_request);
	1937	+ rbd_img_obj_request_add(img_req, obj_req);
	1938	+ return &obj_req->ex;
	1939	+}
2494	1940
2495		− rbd_dev = img_request->rbd_dev;
2496		− rbd_assert(rbd_dev);
	1941	+/*
	1942	+ * While su != os && sc == 1 is technically not fancy (it's the same
	1943	+ * layout as su == os && sc == 1), we can't use the nocopy path for it
	1944	+ * because ->set_pos_fn() should be called only once per object.
	1945	+ * ceph_file_to_extents() invokes action_fn once per stripe unit, so
	1946	+ * treat su != os && sc == 1 as fancy.
	1947	+ */
	1948	+static bool rbd_layout_is_fancy(struct ceph_file_layout *l)
	1949	+{
	1950	+ return l->stripe_unit != l->object_size;
	1951	+}
2497	1952
2498		− pages = obj_request->copyup_pages;
2499		− rbd_assert(pages != NULL);
2500		− obj_request->copyup_pages = NULL;
2501		− page_count = obj_request->copyup_page_count;
2502		− rbd_assert(page_count);
2503		− obj_request->copyup_page_count = 0;
2504		− ceph_release_page_vector(pages, page_count);
	1953	+static int rbd_img_fill_request_nocopy(struct rbd_img_request *img_req,
	1954	+ struct ceph_file_extent *img_extents,
	1955	+ u32 num_img_extents,
	1956	+ struct rbd_img_fill_ctx *fctx)
	1957	+{
	1958	+ u32 i;
	1959	+ int ret;
	1960	+
	1961	+ img_req->data_type = fctx->pos_type;
2505	1962
2506	1963	/*
2507		− * We want the transfer count to reflect the size of the
2508		− * original write request. There is no such thing as a
2509		− * successful short write, so if the request was successful
2510		− * we can just set it to the originally-requested length.
	1964	+ * Create object requests and set each object request's starting
	1965	+ * position in the provided bio (list) or bio_vec array.
2511	1966	*/
2512		− if (!obj_request->result)
2513		− obj_request->xferred = obj_request->length;
	1967	+ fctx->iter = *fctx->pos;
	1968	+ for (i = 0; i < num_img_extents; i++) {
	1969	+ ret = ceph_file_to_extents(&img_req->rbd_dev->layout,
	1970	+ img_extents[i].fe_off,
	1971	+ img_extents[i].fe_len,
	1972	+ &img_req->object_extents,
	1973	+ alloc_object_extent, img_req,
	1974	+ fctx->set_pos_fn, &fctx->iter);
	1975	+ if (ret)
	1976	+ return ret;
	1977	+ }
2514	1978
2515		− obj_request_done_set(obj_request);
	1979	+ return __rbd_img_fill_request(img_req);
2516	1980	}
2517	1981
2518		−static void
2519		−rbd_img_obj_parent_read_full_callback(struct rbd_img_request *img_request)
	1982	+/*
	1983	+ * Map a list of image extents to a list of object extents, create the
	1984	+ * corresponding object requests (normally each to a different object,
	1985	+ * but not always) and add them to @img_req. For each object request,
	1986	+ * set up its data descriptor to point to the corresponding chunk(s) of
	1987	+ * @fctx->pos data buffer.
	1988	+ *
	1989	+ * Because ceph_file_to_extents() will merge adjacent object extents
	1990	+ * together, each object request's data descriptor may point to multiple
	1991	+ * different chunks of @fctx->pos data buffer.
	1992	+ *
	1993	+ * @fctx->pos data buffer is assumed to be large enough.
	1994	+ */
	1995	+static int rbd_img_fill_request(struct rbd_img_request *img_req,
	1996	+ struct ceph_file_extent *img_extents,
	1997	+ u32 num_img_extents,
	1998	+ struct rbd_img_fill_ctx *fctx)
2520	1999	{
2521		− struct rbd_obj_request *orig_request;
2522		− struct ceph_osd_request *osd_req;
2523		− struct rbd_device *rbd_dev;
2524		− struct page **pages;
2525		− enum obj_operation_type op_type;
2526		− u32 page_count;
2527		− int img_result;
2528		− u64 parent_length;
2529		−
2530		− rbd_assert(img_request_child_test(img_request));
2531		−
2532		− /* First get what we need from the image request */
2533		−
2534		− pages = img_request->copyup_pages;
2535		− rbd_assert(pages != NULL);
2536		− img_request->copyup_pages = NULL;
2537		− page_count = img_request->copyup_page_count;
2538		− rbd_assert(page_count);
2539		− img_request->copyup_page_count = 0;
2540		−
2541		− orig_request = img_request->obj_request;
2542		− rbd_assert(orig_request != NULL);
2543		− rbd_assert(obj_request_type_valid(orig_request->type));
2544		− img_result = img_request->result;
2545		− parent_length = img_request->length;
2546		− rbd_assert(img_result \|\| parent_length == img_request->xferred);
2547		− rbd_img_request_put(img_request);
	2000	+ struct rbd_device *rbd_dev = img_req->rbd_dev;
	2001	+ struct rbd_obj_request *obj_req;
	2002	+ u32 i;
	2003	+ int ret;
	2004	+
	2005	+ if (fctx->pos_type == OBJ_REQUEST_NODATA \|\|
	2006	+ !rbd_layout_is_fancy(&rbd_dev->layout))
	2007	+ return rbd_img_fill_request_nocopy(img_req, img_extents,
	2008	+ num_img_extents, fctx);
2548	2009
2549		− rbd_assert(orig_request->img_request);
2550		− rbd_dev = orig_request->img_request->rbd_dev;
2551		− rbd_assert(rbd_dev);
	2010	+ img_req->data_type = OBJ_REQUEST_OWN_BVECS;
2552	2011
2553	2012	/*
2554		− * If the overlap has become 0 (most likely because the
2555		− * image has been flattened) we need to free the pages
2556		− * and re-submit the original write request.
	2013	+ * Create object requests and determine ->bvec_count for each object
	2014	+ * request. Note that ->bvec_count sum over all object requests may
	2015	+ * be greater than the number of bio_vecs in the provided bio (list)
	2016	+ * or bio_vec array because when mapped, those bio_vecs can straddle
	2017	+ * stripe unit boundaries.
2557	2018	*/
2558		− if (!rbd_dev->parent_overlap) {
2559		− ceph_release_page_vector(pages, page_count);
2560		− rbd_obj_request_submit(orig_request);
2561		− return;
	2019	+ fctx->iter = *fctx->pos;
	2020	+ for (i = 0; i < num_img_extents; i++) {
	2021	+ ret = ceph_file_to_extents(&rbd_dev->layout,
	2022	+ img_extents[i].fe_off,
	2023	+ img_extents[i].fe_len,
	2024	+ &img_req->object_extents,
	2025	+ alloc_object_extent, img_req,
	2026	+ fctx->count_fn, &fctx->iter);
	2027	+ if (ret)
	2028	+ return ret;
2562	2029	}
2563	2030
2564		− if (img_result)
2565		− goto out_err;
	2031	+ for_each_obj_request(img_req, obj_req) {
	2032	+ obj_req->bvec_pos.bvecs = kmalloc_array(obj_req->bvec_count,
	2033	+ sizeof(*obj_req->bvec_pos.bvecs),
	2034	+ GFP_NOIO);
	2035	+ if (!obj_req->bvec_pos.bvecs)
	2036	+ return -ENOMEM;
	2037	+ }
2566	2038
2567	2039	/*
2568		− * The original osd request is of no use to use any more.
2569		− * We need a new one that can hold the three ops in a copyup
2570		− * request. Allocate the new copyup osd request for the
2571		− * original request, and release the old one.
	2040	+ * Fill in each object request's private bio_vec array, splitting and
	2041	+ * rearranging the provided bio_vecs in stripe unit chunks as needed.
2572	2042	*/
2573		− img_result = -ENOMEM;
2574		− osd_req = rbd_osd_req_create_copyup(orig_request);
2575		− if (!osd_req)
2576		− goto out_err;
2577		− rbd_osd_req_destroy(orig_request->osd_req);
2578		− orig_request->osd_req = osd_req;
2579		− orig_request->copyup_pages = pages;
2580		− orig_request->copyup_page_count = page_count;
	2043	+ fctx->iter = *fctx->pos;
	2044	+ for (i = 0; i < num_img_extents; i++) {
	2045	+ ret = ceph_iterate_extents(&rbd_dev->layout,
	2046	+ img_extents[i].fe_off,
	2047	+ img_extents[i].fe_len,
	2048	+ &img_req->object_extents,
	2049	+ fctx->copy_fn, &fctx->iter);
	2050	+ if (ret)
	2051	+ return ret;
	2052	+ }
2581	2053
2582		− /* Initialize the copyup op */
	2054	+ return __rbd_img_fill_request(img_req);
	2055	+}
	2056	+
	2057	+static int rbd_img_fill_nodata(struct rbd_img_request *img_req,
	2058	+ u64 off, u64 len)
	2059	+{
	2060	+ struct ceph_file_extent ex = { off, len };
	2061	+ union rbd_img_fill_iter dummy;
	2062	+ struct rbd_img_fill_ctx fctx = {
	2063	+ .pos_type = OBJ_REQUEST_NODATA,
	2064	+ .pos = &dummy,
	2065	+ };
	2066	+
	2067	+ return rbd_img_fill_request(img_req, &ex, 1, &fctx);
	2068	+}
	2069	+
	2070	+static void set_bio_pos(struct ceph_object_extent ex, u32 bytes, void arg)
	2071	+{
	2072	+ struct rbd_obj_request *obj_req =
	2073	+ container_of(ex, struct rbd_obj_request, ex);
	2074	+ struct ceph_bio_iter *it = arg;
2583	2075
2584		− osd_req_op_cls_init(osd_req, 0, CEPH_OSD_OP_CALL, "rbd", "copyup");
2585		− osd_req_op_cls_request_data_pages(osd_req, 0, pages, parent_length, 0,
2586		− false, false);
	2076	+ dout("%s objno %llu bytes %u\n", __func__, ex->oe_objno, bytes);
	2077	+ obj_req->bio_pos = *it;
	2078	+ ceph_bio_iter_advance(it, bytes);
	2079	+}
2587	2080
2588		− /* Add the other op(s) */
	2081	+static void count_bio_bvecs(struct ceph_object_extent ex, u32 bytes, void arg)
	2082	+{
	2083	+ struct rbd_obj_request *obj_req =
	2084	+ container_of(ex, struct rbd_obj_request, ex);
	2085	+ struct ceph_bio_iter *it = arg;
2589	2086
2590		− op_type = rbd_img_request_op_type(orig_request->img_request);
2591		− rbd_img_obj_request_fill(orig_request, osd_req, op_type, 1);
	2087	+ dout("%s objno %llu bytes %u\n", __func__, ex->oe_objno, bytes);
	2088	+ ceph_bio_iter_advance_step(it, bytes, ({
	2089	+ obj_req->bvec_count++;
	2090	+ }));
2592	2091
2593		− /* All set, send it off. */
	2092	+}
2594	2093
2595		− rbd_obj_request_submit(orig_request);
2596		− return;
	2094	+static void copy_bio_bvecs(struct ceph_object_extent ex, u32 bytes, void arg)
	2095	+{
	2096	+ struct rbd_obj_request *obj_req =
	2097	+ container_of(ex, struct rbd_obj_request, ex);
	2098	+ struct ceph_bio_iter *it = arg;
2597	2099
2598		−out_err:
2599		− ceph_release_page_vector(pages, page_count);
2600		− rbd_obj_request_error(orig_request, img_result);
	2100	+ dout("%s objno %llu bytes %u\n", __func__, ex->oe_objno, bytes);
	2101	+ ceph_bio_iter_advance_step(it, bytes, ({
	2102	+ obj_req->bvec_pos.bvecs[obj_req->bvec_idx++] = bv;
	2103	+ obj_req->bvec_pos.iter.bi_size += bv.bv_len;
	2104	+ }));
2601	2105	}
2602	2106
2603		−/*
2604		− * Read from the parent image the range of data that covers the
2605		− * entire target of the given object request. This is used for
2606		− * satisfying a layered image write request when the target of an
2607		− * object request from the image request does not exist.
2608		− *
2609		− * A page array big enough to hold the returned data is allocated
2610		− * and supplied to rbd_img_request_fill() as the "data descriptor."
2611		− * When the read completes, this page array will be transferred to
2612		− * the original object request for the copyup operation.
2613		− *
2614		− * If an error occurs, it is recorded as the result of the original
2615		− * object request in rbd_img_obj_exists_callback().
2616		− */
2617		−static int rbd_img_obj_parent_read_full(struct rbd_obj_request *obj_request)
2618		−{
2619		− struct rbd_device *rbd_dev = obj_request->img_request->rbd_dev;
2620		− struct rbd_img_request *parent_request = NULL;
2621		− u64 img_offset;
2622		− u64 length;
2623		− struct page **pages = NULL;
2624		− u32 page_count;
2625		− int result;
	2107	+static int __rbd_img_fill_from_bio(struct rbd_img_request *img_req,
	2108	+ struct ceph_file_extent *img_extents,
	2109	+ u32 num_img_extents,
	2110	+ struct ceph_bio_iter *bio_pos)
	2111	+{
	2112	+ struct rbd_img_fill_ctx fctx = {
	2113	+ .pos_type = OBJ_REQUEST_BIO,
	2114	+ .pos = (union rbd_img_fill_iter *)bio_pos,
	2115	+ .set_pos_fn = set_bio_pos,
	2116	+ .count_fn = count_bio_bvecs,
	2117	+ .copy_fn = copy_bio_bvecs,
	2118	+ };
2626	2119
2627		− rbd_assert(rbd_dev->parent != NULL);
	2120	+ return rbd_img_fill_request(img_req, img_extents, num_img_extents,
	2121	+ &fctx);
	2122	+}
2628	2123
2629		− /*
2630		− * Determine the byte range covered by the object in the
2631		− * child image to which the original request was to be sent.
2632		− */
2633		− img_offset = obj_request->img_offset - obj_request->offset;
2634		− length = rbd_obj_bytes(&rbd_dev->header);
	2124	+static int rbd_img_fill_from_bio(struct rbd_img_request *img_req,
	2125	+ u64 off, u64 len, struct bio *bio)
	2126	+{
	2127	+ struct ceph_file_extent ex = { off, len };
	2128	+ struct ceph_bio_iter it = { .bio = bio, .iter = bio->bi_iter };
2635	2129
2636		− /*
2637		− * There is no defined parent data beyond the parent
2638		− * overlap, so limit what we read at that boundary if
2639		− * necessary.
2640		− */
2641		− if (img_offset + length > rbd_dev->parent_overlap) {
2642		− rbd_assert(img_offset < rbd_dev->parent_overlap);
2643		− length = rbd_dev->parent_overlap - img_offset;
2644		− }
	2130	+ return __rbd_img_fill_from_bio(img_req, &ex, 1, &it);
	2131	+}
2645	2132
2646		− /*
2647		− * Allocate a page array big enough to receive the data read
2648		− * from the parent.
2649		− */
2650		− page_count = (u32)calc_pages_for(0, length);
2651		− pages = ceph_alloc_page_vector(page_count, GFP_NOIO);
2652		− if (IS_ERR(pages)) {
2653		− result = PTR_ERR(pages);
2654		− pages = NULL;
2655		− goto out_err;
2656		− }
	2133	+static void set_bvec_pos(struct ceph_object_extent ex, u32 bytes, void arg)
	2134	+{
	2135	+ struct rbd_obj_request *obj_req =
	2136	+ container_of(ex, struct rbd_obj_request, ex);
	2137	+ struct ceph_bvec_iter *it = arg;
2657	2138
2658		− result = -ENOMEM;
2659		− parent_request = rbd_parent_request_create(obj_request,
2660		− img_offset, length);
2661		− if (!parent_request)
2662		− goto out_err;
	2139	+ obj_req->bvec_pos = *it;
	2140	+ ceph_bvec_iter_shorten(&obj_req->bvec_pos, bytes);
	2141	+ ceph_bvec_iter_advance(it, bytes);
	2142	+}
2663	2143
2664		− result = rbd_img_request_fill(parent_request, OBJ_REQUEST_PAGES, pages);
2665		− if (result)
2666		− goto out_err;
	2144	+static void count_bvecs(struct ceph_object_extent ex, u32 bytes, void arg)
	2145	+{
	2146	+ struct rbd_obj_request *obj_req =
	2147	+ container_of(ex, struct rbd_obj_request, ex);
	2148	+ struct ceph_bvec_iter *it = arg;
2667	2149
2668		− parent_request->copyup_pages = pages;
2669		− parent_request->copyup_page_count = page_count;
2670		− parent_request->callback = rbd_img_obj_parent_read_full_callback;
	2150	+ ceph_bvec_iter_advance_step(it, bytes, ({
	2151	+ obj_req->bvec_count++;
	2152	+ }));
	2153	+}
2671	2154
2672		− result = rbd_img_request_submit(parent_request);
2673		− if (!result)
2674		− return 0;
	2155	+static void copy_bvecs(struct ceph_object_extent ex, u32 bytes, void arg)
	2156	+{
	2157	+ struct rbd_obj_request *obj_req =
	2158	+ container_of(ex, struct rbd_obj_request, ex);
	2159	+ struct ceph_bvec_iter *it = arg;
2675	2160
2676		− parent_request->copyup_pages = NULL;
2677		− parent_request->copyup_page_count = 0;
2678		−out_err:
2679		− if (pages)
2680		− ceph_release_page_vector(pages, page_count);
2681		− if (parent_request)
2682		− rbd_img_request_put(parent_request);
2683		− return result;
	2161	+ ceph_bvec_iter_advance_step(it, bytes, ({
	2162	+ obj_req->bvec_pos.bvecs[obj_req->bvec_idx++] = bv;
	2163	+ obj_req->bvec_pos.iter.bi_size += bv.bv_len;
	2164	+ }));
2684	2165	}
2685	2166
2686		−static void rbd_img_obj_exists_callback(struct rbd_obj_request *obj_request)
	2167	+static int __rbd_img_fill_from_bvecs(struct rbd_img_request *img_req,
	2168	+ struct ceph_file_extent *img_extents,
	2169	+ u32 num_img_extents,
	2170	+ struct ceph_bvec_iter *bvec_pos)
2687	2171	{
2688		− struct rbd_obj_request *orig_request;
2689		− struct rbd_device *rbd_dev;
2690		− int result;
	2172	+ struct rbd_img_fill_ctx fctx = {
	2173	+ .pos_type = OBJ_REQUEST_BVECS,
	2174	+ .pos = (union rbd_img_fill_iter *)bvec_pos,
	2175	+ .set_pos_fn = set_bvec_pos,
	2176	+ .count_fn = count_bvecs,
	2177	+ .copy_fn = copy_bvecs,
	2178	+ };
2691	2179
2692		− rbd_assert(!obj_request_img_data_test(obj_request));
	2180	+ return rbd_img_fill_request(img_req, img_extents, num_img_extents,
	2181	+ &fctx);
	2182	+}
2693	2183
2694		− /*
2695		− * All we need from the object request is the original
2696		− * request and the result of the STAT op. Grab those, then
2697		− * we're done with the request.
2698		− */
2699		− orig_request = obj_request->obj_request;
2700		− obj_request->obj_request = NULL;
2701		− rbd_obj_request_put(orig_request);
2702		− rbd_assert(orig_request);
2703		− rbd_assert(orig_request->img_request);
2704		−
2705		− result = obj_request->result;
2706		− obj_request->result = 0;
2707		−
2708		− dout("%s: obj %p for obj %p result %d %llu/%llu\n", __func__,
2709		− obj_request, orig_request, result,
2710		− obj_request->xferred, obj_request->length);
2711		− rbd_obj_request_put(obj_request);
	2184	+static int rbd_img_fill_from_bvecs(struct rbd_img_request *img_req,
	2185	+ struct ceph_file_extent *img_extents,
	2186	+ u32 num_img_extents,
	2187	+ struct bio_vec *bvecs)
	2188	+{
	2189	+ struct ceph_bvec_iter it = {
	2190	+ .bvecs = bvecs,
	2191	+ .iter = { .bi_size = ceph_file_extents_bytes(img_extents,
	2192	+ num_img_extents) },
	2193	+ };
2712	2194
2713		− /*
2714		− * If the overlap has become 0 (most likely because the
2715		− * image has been flattened) we need to re-submit the
2716		− * original request.
2717		− */
2718		− rbd_dev = orig_request->img_request->rbd_dev;
2719		− if (!rbd_dev->parent_overlap) {
2720		− rbd_obj_request_submit(orig_request);
2721		− return;
2722		− }
	2195	+ return __rbd_img_fill_from_bvecs(img_req, img_extents, num_img_extents,
	2196	+ &it);
	2197	+}
2723	2198
2724		− /*
2725		− * Our only purpose here is to determine whether the object
2726		− * exists, and we don't want to treat the non-existence as
2727		− * an error. If something else comes back, transfer the
2728		− * error to the original request and complete it now.
2729		− */
2730		− if (!result) {
2731		− obj_request_existence_set(orig_request, true);
2732		− } else if (result == -ENOENT) {
2733		− obj_request_existence_set(orig_request, false);
2734		− } else {
2735		− goto fail_orig_request;
2736		− }
	2199	+static void rbd_img_request_submit(struct rbd_img_request *img_request)
	2200	+{
	2201	+ struct rbd_obj_request *obj_request;
2737	2202
2738		− /*
2739		− * Resubmit the original request now that we have recorded
2740		− * whether the target object exists.
2741		− */
2742		− result = rbd_img_obj_request_submit(orig_request);
2743		− if (result)
2744		− goto fail_orig_request;
	2203	+ dout("%s: img %p\n", __func__, img_request);
2745	2204
2746		− return;
	2205	+ rbd_img_request_get(img_request);
	2206	+ for_each_obj_request(img_request, obj_request)
	2207	+ rbd_obj_request_submit(obj_request);
2747	2208
2748		−fail_orig_request:
2749		− rbd_obj_request_error(orig_request, result);
	2209	+ rbd_img_request_put(img_request);
2750	2210	}
2751	2211
2752		−static int rbd_img_obj_exists_submit(struct rbd_obj_request *obj_request)
	2212	+static int rbd_obj_read_from_parent(struct rbd_obj_request *obj_req)
2753	2213	{
2754		− struct rbd_device *rbd_dev = obj_request->img_request->rbd_dev;
2755		− struct rbd_obj_request *stat_request;
2756		− struct page **pages;
2757		− u32 page_count;
2758		− size_t size;
	2214	+ struct rbd_img_request *img_req = obj_req->img_request;
	2215	+ struct rbd_img_request *child_img_req;
2759	2216	int ret;
2760	2217
2761		− stat_request = rbd_obj_request_create(OBJ_REQUEST_PAGES);
2762		− if (!stat_request)
	2218	+ child_img_req = rbd_img_request_create(img_req->rbd_dev->parent,
	2219	+ OBJ_OP_READ, NULL);
	2220	+ if (!child_img_req)
2763	2221	return -ENOMEM;
2764	2222
2765		− stat_request->object_no = obj_request->object_no;
	2223	+ __set_bit(IMG_REQ_CHILD, &child_img_req->flags);
	2224	+ child_img_req->obj_request = obj_req;
2766	2225
2767		− stat_request->osd_req = rbd_osd_req_create(rbd_dev, OBJ_OP_READ, 1,
2768		− stat_request);
2769		− if (!stat_request->osd_req) {
2770		− ret = -ENOMEM;
2771		− goto fail_stat_request;
	2226	+ if (!rbd_img_is_write(img_req)) {
	2227	+ switch (img_req->data_type) {
	2228	+ case OBJ_REQUEST_BIO:
	2229	+ ret = __rbd_img_fill_from_bio(child_img_req,
	2230	+ obj_req->img_extents,
	2231	+ obj_req->num_img_extents,
	2232	+ &obj_req->bio_pos);
	2233	+ break;
	2234	+ case OBJ_REQUEST_BVECS:
	2235	+ case OBJ_REQUEST_OWN_BVECS:
	2236	+ ret = __rbd_img_fill_from_bvecs(child_img_req,
	2237	+ obj_req->img_extents,
	2238	+ obj_req->num_img_extents,
	2239	+ &obj_req->bvec_pos);
	2240	+ break;
	2241	+ default:
	2242	+ rbd_assert(0);
	2243	+ }
	2244	+ } else {
	2245	+ ret = rbd_img_fill_from_bvecs(child_img_req,
	2246	+ obj_req->img_extents,
	2247	+ obj_req->num_img_extents,
	2248	+ obj_req->copyup_bvecs);
	2249	+ }
	2250	+ if (ret) {
	2251	+ rbd_img_request_put(child_img_req);
	2252	+ return ret;
	2253	+ }
	2254	+
	2255	+ rbd_img_request_submit(child_img_req);
	2256	+ return 0;
	2257	+}
	2258	+
	2259	+static bool rbd_obj_handle_read(struct rbd_obj_request *obj_req)
	2260	+{
	2261	+ struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
	2262	+ int ret;
	2263	+
	2264	+ if (obj_req->result == -ENOENT &&
	2265	+ rbd_dev->parent_overlap && !obj_req->tried_parent) {
	2266	+ /* reverse map this object extent onto the parent */
	2267	+ ret = rbd_obj_calc_img_extents(obj_req, false);
	2268	+ if (ret) {
	2269	+ obj_req->result = ret;
	2270	+ return true;
	2271	+ }
	2272	+
	2273	+ if (obj_req->num_img_extents) {
	2274	+ obj_req->tried_parent = true;
	2275	+ ret = rbd_obj_read_from_parent(obj_req);
	2276	+ if (ret) {
	2277	+ obj_req->result = ret;
	2278	+ return true;
	2279	+ }
	2280	+ return false;
	2281	+ }
2772	2282	}
2773	2283
2774	2284	/*
2775		− * The response data for a STAT call consists of:
2776		− * le64 length;
2777		− * struct {
2778		− * le32 tv_sec;
2779		− * le32 tv_nsec;
2780		− * } mtime;
	2285	+ * -ENOENT means a hole in the image -- zero-fill the entire
	2286	+ * length of the request. A short read also implies zero-fill
	2287	+ * to the end of the request. In both cases we update xferred
	2288	+ * count to indicate the whole request was satisfied.
2781	2289	*/
2782		− size = sizeof (__le64) + sizeof (__le32) + sizeof (__le32);
2783		− page_count = (u32)calc_pages_for(0, size);
2784		− pages = ceph_alloc_page_vector(page_count, GFP_NOIO);
2785		− if (IS_ERR(pages)) {
2786		− ret = PTR_ERR(pages);
2787		− goto fail_stat_request;
	2290	+ if (obj_req->result == -ENOENT \|\|
	2291	+ (!obj_req->result && obj_req->xferred < obj_req->ex.oe_len)) {
	2292	+ rbd_assert(!obj_req->xferred \|\| !obj_req->result);
	2293	+ rbd_obj_zero_range(obj_req, obj_req->xferred,
	2294	+ obj_req->ex.oe_len - obj_req->xferred);
	2295	+ obj_req->result = 0;
	2296	+ obj_req->xferred = obj_req->ex.oe_len;
2788	2297	}
2789	2298
2790		− osd_req_op_init(stat_request->osd_req, 0, CEPH_OSD_OP_STAT, 0);
2791		− osd_req_op_raw_data_in_pages(stat_request->osd_req, 0, pages, size, 0,
2792		− false, false);
2793		−
2794		− rbd_obj_request_get(obj_request);
2795		− stat_request->obj_request = obj_request;
2796		− stat_request->pages = pages;
2797		− stat_request->page_count = page_count;
2798		− stat_request->callback = rbd_img_obj_exists_callback;
	2299	+ return true;
	2300	+}
2799	2301
2800		− rbd_obj_request_submit(stat_request);
2801		− return 0;
	2302	+/*
	2303	+ * copyup_bvecs pages are never highmem pages
	2304	+ */
	2305	+static bool is_zero_bvecs(struct bio_vec *bvecs, u32 bytes)
	2306	+{
	2307	+ struct ceph_bvec_iter it = {
	2308	+ .bvecs = bvecs,
	2309	+ .iter = { .bi_size = bytes },
	2310	+ };
2802	2311
2803		−fail_stat_request:
2804		− rbd_obj_request_put(stat_request);
2805		− return ret;
	2312	+ ceph_bvec_iter_advance_step(&it, bytes, ({
	2313	+ if (memchr_inv(page_address(bv.bv_page) + bv.bv_offset, 0,
	2314	+ bv.bv_len))
	2315	+ return false;
	2316	+ }));
	2317	+ return true;
2806	2318	}
2807	2319
2808		−static bool img_obj_request_simple(struct rbd_obj_request *obj_request)
	2320	+static int rbd_obj_issue_copyup(struct rbd_obj_request *obj_req, u32 bytes)
2809	2321	{
2810		− struct rbd_img_request *img_request = obj_request->img_request;
2811		− struct rbd_device *rbd_dev = img_request->rbd_dev;
2812		−
2813		− /* Reads */
2814		− if (!img_request_write_test(img_request) &&
2815		− !img_request_discard_test(img_request))
2816		− return true;
	2322	+ unsigned int num_osd_ops = obj_req->osd_req->r_num_ops;
2817	2323
2818		− /* Non-layered writes */
2819		− if (!img_request_layered_test(img_request))
2820		− return true;
	2324	+ dout("%s obj_req %p bytes %u\n", __func__, obj_req, bytes);
	2325	+ rbd_assert(obj_req->osd_req->r_ops[0].op == CEPH_OSD_OP_STAT);
	2326	+ rbd_osd_req_destroy(obj_req->osd_req);
2821	2327
2822	2328	/*
2823		− * Layered writes outside of the parent overlap range don't
2824		− * share any data with the parent.
	2329	+ * Create a copyup request with the same number of OSD ops as
	2330	+ * the original request. The original request was stat + op(s),
	2331	+ * the new copyup request will be copyup + the same op(s).
2825	2332	*/
2826		− if (!obj_request_overlaps_parent(obj_request))
2827		− return true;
	2333	+ obj_req->osd_req = rbd_osd_req_create(obj_req, num_osd_ops);
	2334	+ if (!obj_req->osd_req)
	2335	+ return -ENOMEM;
2828	2336
2829	2337	/*
2830		− * Entire-object layered writes - we will overwrite whatever
2831		− * parent data there is anyway.
	2338	+ * Only send non-zero copyup data to save some I/O and network
	2339	+ * bandwidth -- zero copyup data is equivalent to the object not
	2340	+ * existing.
2832	2341	*/
2833		− if (!obj_request->offset &&
2834		− obj_request->length == rbd_obj_bytes(&rbd_dev->header))
2835		− return true;
	2342	+ if (is_zero_bvecs(obj_req->copyup_bvecs, bytes)) {
	2343	+ dout("%s obj_req %p detected zeroes\n", __func__, obj_req);
	2344	+ bytes = 0;
	2345	+ }
2836	2346
2837		− /*
2838		− * If the object is known to already exist, its parent data has
2839		− * already been copied.
2840		− */
2841		− if (obj_request_known_test(obj_request) &&
2842		− obj_request_exists_test(obj_request))
2843		− return true;
	2347	+ osd_req_op_cls_init(obj_req->osd_req, 0, CEPH_OSD_OP_CALL, "rbd",
	2348	+ "copyup");
	2349	+ osd_req_op_cls_request_data_bvecs(obj_req->osd_req, 0,
	2350	+ obj_req->copyup_bvecs, bytes);
	2351	+
	2352	+ switch (obj_req->img_request->op_type) {
	2353	+ case OBJ_OP_WRITE:
	2354	+ __rbd_obj_setup_write(obj_req, 1);
	2355	+ break;
	2356	+ case OBJ_OP_DISCARD:
	2357	+ rbd_assert(!rbd_obj_is_entire(obj_req));
	2358	+ __rbd_obj_setup_discard(obj_req, 1);
	2359	+ break;
	2360	+ default:
	2361	+ rbd_assert(0);
	2362	+ }
2844	2363
2845		− return false;
	2364	+ rbd_obj_request_submit(obj_req);
	2365	+ return 0;
2846	2366	}
2847	2367
2848		−static int rbd_img_obj_request_submit(struct rbd_obj_request *obj_request)
	2368	+static int setup_copyup_bvecs(struct rbd_obj_request *obj_req, u64 obj_overlap)
2849	2369	{
2850		− rbd_assert(obj_request_img_data_test(obj_request));
2851		− rbd_assert(obj_request_type_valid(obj_request->type));
2852		− rbd_assert(obj_request->img_request);
	2370	+ u32 i;
2853	2371
2854		− if (img_obj_request_simple(obj_request)) {
2855		− rbd_obj_request_submit(obj_request);
2856		− return 0;
2857		− }
	2372	+ rbd_assert(!obj_req->copyup_bvecs);
	2373	+ obj_req->copyup_bvec_count = calc_pages_for(0, obj_overlap);
	2374	+ obj_req->copyup_bvecs = kcalloc(obj_req->copyup_bvec_count,
	2375	+ sizeof(*obj_req->copyup_bvecs),
	2376	+ GFP_NOIO);
	2377	+ if (!obj_req->copyup_bvecs)
	2378	+ return -ENOMEM;
2858	2379
2859		− /*
2860		− * It's a layered write. The target object might exist but
2861		− * we may not know that yet. If we know it doesn't exist,
2862		− * start by reading the data for the full target object from
2863		− * the parent so we can use it for a copyup to the target.
2864		− */
2865		− if (obj_request_known_test(obj_request))
2866		− return rbd_img_obj_parent_read_full(obj_request);
	2380	+ for (i = 0; i < obj_req->copyup_bvec_count; i++) {
	2381	+ unsigned int len = min(obj_overlap, (u64)PAGE_SIZE);
	2382	+
	2383	+ obj_req->copyup_bvecs[i].bv_page = alloc_page(GFP_NOIO);
	2384	+ if (!obj_req->copyup_bvecs[i].bv_page)
	2385	+ return -ENOMEM;
2867	2386
2868		− /* We don't know whether the target exists. Go find out. */
	2387	+ obj_req->copyup_bvecs[i].bv_offset = 0;
	2388	+ obj_req->copyup_bvecs[i].bv_len = len;
	2389	+ obj_overlap -= len;
	2390	+ }
2869	2391
2870		− return rbd_img_obj_exists_submit(obj_request);
	2392	+ rbd_assert(!obj_overlap);
	2393	+ return 0;
2871	2394	}
2872	2395
2873		−static int rbd_img_request_submit(struct rbd_img_request *img_request)
	2396	+static int rbd_obj_handle_write_guard(struct rbd_obj_request *obj_req)
2874	2397	{
2875		− struct rbd_obj_request *obj_request;
2876		− struct rbd_obj_request *next_obj_request;
2877		− int ret = 0;
2878		−
2879		− dout("%s: img %p\n", __func__, img_request);
	2398	+ struct rbd_device *rbd_dev = obj_req->img_request->rbd_dev;
	2399	+ int ret;
2880	2400
2881		− rbd_img_request_get(img_request);
2882		− for_each_obj_request_safe(img_request, obj_request, next_obj_request) {
2883		− ret = rbd_img_obj_request_submit(obj_request);
2884		− if (ret)
2885		− goto out_put_ireq;
	2401	+ rbd_assert(obj_req->num_img_extents);
	2402	+ prune_extents(obj_req->img_extents, &obj_req->num_img_extents,
	2403	+ rbd_dev->parent_overlap);
	2404	+ if (!obj_req->num_img_extents) {
	2405	+ /*
	2406	+ * The overlap has become 0 (most likely because the
	2407	+ * image has been flattened). Use rbd_obj_issue_copyup()
	2408	+ * to re-submit the original write request -- the copyup
	2409	+ * operation itself will be a no-op, since someone must
	2410	+ * have populated the child object while we weren't
	2411	+ * looking. Move to WRITE_FLAT state as we'll be done
	2412	+ * with the operation once the null copyup completes.
	2413	+ */
	2414	+ obj_req->write_state = RBD_OBJ_WRITE_FLAT;
	2415	+ return rbd_obj_issue_copyup(obj_req, 0);
2886	2416	}
2887	2417
2888		−out_put_ireq:
2889		− rbd_img_request_put(img_request);
2890		− return ret;
	2418	+ ret = setup_copyup_bvecs(obj_req, rbd_obj_img_extents_bytes(obj_req));
	2419	+ if (ret)
	2420	+ return ret;
	2421	+
	2422	+ obj_req->write_state = RBD_OBJ_WRITE_COPYUP;
	2423	+ return rbd_obj_read_from_parent(obj_req);
2891	2424	}
2892	2425
2893		−static void rbd_img_parent_read_callback(struct rbd_img_request *img_request)
	2426	+static bool rbd_obj_handle_write(struct rbd_obj_request *obj_req)
2894	2427	{
2895		− struct rbd_obj_request *obj_request;
2896		− struct rbd_device *rbd_dev;
2897		− u64 obj_end;
2898		− u64 img_xferred;
2899		− int img_result;
	2428	+ int ret;
2900	2429
2901		− rbd_assert(img_request_child_test(img_request));
	2430	+again:
	2431	+ switch (obj_req->write_state) {
	2432	+ case RBD_OBJ_WRITE_GUARD:
	2433	+ rbd_assert(!obj_req->xferred);
	2434	+ if (obj_req->result == -ENOENT) {
	2435	+ /*
	2436	+ * The target object doesn't exist. Read the data for
	2437	+ * the entire target object up to the overlap point (if
	2438	+ * any) from the parent, so we can use it for a copyup.
	2439	+ */
	2440	+ ret = rbd_obj_handle_write_guard(obj_req);
	2441	+ if (ret) {
	2442	+ obj_req->result = ret;
	2443	+ return true;
	2444	+ }
	2445	+ return false;
	2446	+ }
	2447	+ /* fall through */
	2448	+ case RBD_OBJ_WRITE_FLAT:
	2449	+ if (!obj_req->result)
	2450	+ /*
	2451	+ * There is no such thing as a successful short
	2452	+ * write -- indicate the whole request was satisfied.
	2453	+ */
	2454	+ obj_req->xferred = obj_req->ex.oe_len;
	2455	+ return true;
	2456	+ case RBD_OBJ_WRITE_COPYUP:
	2457	+ obj_req->write_state = RBD_OBJ_WRITE_GUARD;
	2458	+ if (obj_req->result)
	2459	+ goto again;
2902	2460
2903		− /* First get what we need from the image request and release it */
	2461	+ rbd_assert(obj_req->xferred);
	2462	+ ret = rbd_obj_issue_copyup(obj_req, obj_req->xferred);
	2463	+ if (ret) {
	2464	+ obj_req->result = ret;
	2465	+ return true;
	2466	+ }
	2467	+ return false;
	2468	+ default:
	2469	+ rbd_assert(0);
	2470	+ }
	2471	+}
2904	2472
2905		− obj_request = img_request->obj_request;
2906		− img_xferred = img_request->xferred;
2907		− img_result = img_request->result;
2908		− rbd_img_request_put(img_request);
	2473	+/*
	2474	+ * Returns true if @obj_req is completed, or false otherwise.
	2475	+ */
	2476	+static bool __rbd_obj_handle_request(struct rbd_obj_request *obj_req)
	2477	+{
	2478	+ switch (obj_req->img_request->op_type) {
	2479	+ case OBJ_OP_READ:
	2480	+ return rbd_obj_handle_read(obj_req);
	2481	+ case OBJ_OP_WRITE:
	2482	+ return rbd_obj_handle_write(obj_req);
	2483	+ case OBJ_OP_DISCARD:
	2484	+ if (rbd_obj_handle_write(obj_req)) {
	2485	+ /*
	2486	+ * Hide -ENOENT from delete/truncate/zero -- discarding
	2487	+ * a non-existent object is not a problem.
	2488	+ */
	2489	+ if (obj_req->result == -ENOENT) {
	2490	+ obj_req->result = 0;
	2491	+ obj_req->xferred = obj_req->ex.oe_len;
	2492	+ }
	2493	+ return true;
	2494	+ }
	2495	+ return false;
	2496	+ default:
	2497	+ rbd_assert(0);
	2498	+ }
	2499	+}
2909	2500
2910		− /*
2911		− * If the overlap has become 0 (most likely because the
2912		− * image has been flattened) we need to re-submit the
2913		− * original request.
2914		− */
2915		− rbd_assert(obj_request);
2916		− rbd_assert(obj_request->img_request);
2917		− rbd_dev = obj_request->img_request->rbd_dev;
2918		− if (!rbd_dev->parent_overlap) {
2919		− rbd_obj_request_submit(obj_request);
	2501	+static void rbd_obj_end_request(struct rbd_obj_request *obj_req)
	2502	+{
	2503	+ struct rbd_img_request *img_req = obj_req->img_request;
	2504	+
	2505	+ rbd_assert((!obj_req->result &&
	2506	+ obj_req->xferred == obj_req->ex.oe_len) \|\|
	2507	+ (obj_req->result < 0 && !obj_req->xferred));
	2508	+ if (!obj_req->result) {
	2509	+ img_req->xferred += obj_req->xferred;
2920	2510	return;
2921	2511	}
2922	2512
2923		− obj_request->result = img_result;
2924		− if (obj_request->result)
2925		− goto out;
	2513	+ rbd_warn(img_req->rbd_dev,
	2514	+ "%s at objno %llu %llu~%llu result %d xferred %llu",
	2515	+ obj_op_name(img_req->op_type), obj_req->ex.oe_objno,
	2516	+ obj_req->ex.oe_off, obj_req->ex.oe_len, obj_req->result,
	2517	+ obj_req->xferred);
	2518	+ if (!img_req->result) {
	2519	+ img_req->result = obj_req->result;
	2520	+ img_req->xferred = 0;
	2521	+ }
	2522	+}
2926	2523
2927		− /*
2928		− * We need to zero anything beyond the parent overlap
2929		− * boundary. Since rbd_img_obj_request_read_callback()
2930		− * will zero anything beyond the end of a short read, an
2931		− * easy way to do this is to pretend the data from the
2932		− * parent came up short--ending at the overlap boundary.
2933		− */
2934		− rbd_assert(obj_request->img_offset < U64_MAX - obj_request->length);
2935		− obj_end = obj_request->img_offset + obj_request->length;
2936		− if (obj_end > rbd_dev->parent_overlap) {
2937		− u64 xferred = 0;
	2524	+static void rbd_img_end_child_request(struct rbd_img_request *img_req)
	2525	+{
	2526	+ struct rbd_obj_request *obj_req = img_req->obj_request;
2938	2527
2939		− if (obj_request->img_offset < rbd_dev->parent_overlap)
2940		− xferred = rbd_dev->parent_overlap -
2941		− obj_request->img_offset;
	2528	+ rbd_assert(test_bit(IMG_REQ_CHILD, &img_req->flags));
	2529	+ rbd_assert((!img_req->result &&
	2530	+ img_req->xferred == rbd_obj_img_extents_bytes(obj_req)) \|\|
	2531	+ (img_req->result < 0 && !img_req->xferred));
2942	2532
2943		− obj_request->xferred = min(img_xferred, xferred);
2944		− } else {
2945		− obj_request->xferred = img_xferred;
2946		− }
2947		−out:
2948		− rbd_img_obj_request_read_callback(obj_request);
2949		− rbd_obj_request_complete(obj_request);
	2533	+ obj_req->result = img_req->result;
	2534	+ obj_req->xferred = img_req->xferred;
	2535	+ rbd_img_request_put(img_req);
2950	2536	}
2951	2537
2952		−static void rbd_img_parent_read(struct rbd_obj_request *obj_request)
	2538	+static void rbd_img_end_request(struct rbd_img_request *img_req)
2953	2539	{
2954		− struct rbd_img_request *img_request;
2955		− int result;
	2540	+ rbd_assert(!test_bit(IMG_REQ_CHILD, &img_req->flags));
	2541	+ rbd_assert((!img_req->result &&
	2542	+ img_req->xferred == blk_rq_bytes(img_req->rq)) \|\|
	2543	+ (img_req->result < 0 && !img_req->xferred));
2956	2544
2957		− rbd_assert(obj_request_img_data_test(obj_request));
2958		− rbd_assert(obj_request->img_request != NULL);
2959		− rbd_assert(obj_request->result == (s32) -ENOENT);
2960		− rbd_assert(obj_request_type_valid(obj_request->type));
	2545	+ blk_mq_end_request(img_req->rq,
	2546	+ errno_to_blk_status(img_req->result));
	2547	+ rbd_img_request_put(img_req);
	2548	+}
2961	2549
2962		− /* rbd_read_finish(obj_request, obj_request->length); */
2963		− img_request = rbd_parent_request_create(obj_request,
2964		− obj_request->img_offset,
2965		− obj_request->length);
2966		− result = -ENOMEM;
2967		− if (!img_request)
2968		− goto out_err;
	2550	+static void rbd_obj_handle_request(struct rbd_obj_request *obj_req)
	2551	+{
	2552	+ struct rbd_img_request *img_req;
2969	2553
2970		− if (obj_request->type == OBJ_REQUEST_BIO)
2971		− result = rbd_img_request_fill(img_request, OBJ_REQUEST_BIO,
2972		− obj_request->bio_list);
2973		− else
2974		− result = rbd_img_request_fill(img_request, OBJ_REQUEST_PAGES,
2975		− obj_request->pages);
2976		− if (result)
2977		− goto out_err;
	2554	+again:
	2555	+ if (!__rbd_obj_handle_request(obj_req))
	2556	+ return;
2978	2557
2979		− img_request->callback = rbd_img_parent_read_callback;
2980		− result = rbd_img_request_submit(img_request);
2981		− if (result)
2982		− goto out_err;
	2558	+ img_req = obj_req->img_request;
	2559	+ spin_lock(&img_req->completion_lock);
	2560	+ rbd_obj_end_request(obj_req);
	2561	+ rbd_assert(img_req->pending_count);
	2562	+ if (--img_req->pending_count) {
	2563	+ spin_unlock(&img_req->completion_lock);
	2564	+ return;
	2565	+ }
2983	2566
2984		− return;
2985		−out_err:
2986		− if (img_request)
2987		− rbd_img_request_put(img_request);
2988		− obj_request->result = result;
2989		− obj_request->xferred = 0;
2990		− obj_request_done_set(obj_request);
	2567	+ spin_unlock(&img_req->completion_lock);
	2568	+ if (test_bit(IMG_REQ_CHILD, &img_req->flags)) {
	2569	+ obj_req = img_req->obj_request;
	2570	+ rbd_img_end_child_request(img_req);
	2571	+ goto again;
	2572	+ }
	2573	+ rbd_img_end_request(img_req);
2991	2574	}
2992	2575
2993	2576	static const struct rbd_client_id rbd_empty_cid;
@@ -3091,8 +2674,8 @@ static int __rbd_notify_op_lock(struct rbd_device *rbd_dev, · 97 unmodified lines
3091	2674	{
3092	2675	struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
3093	2676	struct rbd_client_id cid = rbd_get_cid(rbd_dev);
3094		− int buf_size = 4 + 8 + 8 + CEPH_ENCODING_START_BLK_LEN;
3095		− char buf[buf_size];
	2677	+ char buf[4 + 8 + 8 + CEPH_ENCODING_START_BLK_LEN];
	2678	+ int buf_size = sizeof(buf);
3096	2679	void *p = buf;
3097	2680
3098	2681	dout("%s rbd_dev %p notify_op %d\n", __func__, rbd_dev, notify_op);
@@ -3610,8 +3193,8 @@ static void __rbd_acknowledge_notify(struct rbd_device *rbd_dev, · 511 unmodified lines
3610	3193	u64 notify_id, u64 cookie, s32 *result)
3611	3194	{
3612	3195	struct ceph_osd_client *osdc = &rbd_dev->rbd_client->client->osdc;
3613		− int buf_size = 4 + CEPH_ENCODING_START_BLK_LEN;
3614		− char buf[buf_size];
	3196	+ char buf[4 + CEPH_ENCODING_START_BLK_LEN];
	3197	+ int buf_size = sizeof(buf);
3615	3198	int ret;
3616	3199
3617	3200	if (result) {
@@ -3887,7 +3470,7 @@ static void rbd_reregister_watch(struct work_struct *work) · 269 unmodified lines
3887	3470
3888	3471	ret = rbd_dev_refresh(rbd_dev);
3889	3472	if (ret)
3890		− rbd_warn(rbd_dev, "reregisteration refresh failed: %d", ret);
	3473	+ rbd_warn(rbd_dev, "reregistration refresh failed: %d", ret);
3891	3474	}
3892	3475
3893	3476	/*
@@ -4070,8 +3653,7 @@ static void rbd_queue_workfn(struct work_struct *work) · 176 unmodified lines
4070	3653	}
4071	3654	}
4072	3655
4073		− img_request = rbd_img_request_create(rbd_dev, offset, length, op_type,
4074		− snapc);
	3656	+ img_request = rbd_img_request_create(rbd_dev, op_type, snapc);
4075	3657	if (!img_request) {
4076	3658	result = -ENOMEM;
4077	3659	goto err_unlock;
@@ -4080,18 +3662,14 @@ static void rbd_queue_workfn(struct work_struct *work) · 2 unmodified lines
4080	3662	snapc = NULL; /* img_request consumes a ref */
4081	3663
4082	3664	if (op_type == OBJ_OP_DISCARD)
4083		− result = rbd_img_request_fill(img_request, OBJ_REQUEST_NODATA,
4084		− NULL);
	3665	+ result = rbd_img_fill_nodata(img_request, offset, length);
4085	3666	else
4086		− result = rbd_img_request_fill(img_request, OBJ_REQUEST_BIO,
4087		− rq->bio);
4088		− if (result)
4089		− goto err_img_request;
4090		−
4091		− result = rbd_img_request_submit(img_request);
	3667	+ result = rbd_img_fill_from_bio(img_request, offset, length,
	3668	+ rq->bio);
4092	3669	if (result)
4093	3670	goto err_img_request;
4094	3671
	3672	+ rbd_img_request_submit(img_request);
4095	3673	if (must_be_locked)
4096	3674	up_read(&rbd_dev->lock_rwsem);
4097	3675	return;
@@ -4369,7 +3947,7 @@ static int rbd_init_disk(struct rbd_device *rbd_dev) · 271 unmodified lines
4369	3947	blk_queue_max_hw_sectors(q, segment_size / SECTOR_SIZE);
4370	3948	q->limits.max_sectors = queue_max_hw_sectors(q);
4371	3949	blk_queue_max_segments(q, USHRT_MAX);
4372		− blk_queue_max_segment_size(q, segment_size);
	3950	+ blk_queue_max_segment_size(q, UINT_MAX);
4373	3951	blk_queue_io_min(q, segment_size);
4374	3952	blk_queue_io_opt(q, segment_size);
4375	3953
@@ -5057,9 +4635,6 @@ static int rbd_dev_v2_striping_info(struct rbd_device *rbd_dev) · 681 unmodified lines
5057	4635	} __attribute__ ((packed)) striping_info_buf = { 0 };
5058	4636	size_t size = sizeof (striping_info_buf);
5059	4637	void *p;
5060		− u64 obj_size;
5061		− u64 stripe_unit;
5062		− u64 stripe_count;
5063	4638	int ret;
5064	4639
5065	4640	ret = rbd_obj_method_sync(rbd_dev, &rbd_dev->header_oid,
@@ -5071,31 +4646,9 @@ static int rbd_dev_v2_striping_info(struct rbd_device *rbd_dev) · 5 unmodified lines
5071	4646	if (ret < size)
5072	4647	return -ERANGE;
5073	4648
5074		− /*
5075		− * We don't actually support the "fancy striping" feature
5076		− * (STRIPINGV2) yet, but if the striping sizes are the
5077		− * defaults the behavior is the same as before. So find
5078		− * out, and only fail if the image has non-default values.
5079		− */
5080		− ret = -EINVAL;
5081		− obj_size = rbd_obj_bytes(&rbd_dev->header);
5082	4649	p = &striping_info_buf;
5083		− stripe_unit = ceph_decode_64(&p);
5084		− if (stripe_unit != obj_size) {
5085		− rbd_warn(rbd_dev, "unsupported stripe unit "
5086		− "(got %llu want %llu)",
5087		− stripe_unit, obj_size);
5088		− return -EINVAL;
5089		− }
5090		− stripe_count = ceph_decode_64(&p);
5091		− if (stripe_count != 1) {
5092		− rbd_warn(rbd_dev, "unsupported stripe count "
5093		− "(got %llu want 1)", stripe_count);
5094		− return -EINVAL;
5095		− }
5096		− rbd_dev->header.stripe_unit = stripe_unit;
5097		− rbd_dev->header.stripe_count = stripe_count;
5098		−
	4650	+ rbd_dev->header.stripe_unit = ceph_decode_64(&p);
	4651	+ rbd_dev->header.stripe_count = ceph_decode_64(&p);
5099	4652	return 0;
5100	4653	}
5101	4654
@@ -5653,39 +5206,6 @@ out_err: · 551 unmodified lines
5653	5206	return ret;
5654	5207	}
5655	5208
5656		−/*
5657		− * Return pool id (>= 0) or a negative error code.
5658		− */
5659		−static int rbd_add_get_pool_id(struct rbd_client rbdc, const char pool_name)
5660		−{
5661		− struct ceph_options *opts = rbdc->client->options;
5662		− u64 newest_epoch;
5663		− int tries = 0;
5664		− int ret;
5665		−
5666		−again:
5667		− ret = ceph_pg_poolid_by_name(rbdc->client->osdc.osdmap, pool_name);
5668		− if (ret == -ENOENT && tries++ < 1) {
5669		− ret = ceph_monc_get_version(&rbdc->client->monc, "osdmap",
5670		− &newest_epoch);
5671		− if (ret < 0)
5672		− return ret;
5673		−
5674		− if (rbdc->client->osdc.osdmap->epoch < newest_epoch) {
5675		− ceph_osdc_maybe_request_map(&rbdc->client->osdc);
5676		− (void) ceph_monc_wait_osdmap(&rbdc->client->monc,
5677		− newest_epoch,
5678		− opts->mount_timeout);
5679		− goto again;
5680		− } else {
5681		− /* the osdmap we have is new enough */
5682		− return -ENOENT;
5683		− }
5684		− }
5685		−
5686		− return ret;
5687		−}
5688		−
5689	5209	static void rbd_dev_image_unlock(struct rbd_device *rbd_dev)
5690	5210	{
5691	5211	down_write(&rbd_dev->lock_rwsem);
@@ -6114,7 +5634,7 @@ static ssize_t do_rbd_add(struct bus_type *bus, · 422 unmodified lines
6114	5634	}
6115	5635
6116	5636	/* pick the pool */
6117		− rc = rbd_add_get_pool_id(rbdc, spec->pool_name);
	5637	+ rc = ceph_pg_poolid_by_name(rbdc->client->osdc.osdmap, spec->pool_name);
6118	5638	if (rc < 0) {
6119	5639	if (rc == -ENOENT)
6120	5640	pr_info("pool %s does not exist\n", spec->pool_name);
@@ -6366,16 +5886,8 @@ static int rbd_slab_init(void) · 245 unmodified lines
6366	5886	if (!rbd_obj_request_cache)
6367	5887	goto out_err;
6368	5888
6369		− rbd_assert(!rbd_bio_clone);
6370		− rbd_bio_clone = bioset_create(BIO_POOL_SIZE, 0, 0);
6371		− if (!rbd_bio_clone)
6372		− goto out_err_clone;
6373		−
6374	5889	return 0;
6375	5890
6376		−out_err_clone:
6377		− kmem_cache_destroy(rbd_obj_request_cache);
6378		− rbd_obj_request_cache = NULL;
6379	5891	out_err:
6380	5892	kmem_cache_destroy(rbd_img_request_cache);
6381	5893	rbd_img_request_cache = NULL;
@@ -6391,10 +5903,6 @@ static void rbd_slab_exit(void) · 9 unmodified lines
6391	5903	rbd_assert(rbd_img_request_cache);
6392	5904	kmem_cache_destroy(rbd_img_request_cache);
6393	5905	rbd_img_request_cache = NULL;
6394		−
6395		− rbd_assert(rbd_bio_clone);
6396		− bioset_free(rbd_bio_clone);
6397		− rbd_bio_clone = NULL;
6398	5906	}
6399	5907
6400	5908	static int __init rbd_init(void)

fs/ceph/Makefile+1−1

@@ -6,7 +6,7 @@ · 5 unmodified lines
6	6	obj-$(CONFIG_CEPH_FS) += ceph.o
7	7
8	8	ceph-y := super.o inode.o dir.o file.o locks.o addr.o ioctl.o \
9		− export.o caps.o snap.o xattr.o \
	9	+ export.o caps.o snap.o xattr.o quota.o \
10	10	mds_client.o mdsmap.o strings.o ceph_frag.o \
11	11	debugfs.o
12	12

fs/ceph/addr.c+32−31

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	15	#include "mds_client.h"
16	16	#include "cache.h"
17	17	#include <linux/ceph/osd_client.h>
	18	+#include <linux/ceph/striper.h>
18	19
19	20	/*
20	21	* Ceph address space ops.
@@ -438,7 +439,7 @@ static int ceph_readpages(struct file file, struct address_space mapping, · 417 unmodified lines
438	439	{
439	440	struct inode *inode = file_inode(file);
440	441	struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
441		− struct ceph_file_info *ci = file->private_data;
	442	+ struct ceph_file_info *fi = file->private_data;
442	443	struct ceph_rw_context *rw_ctx;
443	444	int rc = 0;
444	445	int max = 0;
@@ -452,7 +453,7 @@ static int ceph_readpages(struct file file, struct address_space mapping, · 7 unmodified lines
452	453	if (rc == 0)
453	454	goto out;
454	455
455		− rw_ctx = ceph_find_rw_context(ci);
	456	+ rw_ctx = ceph_find_rw_context(fi);
456	457	max = fsc->mount_options->rsize >> PAGE_SHIFT;
457	458	dout("readpages %p file %p ctx %p nr_pages %d max %d\n",
458	459	inode, file, rw_ctx, nr_pages, max);
@@ -800,7 +801,7 @@ static int ceph_writepages_start(struct address_space *mapping, · 341 unmodified lines
800	801	struct ceph_osd_request *req = NULL;
801	802	struct ceph_writeback_ctl ceph_wbc;
802	803	bool should_loop, range_whole = false;
803		− bool stop, done = false;
	804	+ bool done = false;
804	805
805	806	dout("writepages_start %p (mode=%s)\n", inode,
806	807	wbc->sync_mode == WB_SYNC_NONE ? "NONE" :
@@ -856,7 +857,7 @@ retry: · 49 unmodified lines
856	857	* in that range can be associated with newer snapc.
857	858	* They are not writeable until we write all dirty pages
858	859	* associated with 'snapc' get written */
859		− if (index > 0 \|\| wbc->sync_mode != WB_SYNC_NONE)
	860	+ if (index > 0)
860	861	should_loop = true;
861	862	dout(" non-head snapc, range whole\n");
862	863	}
@@ -864,8 +865,7 @@ retry: · 1 unmodified line
864	865	ceph_put_snap_context(last_snapc);
865	866	last_snapc = snapc;
866	867
867		− stop = false;
868		− while (!stop && index <= end) {
	868	+ while (!done && index <= end) {
869	869	int num_ops = 0, op_idx;
870	870	unsigned i, pvec_pages, max_pages, locked_pages = 0;
871	871	struct page pages = NULL, data_pages;
@@ -898,16 +898,30 @@ get_more_pages: · 26 unmodified lines
898	898	unlock_page(page);
899	899	continue;
900	900	}
901		− if (strip_unit_end && (page->index > strip_unit_end)) {
902		− dout("end of strip unit %p\n", page);
	901	+ /* only if matching snap context */
	902	+ pgsnapc = page_snap_context(page);
	903	+ if (pgsnapc != snapc) {
	904	+ dout("page snapc %p %lld != oldest %p %lld\n",
	905	+ pgsnapc, pgsnapc->seq, snapc, snapc->seq);
	906	+ if (!should_loop &&
	907	+ !ceph_wbc.head_snapc &&
	908	+ wbc->sync_mode != WB_SYNC_NONE)
	909	+ should_loop = true;
903	910	unlock_page(page);
904		− break;
	911	+ continue;
905	912	}
906	913	if (page_offset(page) >= ceph_wbc.i_size) {
907	914	dout("%p page eof %llu\n",
908	915	page, ceph_wbc.i_size);
909		− /* not done if range_cyclic */
910		− stop = true;
	916	+ if (ceph_wbc.size_stable \|\|
	917	+ page_offset(page) >= i_size_read(inode))
	918	+ mapping->a_ops->invalidatepage(page,
	919	+ 0, PAGE_SIZE);
	920	+ unlock_page(page);
	921	+ continue;
	922	+ }
	923	+ if (strip_unit_end && (page->index > strip_unit_end)) {
	924	+ dout("end of strip unit %p\n", page);
911	925	unlock_page(page);
912	926	break;
913	927	}
@@ -921,15 +935,6 @@ get_more_pages: · 7 unmodified lines
921	935	wait_on_page_writeback(page);
922	936	}
923	937
924		− /* only if matching snap context */
925		− pgsnapc = page_snap_context(page);
926		− if (pgsnapc != snapc) {
927		− dout("page snapc %p %lld != oldest %p %lld\n",
928		− pgsnapc, pgsnapc->seq, snapc, snapc->seq);
929		− unlock_page(page);
930		− continue;
931		− }
932		−
933	938	if (!clear_page_dirty_for_io(page)) {
934	939	dout("%p !clear_page_dirty_for_io\n", page);
935	940	unlock_page(page);
@@ -945,19 +950,15 @@ get_more_pages: · 9 unmodified lines
945	950	if (locked_pages == 0) {
946	951	u64 objnum;
947	952	u64 objoff;
	953	+ u32 xlen;
948	954
949	955	/* prepare async write request */
950	956	offset = (u64)page_offset(page);
951		− len = wsize;
952		−
953		− rc = ceph_calc_file_object_mapping(&ci->i_layout,
954		− offset, len,
955		− &objnum, &objoff,
956		− &len);
957		− if (rc < 0) {
958		− unlock_page(page);
959		− break;
960		− }
	957	+ ceph_calc_file_object_mapping(&ci->i_layout,
	958	+ offset, wsize,
	959	+ &objnum, &objoff,
	960	+ &xlen);
	961	+ len = xlen;
961	962
962	963	num_ops = 1;
963	964	strip_unit_end = page->index +
@@ -1146,7 +1147,7 @@ new_request: · 182 unmodified lines
1146	1147	* we tagged for writeback prior to entering this loop.
1147	1148	*/
1148	1149	if (wbc->nr_to_write <= 0 && wbc->sync_mode == WB_SYNC_NONE)
1149		− done = stop = true;
	1150	+ done = true;
1150	1151
1151	1152	release_pvec_pages:
1152	1153	dout("pagevec_release on %d pages (%p)\n", (int)pvec.nr,

fs/ceph/cache.c+2−2

@@ -51,7 +51,7 @@ static const struct fscache_cookie_def ceph_fscache_fsid_object_def = { · 50 unmodified lines
51	51	.type = FSCACHE_COOKIE_TYPE_INDEX,
52	52	};
53	53
54		−int ceph_fscache_register(void)
	54	+int __init ceph_fscache_register(void)
55	55	{
56	56	return fscache_register_netfs(&ceph_cache_netfs);
57	57	}
@@ -135,7 +135,7 @@ static enum fscache_checkaux ceph_fscache_inode_check_aux( · 77 unmodified lines
135	135	if (memcmp(data, &aux, sizeof(aux)) != 0)
136	136	return FSCACHE_CHECKAUX_OBSOLETE;
137	137
138		− dout("ceph inode 0x%p cached okay", ci);
	138	+ dout("ceph inode 0x%p cached okay\n", ci);
139	139	return FSCACHE_CHECKAUX_OKAY;
140	140	}
141	141

fs/ceph/caps.c+97−31

@@ -184,36 +184,54 @@ int ceph_reserve_caps(struct ceph_mds_client *mdsc, · 183 unmodified lines
184	184	mdsc->caps_avail_count);
185	185	spin_unlock(&mdsc->caps_list_lock);
186	186
187		− for (i = have; i < need; i++) {
188		−retry:
	187	+ for (i = have; i < need; ) {
189	188	cap = kmem_cache_alloc(ceph_cap_cachep, GFP_NOFS);
190		− if (!cap) {
191		− if (!trimmed) {
192		− for (j = 0; j < mdsc->max_sessions; j++) {
193		− s = __ceph_lookup_mds_session(mdsc, j);
194		− if (!s)
195		− continue;
196		− mutex_unlock(&mdsc->mutex);
	189	+ if (cap) {
	190	+ list_add(&cap->caps_item, &newcaps);
	191	+ alloc++;
	192	+ i++;
	193	+ continue;
	194	+ }
197	195
198		− mutex_lock(&s->s_mutex);
199		− max_caps = s->s_nr_caps - (need - i);
200		− ceph_trim_caps(mdsc, s, max_caps);
201		− mutex_unlock(&s->s_mutex);
	196	+ if (!trimmed) {
	197	+ for (j = 0; j < mdsc->max_sessions; j++) {
	198	+ s = __ceph_lookup_mds_session(mdsc, j);
	199	+ if (!s)
	200	+ continue;
	201	+ mutex_unlock(&mdsc->mutex);
202	202
203		− ceph_put_mds_session(s);
204		− mutex_lock(&mdsc->mutex);
205		− }
206		− trimmed = true;
207		− goto retry;
208		− } else {
209		− pr_warn("reserve caps ctx=%p ENOMEM "
210		− "need=%d got=%d\n",
211		− ctx, need, have + alloc);
212		− goto out_nomem;
	203	+ mutex_lock(&s->s_mutex);
	204	+ max_caps = s->s_nr_caps - (need - i);
	205	+ ceph_trim_caps(mdsc, s, max_caps);
	206	+ mutex_unlock(&s->s_mutex);
	207	+
	208	+ ceph_put_mds_session(s);
	209	+ mutex_lock(&mdsc->mutex);
213	210	}
	211	+ trimmed = true;
	212	+
	213	+ spin_lock(&mdsc->caps_list_lock);
	214	+ if (mdsc->caps_avail_count) {
	215	+ int more_have;
	216	+ if (mdsc->caps_avail_count >= need - i)
	217	+ more_have = need - i;
	218	+ else
	219	+ more_have = mdsc->caps_avail_count;
	220	+
	221	+ i += more_have;
	222	+ have += more_have;
	223	+ mdsc->caps_avail_count -= more_have;
	224	+ mdsc->caps_reserve_count += more_have;
	225	+
	226	+ }
	227	+ spin_unlock(&mdsc->caps_list_lock);
	228	+
	229	+ continue;
214	230	}
215		− list_add(&cap->caps_item, &newcaps);
216		− alloc++;
	231	+
	232	+ pr_warn("reserve caps ctx=%p ENOMEM need=%d got=%d\n",
	233	+ ctx, need, have + alloc);
	234	+ goto out_nomem;
217	235	}
218	236	BUG_ON(have + alloc != need);
219	237
@@ -234,16 +252,28 @@ retry: · 14 unmodified lines
234	252	return 0;
235	253
236	254	out_nomem:
	255	+
	256	+ spin_lock(&mdsc->caps_list_lock);
	257	+ mdsc->caps_avail_count += have;
	258	+ mdsc->caps_reserve_count -= have;
	259	+
237	260	while (!list_empty(&newcaps)) {
238	261	cap = list_first_entry(&newcaps,
239	262	struct ceph_cap, caps_item);
240	263	list_del(&cap->caps_item);
241		− kmem_cache_free(ceph_cap_cachep, cap);
	264	+
	265	+ /* Keep some preallocated caps around (ceph_min_count), to
	266	+ * avoid lots of free/alloc churn. */
	267	+ if (mdsc->caps_avail_count >=
	268	+ mdsc->caps_reserve_count + mdsc->caps_min_count) {
	269	+ kmem_cache_free(ceph_cap_cachep, cap);
	270	+ } else {
	271	+ mdsc->caps_avail_count++;
	272	+ mdsc->caps_total_count++;
	273	+ list_add(&cap->caps_item, &mdsc->caps_list);
	274	+ }
242	275	}
243	276
244		− spin_lock(&mdsc->caps_list_lock);
245		− mdsc->caps_avail_count += have;
246		− mdsc->caps_reserve_count -= have;
247	277	BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
248	278	mdsc->caps_reserve_count +
249	279	mdsc->caps_avail_count);
@@ -254,12 +284,26 @@ out_nomem: · 4 unmodified lines
254	284	int ceph_unreserve_caps(struct ceph_mds_client *mdsc,
255	285	struct ceph_cap_reservation *ctx)
256	286	{
	287	+ int i;
	288	+ struct ceph_cap *cap;
	289	+
257	290	dout("unreserve caps ctx=%p count=%d\n", ctx, ctx->count);
258	291	if (ctx->count) {
259	292	spin_lock(&mdsc->caps_list_lock);
260	293	BUG_ON(mdsc->caps_reserve_count < ctx->count);
261	294	mdsc->caps_reserve_count -= ctx->count;
262		− mdsc->caps_avail_count += ctx->count;
	295	+ if (mdsc->caps_avail_count >=
	296	+ mdsc->caps_reserve_count + mdsc->caps_min_count) {
	297	+ mdsc->caps_total_count -= ctx->count;
	298	+ for (i = 0; i < ctx->count; i++) {
	299	+ cap = list_first_entry(&mdsc->caps_list,
	300	+ struct ceph_cap, caps_item);
	301	+ list_del(&cap->caps_item);
	302	+ kmem_cache_free(ceph_cap_cachep, cap);
	303	+ }
	304	+ } else {
	305	+ mdsc->caps_avail_count += ctx->count;
	306	+ }
263	307	ctx->count = 0;
264	308	dout("unreserve caps %d = %d used + %d resv + %d avail\n",
265	309	mdsc->caps_total_count, mdsc->caps_use_count,
@@ -285,7 +329,23 @@ struct ceph_cap ceph_get_cap(struct ceph_mds_client mdsc, · 19 unmodified lines
285	329	mdsc->caps_use_count++;
286	330	mdsc->caps_total_count++;
287	331	spin_unlock(&mdsc->caps_list_lock);
	332	+ } else {
	333	+ spin_lock(&mdsc->caps_list_lock);
	334	+ if (mdsc->caps_avail_count) {
	335	+ BUG_ON(list_empty(&mdsc->caps_list));
	336	+
	337	+ mdsc->caps_avail_count--;
	338	+ mdsc->caps_use_count++;
	339	+ cap = list_first_entry(&mdsc->caps_list,
	340	+ struct ceph_cap, caps_item);
	341	+ list_del(&cap->caps_item);
	342	+
	343	+ BUG_ON(mdsc->caps_total_count != mdsc->caps_use_count +
	344	+ mdsc->caps_reserve_count + mdsc->caps_avail_count);
	345	+ }
	346	+ spin_unlock(&mdsc->caps_list_lock);
288	347	}
	348	+
289	349	return cap;
290	350	}
291	351
@@ -341,6 +401,8 @@ void ceph_reservation_status(struct ceph_fs_client *fsc, · 49 unmodified lines
341	401	{
342	402	struct ceph_mds_client *mdsc = fsc->mdsc;
343	403
	404	+ spin_lock(&mdsc->caps_list_lock);
	405	+
344	406	if (total)
345	407	*total = mdsc->caps_total_count;
346	408	if (avail)
@@ -351,6 +413,8 @@ void ceph_reservation_status(struct ceph_fs_client *fsc, · 4 unmodified lines
351	413	*reserved = mdsc->caps_reserve_count;
352	414	if (min)
353	415	*min = mdsc->caps_min_count;
	416	+
	417	+ spin_unlock(&mdsc->caps_list_lock);
354	418	}
355	419
356	420	/*
@@ -639,9 +703,11 @@ void ceph_add_cap(struct inode *inode, · 282 unmodified lines
639	703	}
640	704
641	705	spin_lock(&realm->inodes_with_caps_lock);
642		− ci->i_snap_realm = realm;
643	706	list_add(&ci->i_snap_realm_item,
644	707	&realm->inodes_with_caps);
	708	+ ci->i_snap_realm = realm;
	709	+ if (realm->ino == ci->i_vino.ino)
	710	+ realm->inode = inode;
645	711	spin_unlock(&realm->inodes_with_caps_lock);
646	712
647	713	if (oldrealm)

fs/ceph/debugfs.c+4−4

@@ -260,7 +260,7 @@ int ceph_fs_debugfs_init(struct ceph_fs_client *fsc) · 259 unmodified lines
260	260	goto out;
261	261
262	262	fsc->debugfs_mdsmap = debugfs_create_file("mdsmap",
263		− 0600,
	263	+ 0400,
264	264	fsc->client->debugfs_dir,
265	265	fsc,
266	266	&mdsmap_show_fops);
@@ -268,7 +268,7 @@ int ceph_fs_debugfs_init(struct ceph_fs_client *fsc) · 1 unmodified line
268	268	goto out;
269	269
270	270	fsc->debugfs_mds_sessions = debugfs_create_file("mds_sessions",
271		− 0600,
	271	+ 0400,
272	272	fsc->client->debugfs_dir,
273	273	fsc,
274	274	&mds_sessions_show_fops);
@@ -276,7 +276,7 @@ int ceph_fs_debugfs_init(struct ceph_fs_client *fsc) · 1 unmodified line
276	276	goto out;
277	277
278	278	fsc->debugfs_mdsc = debugfs_create_file("mdsc",
279		− 0600,
	279	+ 0400,
280	280	fsc->client->debugfs_dir,
281	281	fsc,
282	282	&mdsc_show_fops);
@@ -292,7 +292,7 @@ int ceph_fs_debugfs_init(struct ceph_fs_client *fsc) · 9 unmodified lines
292	292	goto out;
293	293
294	294	fsc->debugfs_dentry_lru = debugfs_create_file("dentry_lru",
295		− 0600,
	295	+ 0400,
296	296	fsc->client->debugfs_dir,
297	297	fsc,
298	298	&dentry_lru_show_fops);

fs/ceph/dir.c+112−92

@@ -101,18 +101,18 @@ static int fpos_cmp(loff_t l, loff_t r) · 100 unmodified lines
101	101	* regardless of what dir changes take place on the
102	102	* server.
103	103	*/
104		−static int note_last_dentry(struct ceph_file_info fi, const char name,
	104	+static int note_last_dentry(struct ceph_dir_file_info dfi, const char name,
105	105	int len, unsigned next_offset)
106	106	{
107	107	char *buf = kmalloc(len+1, GFP_KERNEL);
108	108	if (!buf)
109	109	return -ENOMEM;
110		− kfree(fi->last_name);
111		− fi->last_name = buf;
112		− memcpy(fi->last_name, name, len);
113		− fi->last_name[len] = 0;
114		− fi->next_offset = next_offset;
115		− dout("note_last_dentry '%s'\n", fi->last_name);
	110	+ kfree(dfi->last_name);
	111	+ dfi->last_name = buf;
	112	+ memcpy(dfi->last_name, name, len);
	113	+ dfi->last_name[len] = 0;
	114	+ dfi->next_offset = next_offset;
	115	+ dout("note_last_dentry '%s'\n", dfi->last_name);
116	116	return 0;
117	117	}
118	118
@@ -174,7 +174,7 @@ __dcache_find_get_entry(struct dentry *parent, u64 idx, · 55 unmodified lines
174	174	static int __dcache_readdir(struct file file, struct dir_context ctx,
175	175	int shared_gen)
176	176	{
177		− struct ceph_file_info *fi = file->private_data;
	177	+ struct ceph_dir_file_info *dfi = file->private_data;
178	178	struct dentry *parent = file->f_path.dentry;
179	179	struct inode *dir = d_inode(parent);
180	180	struct dentry dentry, last = NULL;
@@ -221,7 +221,7 @@ static int __dcache_readdir(struct file file, struct dir_context ctx, · 40 unmodified lines
221	221	bool emit_dentry = false;
222	222	dentry = __dcache_find_get_entry(parent, idx++, &cache_ctl);
223	223	if (!dentry) {
224		− fi->flags \|= CEPH_F_ATEND;
	224	+ dfi->file_info.flags \|= CEPH_F_ATEND;
225	225	err = 0;
226	226	break;
227	227	}
@@ -272,33 +272,33 @@ out: · 44 unmodified lines
272	272	if (last) {
273	273	int ret;
274	274	di = ceph_dentry(last);
275		− ret = note_last_dentry(fi, last->d_name.name, last->d_name.len,
	275	+ ret = note_last_dentry(dfi, last->d_name.name, last->d_name.len,
276	276	fpos_off(di->offset) + 1);
277	277	if (ret < 0)
278	278	err = ret;
279	279	dput(last);
280	280	/* last_name no longer match cache index */
281		− if (fi->readdir_cache_idx >= 0) {
282		− fi->readdir_cache_idx = -1;
283		− fi->dir_release_count = 0;
	281	+ if (dfi->readdir_cache_idx >= 0) {
	282	+ dfi->readdir_cache_idx = -1;
	283	+ dfi->dir_release_count = 0;
284	284	}
285	285	}
286	286	return err;
287	287	}
288	288
289		−static bool need_send_readdir(struct ceph_file_info *fi, loff_t pos)
	289	+static bool need_send_readdir(struct ceph_dir_file_info *dfi, loff_t pos)
290	290	{
291		− if (!fi->last_readdir)
	291	+ if (!dfi->last_readdir)
292	292	return true;
293	293	if (is_hash_order(pos))
294		− return !ceph_frag_contains_value(fi->frag, fpos_hash(pos));
	294	+ return !ceph_frag_contains_value(dfi->frag, fpos_hash(pos));
295	295	else
296		− return fi->frag != fpos_frag(pos);
	296	+ return dfi->frag != fpos_frag(pos);
297	297	}
298	298
299	299	static int ceph_readdir(struct file file, struct dir_context ctx)
300	300	{
301		− struct ceph_file_info *fi = file->private_data;
	301	+ struct ceph_dir_file_info *dfi = file->private_data;
302	302	struct inode *inode = file_inode(file);
303	303	struct ceph_inode_info *ci = ceph_inode(inode);
304	304	struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
@@ -309,7 +309,7 @@ static int ceph_readdir(struct file file, struct dir_context ctx) · 4 unmodified lines
309	309	struct ceph_mds_reply_info_parsed *rinfo;
310	310
311	311	dout("readdir %p file %p pos %llx\n", inode, file, ctx->pos);
312		− if (fi->flags & CEPH_F_ATEND)
	312	+ if (dfi->file_info.flags & CEPH_F_ATEND)
313	313	return 0;
314	314
315	315	/* always start with . and .. */
@@ -350,15 +350,15 @@ static int ceph_readdir(struct file file, struct dir_context ctx) · 34 unmodified lines
350	350	/* proceed with a normal readdir */
351	351	more:
352	352	/* do we have the correct frag content buffered? */
353		− if (need_send_readdir(fi, ctx->pos)) {
	353	+ if (need_send_readdir(dfi, ctx->pos)) {
354	354	struct ceph_mds_request *req;
355	355	int op = ceph_snap(inode) == CEPH_SNAPDIR ?
356	356	CEPH_MDS_OP_LSSNAP : CEPH_MDS_OP_READDIR;
357	357
358	358	/* discard old result, if any */
359		− if (fi->last_readdir) {
360		− ceph_mdsc_put_request(fi->last_readdir);
361		− fi->last_readdir = NULL;
	359	+ if (dfi->last_readdir) {
	360	+ ceph_mdsc_put_request(dfi->last_readdir);
	361	+ dfi->last_readdir = NULL;
362	362	}
363	363
364	364	if (is_hash_order(ctx->pos)) {
@@ -372,7 +372,7 @@ more: · 7 unmodified lines
372	372	}
373	373
374	374	dout("readdir fetching %llx.%llx frag %x offset '%s'\n",
375		− ceph_vinop(inode), frag, fi->last_name);
	375	+ ceph_vinop(inode), frag, dfi->last_name);
376	376	req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
377	377	if (IS_ERR(req))
378	378	return PTR_ERR(req);
@@ -388,8 +388,8 @@ more: · 9 unmodified lines
388	388	__set_bit(CEPH_MDS_R_DIRECT_IS_HASH, &req->r_req_flags);
389	389	req->r_inode_drop = CEPH_CAP_FILE_EXCL;
390	390	}
391		− if (fi->last_name) {
392		− req->r_path2 = kstrdup(fi->last_name, GFP_KERNEL);
	391	+ if (dfi->last_name) {
	392	+ req->r_path2 = kstrdup(dfi->last_name, GFP_KERNEL);
393	393	if (!req->r_path2) {
394	394	ceph_mdsc_put_request(req);
395	395	return -ENOMEM;
@@ -399,10 +399,10 @@ more: · 3 unmodified lines
399	399	cpu_to_le32(fpos_hash(ctx->pos));
400	400	}
401	401
402		− req->r_dir_release_cnt = fi->dir_release_count;
403		− req->r_dir_ordered_cnt = fi->dir_ordered_count;
404		− req->r_readdir_cache_idx = fi->readdir_cache_idx;
405		− req->r_readdir_offset = fi->next_offset;
	402	+ req->r_dir_release_cnt = dfi->dir_release_count;
	403	+ req->r_dir_ordered_cnt = dfi->dir_ordered_count;
	404	+ req->r_readdir_cache_idx = dfi->readdir_cache_idx;
	405	+ req->r_readdir_offset = dfi->next_offset;
406	406	req->r_args.readdir.frag = cpu_to_le32(frag);
407	407	req->r_args.readdir.flags =
408	408	cpu_to_le16(CEPH_READDIR_REPLY_BITFLAGS);
@@ -426,35 +426,35 @@ more: · 17 unmodified lines
426	426	if (le32_to_cpu(rinfo->dir_dir->frag) != frag) {
427	427	frag = le32_to_cpu(rinfo->dir_dir->frag);
428	428	if (!rinfo->hash_order) {
429		− fi->next_offset = req->r_readdir_offset;
	429	+ dfi->next_offset = req->r_readdir_offset;
430	430	/* adjust ctx->pos to beginning of frag */
431	431	ctx->pos = ceph_make_fpos(frag,
432		− fi->next_offset,
	432	+ dfi->next_offset,
433	433	false);
434	434	}
435	435	}
436	436
437		− fi->frag = frag;
438		− fi->last_readdir = req;
	437	+ dfi->frag = frag;
	438	+ dfi->last_readdir = req;
439	439
440	440	if (test_bit(CEPH_MDS_R_DID_PREPOPULATE, &req->r_req_flags)) {
441		− fi->readdir_cache_idx = req->r_readdir_cache_idx;
442		− if (fi->readdir_cache_idx < 0) {
	441	+ dfi->readdir_cache_idx = req->r_readdir_cache_idx;
	442	+ if (dfi->readdir_cache_idx < 0) {
443	443	/* preclude from marking dir ordered */
444		− fi->dir_ordered_count = 0;
	444	+ dfi->dir_ordered_count = 0;
445	445	} else if (ceph_frag_is_leftmost(frag) &&
446		− fi->next_offset == 2) {
	446	+ dfi->next_offset == 2) {
447	447	/* note dir version at start of readdir so
448	448	* we can tell if any dentries get dropped */
449		− fi->dir_release_count = req->r_dir_release_cnt;
450		− fi->dir_ordered_count = req->r_dir_ordered_cnt;
	449	+ dfi->dir_release_count = req->r_dir_release_cnt;
	450	+ dfi->dir_ordered_count = req->r_dir_ordered_cnt;
451	451	}
452	452	} else {
453		− dout("readdir !did_prepopulate");
	453	+ dout("readdir !did_prepopulate\n");
454	454	/* disable readdir cache */
455		− fi->readdir_cache_idx = -1;
	455	+ dfi->readdir_cache_idx = -1;
456	456	/* preclude from marking dir complete */
457		− fi->dir_release_count = 0;
	457	+ dfi->dir_release_count = 0;
458	458	}
459	459
460	460	/* note next offset and last dentry name */
@@ -463,19 +463,19 @@ more: · 2 unmodified lines
463	463	rinfo->dir_entries + (rinfo->dir_nr-1);
464	464	unsigned next_offset = req->r_reply_info.dir_end ?
465	465	2 : (fpos_off(rde->offset) + 1);
466		− err = note_last_dentry(fi, rde->name, rde->name_len,
	466	+ err = note_last_dentry(dfi, rde->name, rde->name_len,
467	467	next_offset);
468	468	if (err)
469	469	return err;
470	470	} else if (req->r_reply_info.dir_end) {
471		− fi->next_offset = 2;
	471	+ dfi->next_offset = 2;
472	472	/* keep last name */
473	473	}
474	474	}
475	475
476		− rinfo = &fi->last_readdir->r_reply_info;
	476	+ rinfo = &dfi->last_readdir->r_reply_info;
477	477	dout("readdir frag %x num %d pos %llx chunk first %llx\n",
478		− fi->frag, rinfo->dir_nr, ctx->pos,
	478	+ dfi->frag, rinfo->dir_nr, ctx->pos,
479	479	rinfo->dir_nr ? rinfo->dir_entries[0].offset : 0LL);
480	480
481	481	i = 0;
@@ -519,52 +519,55 @@ more: · 37 unmodified lines
519	519	ctx->pos++;
520	520	}
521	521
522		− ceph_mdsc_put_request(fi->last_readdir);
523		− fi->last_readdir = NULL;
	522	+ ceph_mdsc_put_request(dfi->last_readdir);
	523	+ dfi->last_readdir = NULL;
524	524
525		− if (fi->next_offset > 2) {
526		− frag = fi->frag;
	525	+ if (dfi->next_offset > 2) {
	526	+ frag = dfi->frag;
527	527	goto more;
528	528	}
529	529
530	530	/* more frags? */
531		− if (!ceph_frag_is_rightmost(fi->frag)) {
532		− frag = ceph_frag_next(fi->frag);
	531	+ if (!ceph_frag_is_rightmost(dfi->frag)) {
	532	+ frag = ceph_frag_next(dfi->frag);
533	533	if (is_hash_order(ctx->pos)) {
534	534	loff_t new_pos = ceph_make_fpos(ceph_frag_value(frag),
535		− fi->next_offset, true);
	535	+ dfi->next_offset, true);
536	536	if (new_pos > ctx->pos)
537	537	ctx->pos = new_pos;
538	538	/* keep last_name */
539	539	} else {
540		− ctx->pos = ceph_make_fpos(frag, fi->next_offset, false);
541		− kfree(fi->last_name);
542		− fi->last_name = NULL;
	540	+ ctx->pos = ceph_make_fpos(frag, dfi->next_offset,
	541	+ false);
	542	+ kfree(dfi->last_name);
	543	+ dfi->last_name = NULL;
543	544	}
544	545	dout("readdir next frag is %x\n", frag);
545	546	goto more;
546	547	}
547		− fi->flags \|= CEPH_F_ATEND;
	548	+ dfi->file_info.flags \|= CEPH_F_ATEND;
548	549
549	550	/*
550	551	* if dir_release_count still matches the dir, no dentries
551	552	* were released during the whole readdir, and we should have
552	553	* the complete dir contents in our cache.
553	554	*/
554		− if (atomic64_read(&ci->i_release_count) == fi->dir_release_count) {
	555	+ if (atomic64_read(&ci->i_release_count) ==
	556	+ dfi->dir_release_count) {
555	557	spin_lock(&ci->i_ceph_lock);
556		− if (fi->dir_ordered_count == atomic64_read(&ci->i_ordered_count)) {
	558	+ if (dfi->dir_ordered_count ==
	559	+ atomic64_read(&ci->i_ordered_count)) {
557	560	dout(" marking %p complete and ordered\n", inode);
558	561	/* use i_size to track number of entries in
559	562	* readdir cache */
560		− BUG_ON(fi->readdir_cache_idx < 0);
561		− i_size_write(inode, fi->readdir_cache_idx *
	563	+ BUG_ON(dfi->readdir_cache_idx < 0);
	564	+ i_size_write(inode, dfi->readdir_cache_idx *
562	565	sizeof(struct dentry*));
563	566	} else {
564	567	dout(" marking %p complete\n", inode);
565	568	}
566		− __ceph_dir_set_complete(ci, fi->dir_release_count,
567		− fi->dir_ordered_count);
	569	+ __ceph_dir_set_complete(ci, dfi->dir_release_count,
	570	+ dfi->dir_ordered_count);
568	571	spin_unlock(&ci->i_ceph_lock);
569	572	}
570	573
@@ -572,25 +575,25 @@ more: · 1 unmodified line
572	575	return 0;
573	576	}
574	577
575		−static void reset_readdir(struct ceph_file_info *fi)
	578	+static void reset_readdir(struct ceph_dir_file_info *dfi)
576	579	{
577		− if (fi->last_readdir) {
578		− ceph_mdsc_put_request(fi->last_readdir);
579		− fi->last_readdir = NULL;
	580	+ if (dfi->last_readdir) {
	581	+ ceph_mdsc_put_request(dfi->last_readdir);
	582	+ dfi->last_readdir = NULL;
580	583	}
581		− kfree(fi->last_name);
582		− fi->last_name = NULL;
583		− fi->dir_release_count = 0;
584		− fi->readdir_cache_idx = -1;
585		− fi->next_offset = 2; /* compensate for . and .. */
586		− fi->flags &= ~CEPH_F_ATEND;
	584	+ kfree(dfi->last_name);
	585	+ dfi->last_name = NULL;
	586	+ dfi->dir_release_count = 0;
	587	+ dfi->readdir_cache_idx = -1;
	588	+ dfi->next_offset = 2; /* compensate for . and .. */
	589	+ dfi->file_info.flags &= ~CEPH_F_ATEND;
587	590	}
588	591
589	592	/*
590	593	* discard buffered readdir content on seekdir(0), or seek to new frag,
591	594	* or seek prior to current chunk
592	595	*/
593		−static bool need_reset_readdir(struct ceph_file_info *fi, loff_t new_pos)
	596	+static bool need_reset_readdir(struct ceph_dir_file_info *dfi, loff_t new_pos)
594	597	{
595	598	struct ceph_mds_reply_info_parsed *rinfo;
596	599	loff_t chunk_offset;
@@ -599,10 +602,10 @@ static bool need_reset_readdir(struct ceph_file_info *fi, loff_t new_pos) · 2 unmodified lines
599	602	if (is_hash_order(new_pos)) {
600	603	/* no need to reset last_name for a forward seek when
601	604	* dentries are sotred in hash order */
602		− } else if (fi->frag != fpos_frag(new_pos)) {
	605	+ } else if (dfi->frag != fpos_frag(new_pos)) {
603	606	return true;
604	607	}
605		− rinfo = fi->last_readdir ? &fi->last_readdir->r_reply_info : NULL;
	608	+ rinfo = dfi->last_readdir ? &dfi->last_readdir->r_reply_info : NULL;
606	609	if (!rinfo \|\| !rinfo->dir_nr)
607	610	return true;
608	611	chunk_offset = rinfo->dir_entries[0].offset;
@@ -612,7 +615,7 @@ static bool need_reset_readdir(struct ceph_file_info *fi, loff_t new_pos) · 3 unmodified lines
612	615
613	616	static loff_t ceph_dir_llseek(struct file *file, loff_t offset, int whence)
614	617	{
615		− struct ceph_file_info *fi = file->private_data;
	618	+ struct ceph_dir_file_info *dfi = file->private_data;
616	619	struct inode *inode = file->f_mapping->host;
617	620	loff_t retval;
618	621
@@ -630,20 +633,20 @@ static loff_t ceph_dir_llseek(struct file *file, loff_t offset, int whence) · 11 unmodified lines
630	633	}
631	634
632	635	if (offset >= 0) {
633		− if (need_reset_readdir(fi, offset)) {
	636	+ if (need_reset_readdir(dfi, offset)) {
634	637	dout("dir_llseek dropping %p content\n", file);
635		− reset_readdir(fi);
	638	+ reset_readdir(dfi);
636	639	} else if (is_hash_order(offset) && offset > file->f_pos) {
637	640	/* for hash offset, we don't know if a forward seek
638	641	* is within same frag */
639		− fi->dir_release_count = 0;
640		− fi->readdir_cache_idx = -1;
	642	+ dfi->dir_release_count = 0;
	643	+ dfi->readdir_cache_idx = -1;
641	644	}
642	645
643	646	if (offset != file->f_pos) {
644	647	file->f_pos = offset;
645	648	file->f_version = 0;
646		− fi->flags &= ~CEPH_F_ATEND;
	649	+ dfi->file_info.flags &= ~CEPH_F_ATEND;
647	650	}
648	651	retval = offset;
649	652	}
@@ -824,6 +827,9 @@ static int ceph_mknod(struct inode dir, struct dentry dentry, · 174 unmodified lines
824	827	if (ceph_snap(dir) != CEPH_NOSNAP)
825	828	return -EROFS;
826	829
	830	+ if (ceph_quota_is_max_files_exceeded(dir))
	831	+ return -EDQUOT;
	832	+
827	833	err = ceph_pre_init_acls(dir, &mode, &acls);
828	834	if (err < 0)
829	835	return err;
@@ -877,6 +883,9 @@ static int ceph_symlink(struct inode dir, struct dentry dentry, · 47 unmodified lines
877	883	if (ceph_snap(dir) != CEPH_NOSNAP)
878	884	return -EROFS;
879	885
	886	+ if (ceph_quota_is_max_files_exceeded(dir))
	887	+ return -EDQUOT;
	888	+
880	889	dout("symlink in dir %p dentry %p to '%s'\n", dir, dentry, dest);
881	890	req = ceph_mdsc_create_request(mdsc, CEPH_MDS_OP_SYMLINK, USE_AUTH_MDS);
882	891	if (IS_ERR(req)) {
@@ -926,6 +935,12 @@ static int ceph_mkdir(struct inode dir, struct dentry dentry, umode_t mode) · 43 unmodified lines
926	935	goto out;
927	936	}
928	937
	938	+ if (op == CEPH_MDS_OP_MKDIR &&
	939	+ ceph_quota_is_max_files_exceeded(dir)) {
	940	+ err = -EDQUOT;
	941	+ goto out;
	942	+ }
	943	+
929	944	mode \|= S_IFDIR;
930	945	err = ceph_pre_init_acls(dir, &mode, &acls);
931	946	if (err < 0)
@@ -1065,6 +1080,11 @@ static int ceph_rename(struct inode old_dir, struct dentry old_dentry, · 133 unmodified lines
1065	1080	else
1066	1081	return -EROFS;
1067	1082	}
	1083	+ /* don't allow cross-quota renames */
	1084	+ if ((old_dir != new_dir) &&
	1085	+ (!ceph_quota_is_same_realm(old_dir, new_dir)))
	1086	+ return -EXDEV;
	1087	+
1068	1088	dout("rename dir %p dentry %p to dir %p dentry %p\n",
1069	1089	old_dir, old_dentry, new_dir, new_dentry);
1070	1090	req = ceph_mdsc_create_request(mdsc, op, USE_AUTH_MDS);
@@ -1351,7 +1371,7 @@ static void ceph_d_prune(struct dentry *dentry) · 280 unmodified lines
1351	1371	static ssize_t ceph_read_dir(struct file file, char __user buf, size_t size,
1352	1372	loff_t *ppos)
1353	1373	{
1354		− struct ceph_file_info *cf = file->private_data;
	1374	+ struct ceph_dir_file_info *dfi = file->private_data;
1355	1375	struct inode *inode = file_inode(file);
1356	1376	struct ceph_inode_info *ci = ceph_inode(inode);
1357	1377	int left;
@@ -1360,12 +1380,12 @@ static ssize_t ceph_read_dir(struct file file, char __user buf, size_t size, · 2 unmodified lines
1360	1380	if (!ceph_test_mount_opt(ceph_sb_to_client(inode->i_sb), DIRSTAT))
1361	1381	return -EISDIR;
1362	1382
1363		− if (!cf->dir_info) {
1364		− cf->dir_info = kmalloc(bufsize, GFP_KERNEL);
1365		− if (!cf->dir_info)
	1383	+ if (!dfi->dir_info) {
	1384	+ dfi->dir_info = kmalloc(bufsize, GFP_KERNEL);
	1385	+ if (!dfi->dir_info)
1366	1386	return -ENOMEM;
1367		− cf->dir_info_len =
1368		− snprintf(cf->dir_info, bufsize,
	1387	+ dfi->dir_info_len =
	1388	+ snprintf(dfi->dir_info, bufsize,
1369	1389	"entries: %20lld\n"
1370	1390	" files: %20lld\n"
1371	1391	" subdirs: %20lld\n"
@@ -1385,10 +1405,10 @@ static ssize_t ceph_read_dir(struct file file, char __user buf, size_t size, · 13 unmodified lines
1385	1405	(long)ci->i_rctime.tv_nsec);
1386	1406	}
1387	1407
1388		− if (*ppos >= cf->dir_info_len)
	1408	+ if (*ppos >= dfi->dir_info_len)
1389	1409	return 0;
1390		− size = min_t(unsigned, size, cf->dir_info_len-*ppos);
1391		− left = copy_to_user(buf, cf->dir_info + *ppos, size);
	1410	+ size = min_t(unsigned, size, dfi->dir_info_len-*ppos);
	1411	+ left = copy_to_user(buf, dfi->dir_info + *ppos, size);
1392	1412	if (left == size)
1393	1413	return -EFAULT;
1394	1414	*ppos += (size - left);

fs/ceph/file.c+87−30

@@ -30,6 +30,8 @@ static __le32 ceph_flags_sys2wire(u32 flags) · 29 unmodified lines
30	30	break;
31	31	}
32	32
	33	+ flags &= ~O_ACCMODE;
	34	+
33	35	#define ceph_sys2wire(a) if (flags & a) { wire_flags \|= CEPH_##a; flags &= ~a; }
34	36
35	37	ceph_sys2wire(O_CREAT);
@@ -41,7 +43,7 @@ static __le32 ceph_flags_sys2wire(u32 flags) · 5 unmodified lines
41	43	#undef ceph_sys2wire
42	44
43	45	if (flags)
44		− dout("unused open flags: %x", flags);
	46	+ dout("unused open flags: %x\n", flags);
45	47
46	48	return cpu_to_le32(wire_flags);
47	49	}
@@ -159,13 +161,50 @@ out: · 111 unmodified lines
159	161	return req;
160	162	}
161	163
	164	+static int ceph_init_file_info(struct inode inode, struct file file,
	165	+ int fmode, bool isdir)
	166	+{
	167	+ struct ceph_file_info *fi;
	168	+
	169	+ dout("%s %p %p 0%o (%s)\n", __func__, inode, file,
	170	+ inode->i_mode, isdir ? "dir" : "regular");
	171	+ BUG_ON(inode->i_fop->release != ceph_release);
	172	+
	173	+ if (isdir) {
	174	+ struct ceph_dir_file_info *dfi =
	175	+ kmem_cache_zalloc(ceph_dir_file_cachep, GFP_KERNEL);
	176	+ if (!dfi) {
	177	+ ceph_put_fmode(ceph_inode(inode), fmode); /* clean up */
	178	+ return -ENOMEM;
	179	+ }
	180	+
	181	+ file->private_data = dfi;
	182	+ fi = &dfi->file_info;
	183	+ dfi->next_offset = 2;
	184	+ dfi->readdir_cache_idx = -1;
	185	+ } else {
	186	+ fi = kmem_cache_zalloc(ceph_file_cachep, GFP_KERNEL);
	187	+ if (!fi) {
	188	+ ceph_put_fmode(ceph_inode(inode), fmode); /* clean up */
	189	+ return -ENOMEM;
	190	+ }
	191	+
	192	+ file->private_data = fi;
	193	+ }
	194	+
	195	+ fi->fmode = fmode;
	196	+ spin_lock_init(&fi->rw_contexts_lock);
	197	+ INIT_LIST_HEAD(&fi->rw_contexts);
	198	+
	199	+ return 0;
	200	+}
	201	+
162	202	/*
163	203	* initialize private struct file data.
164	204	* if we fail, clean up by dropping fmode reference on the ceph_inode
165	205	*/
166	206	static int ceph_init_file(struct inode inode, struct file file, int fmode)
167	207	{
168		− struct ceph_file_info *cf;
169	208	int ret = 0;
170	209
171	210	switch (inode->i_mode & S_IFMT) {
@@ -173,22 +212,10 @@ static int ceph_init_file(struct inode inode, struct file file, int fmode) · 1 unmodified line
173	212	ceph_fscache_register_inode_cookie(inode);
174	213	ceph_fscache_file_set_cookie(inode, file);
175	214	case S_IFDIR:
176		− dout("init_file %p %p 0%o (regular)\n", inode, file,
177		− inode->i_mode);
178		− cf = kmem_cache_zalloc(ceph_file_cachep, GFP_KERNEL);
179		− if (!cf) {
180		− ceph_put_fmode(ceph_inode(inode), fmode); /* clean up */
181		− return -ENOMEM;
182		− }
183		− cf->fmode = fmode;
184		−
185		− spin_lock_init(&cf->rw_contexts_lock);
186		− INIT_LIST_HEAD(&cf->rw_contexts);
187		−
188		− cf->next_offset = 2;
189		− cf->readdir_cache_idx = -1;
190		− file->private_data = cf;
191		− BUG_ON(inode->i_fop->release != ceph_release);
	215	+ ret = ceph_init_file_info(inode, file, fmode,
	216	+ S_ISDIR(inode->i_mode));
	217	+ if (ret)
	218	+ return ret;
192	219	break;
193	220
194	221	case S_IFLNK:
@@ -278,11 +305,11 @@ int ceph_open(struct inode inode, struct file file) · 83 unmodified lines
278	305	struct ceph_fs_client *fsc = ceph_sb_to_client(inode->i_sb);
279	306	struct ceph_mds_client *mdsc = fsc->mdsc;
280	307	struct ceph_mds_request *req;
281		− struct ceph_file_info *cf = file->private_data;
	308	+ struct ceph_file_info *fi = file->private_data;
282	309	int err;
283	310	int flags, fmode, wanted;
284	311
285		− if (cf) {
	312	+ if (fi) {
286	313	dout("open file %p is already opened\n", file);
287	314	return 0;
288	315	}
@@ -375,7 +402,7 @@ int ceph_atomic_open(struct inode dir, struct dentry dentry, · 86 unmodified lines
375	402	struct ceph_mds_request *req;
376	403	struct dentry *dn;
377	404	struct ceph_acls_info acls = {};
378		− int mask;
	405	+ int mask;
379	406	int err;
380	407
381	408	dout("atomic_open %p dentry %p '%pd' %s flags %d mode 0%o\n",
@@ -386,6 +413,8 @@ int ceph_atomic_open(struct inode dir, struct dentry dentry, · 4 unmodified lines
386	413	return -ENAMETOOLONG;
387	414
388	415	if (flags & O_CREAT) {
	416	+ if (ceph_quota_is_max_files_exceeded(dir))
	417	+ return -EDQUOT;
389	418	err = ceph_pre_init_acls(dir, &mode, &acls);
390	419	if (err < 0)
391	420	return err;
@@ -460,16 +489,27 @@ out_acl: · 68 unmodified lines
460	489	int ceph_release(struct inode inode, struct file file)
461	490	{
462	491	struct ceph_inode_info *ci = ceph_inode(inode);
463		− struct ceph_file_info *cf = file->private_data;
464	492
465		− dout("release inode %p file %p\n", inode, file);
466		− ceph_put_fmode(ci, cf->fmode);
467		− if (cf->last_readdir)
468		− ceph_mdsc_put_request(cf->last_readdir);
469		− kfree(cf->last_name);
470		− kfree(cf->dir_info);
471		− WARN_ON(!list_empty(&cf->rw_contexts));
472		− kmem_cache_free(ceph_file_cachep, cf);
	493	+ if (S_ISDIR(inode->i_mode)) {
	494	+ struct ceph_dir_file_info *dfi = file->private_data;
	495	+ dout("release inode %p dir file %p\n", inode, file);
	496	+ WARN_ON(!list_empty(&dfi->file_info.rw_contexts));
	497	+
	498	+ ceph_put_fmode(ci, dfi->file_info.fmode);
	499	+
	500	+ if (dfi->last_readdir)
	501	+ ceph_mdsc_put_request(dfi->last_readdir);
	502	+ kfree(dfi->last_name);
	503	+ kfree(dfi->dir_info);
	504	+ kmem_cache_free(ceph_dir_file_cachep, dfi);
	505	+ } else {
	506	+ struct ceph_file_info *fi = file->private_data;
	507	+ dout("release inode %p regular file %p\n", inode, file);
	508	+ WARN_ON(!list_empty(&fi->rw_contexts));
	509	+
	510	+ ceph_put_fmode(ci, fi->fmode);
	511	+ kmem_cache_free(ceph_file_cachep, fi);
	512	+ }
473	513
474	514	/* wake up anyone waiting for caps on this inode */
475	515	wake_up_all(&ci->i_cap_wq);
@@ -1338,6 +1378,11 @@ retry_snap: · 862 unmodified lines
1338	1378
1339	1379	pos = iocb->ki_pos;
1340	1380	count = iov_iter_count(from);
	1381	+ if (ceph_quota_is_max_bytes_exceeded(inode, pos + count)) {
	1382	+ err = -EDQUOT;
	1383	+ goto out;
	1384	+ }
	1385	+
1341	1386	err = file_remove_privs(file);
1342	1387	if (err)
1343	1388	goto out;
@@ -1419,6 +1464,7 @@ retry_snap: · 75 unmodified lines
1419	1464
1420	1465	if (written >= 0) {
1421	1466	int dirty;
	1467	+
1422	1468	spin_lock(&ci->i_ceph_lock);
1423	1469	ci->i_inline_version = CEPH_INLINE_NONE;
1424	1470	dirty = __ceph_mark_dirty_caps(ci, CEPH_CAP_FILE_WR,
@@ -1426,6 +1472,8 @@ retry_snap: · 1 unmodified line
1426	1472	spin_unlock(&ci->i_ceph_lock);
1427	1473	if (dirty)
1428	1474	__mark_inode_dirty(inode, dirty);
	1475	+ if (ceph_quota_is_max_bytes_approaching(inode, iocb->ki_pos))
	1476	+ ceph_check_caps(ci, CHECK_CAPS_NODELAY, NULL);
1429	1477	}
1430	1478
1431	1479	dout("aio_write %p %llx.%llx %llu~%u dropping cap refs on %s\n",
@@ -1668,6 +1716,12 @@ static long ceph_fallocate(struct file *file, int mode, · 236 unmodified lines
1668	1716	goto unlock;
1669	1717	}
1670	1718
	1719	+ if (!(mode & (FALLOC_FL_PUNCH_HOLE \| FALLOC_FL_KEEP_SIZE)) &&
	1720	+ ceph_quota_is_max_bytes_exceeded(inode, offset + length)) {
	1721	+ ret = -EDQUOT;
	1722	+ goto unlock;
	1723	+ }
	1724	+
1671	1725	if (ceph_osdmap_flag(osdc, CEPH_OSDMAP_FULL) &&
1672	1726	!(mode & FALLOC_FL_PUNCH_HOLE)) {
1673	1727	ret = -ENOSPC;
@@ -1716,6 +1770,9 @@ static long ceph_fallocate(struct file *file, int mode, · 42 unmodified lines
1716	1770	spin_unlock(&ci->i_ceph_lock);
1717	1771	if (dirty)
1718	1772	__mark_inode_dirty(inode, dirty);
	1773	+ if ((endoff > size) &&
	1774	+ ceph_quota_is_max_bytes_approaching(inode, endoff))
	1775	+ ceph_check_caps(ci, CHECK_CAPS_NODELAY, NULL);
1719	1776	}
1720	1777
1721	1778	ceph_put_cap_refs(ci, got);

fs/ceph/inode.c+15−11

@@ -441,6 +441,9 @@ struct inode ceph_alloc_inode(struct super_block sb) · 440 unmodified lines
441	441	atomic64_set(&ci->i_complete_seq[1], 0);
442	442	ci->i_symlink = NULL;
443	443
	444	+ ci->i_max_bytes = 0;
	445	+ ci->i_max_files = 0;
	446	+
444	447	memset(&ci->i_dir_layout, 0, sizeof(ci->i_dir_layout));
445	448	RCU_INIT_POINTER(ci->i_layout.pool_ns, NULL);
446	449
@@ -536,6 +539,9 @@ void ceph_destroy_inode(struct inode *inode) · 89 unmodified lines
536	539
537	540	ceph_queue_caps_release(inode);
538	541
	542	+ if (__ceph_has_any_quota(ci))
	543	+ ceph_adjust_quota_realms_count(inode, false);
	544	+
539	545	/*
540	546	* we may still have a snap_realm reference if there are stray
541	547	* caps in i_snap_caps.
@@ -548,6 +554,9 @@ void ceph_destroy_inode(struct inode *inode) · 6 unmodified lines
548	554	dout(" dropping residual ref to snap realm %p\n", realm);
549	555	spin_lock(&realm->inodes_with_caps_lock);
550	556	list_del_init(&ci->i_snap_realm_item);
	557	+ ci->i_snap_realm = NULL;
	558	+ if (realm->ino == ci->i_vino.ino)
	559	+ realm->inode = NULL;
551	560	spin_unlock(&realm->inodes_with_caps_lock);
552	561	ceph_put_snap_realm(mdsc, realm);
553	562	}
@@ -790,6 +799,8 @@ static int fill_inode(struct inode inode, struct page locked_page, · 236 unmodified lines
790	799	inode->i_rdev = le32_to_cpu(info->rdev);
791	800	inode->i_blkbits = fls(le32_to_cpu(info->layout.fl_stripe_unit)) - 1;
792	801
	802	+ __ceph_update_quota(ci, iinfo->max_bytes, iinfo->max_files);
	803	+
793	804	if ((new_version \|\| (new_issued & CEPH_CAP_AUTH_SHARED)) &&
794	805	(issued & CEPH_CAP_AUTH_EXCL) == 0) {
795	806	inode->i_mode = le32_to_cpu(info->mode);
@@ -1867,20 +1878,9 @@ retry: · 1071 unmodified lines
1867	1878	* possibly truncate them.. so write AND block!
1868	1879	*/
1869	1880	if (ci->i_wrbuffer_ref_head < ci->i_wrbuffer_ref) {
1870		− struct ceph_cap_snap *capsnap;
1871		− to = ci->i_truncate_size;
1872		− list_for_each_entry(capsnap, &ci->i_cap_snaps, ci_item) {
1873		− // MDS should have revoked Frw caps
1874		− WARN_ON_ONCE(capsnap->writing);
1875		− if (capsnap->dirty_pages && capsnap->size > to)
1876		− to = capsnap->size;
1877		− }
1878	1881	spin_unlock(&ci->i_ceph_lock);
1879	1882	dout("__do_pending_vmtruncate %p flushing snaps first\n",
1880	1883	inode);
1881		−
1882		− truncate_pagecache(inode, to);
1883		−
1884	1884	filemap_write_and_wait_range(&inode->i_data, 0,
1885	1885	inode->i_sb->s_maxbytes);
1886	1886	goto retry;
@@ -2152,6 +2152,10 @@ int ceph_setattr(struct dentry dentry, struct iattr attr) · 265 unmodified lines
2152	2152	if (err != 0)
2153	2153	return err;
2154	2154
	2155	+ if ((attr->ia_valid & ATTR_SIZE) &&
	2156	+ ceph_quota_is_max_bytes_exceeded(inode, attr->ia_size))
	2157	+ return -EDQUOT;
	2158	+
2155	2159	err = __ceph_setattr(inode, attr);
2156	2160
2157	2161	if (err >= 0 && (attr->ia_valid & ATTR_MODE))

fs/ceph/ioctl.c+4−9

@@ -5,7 +5,7 @@ · 4 unmodified lines
5	5	#include "super.h"
6	6	#include "mds_client.h"
7	7	#include "ioctl.h"
8		−
	8	+#include <linux/ceph/striper.h>
9	9
10	10	/*
11	11	* ioctls
@@ -185,7 +185,7 @@ static long ceph_ioctl_get_dataloc(struct file file, void __user arg) · 173 unmodified lines
185	185	&ceph_sb_to_client(inode->i_sb)->client->osdc;
186	186	struct ceph_object_locator oloc;
187	187	CEPH_DEFINE_OID_ONSTACK(oid);
188		− u64 len = 1, olen;
	188	+ u32 xlen;
189	189	u64 tmp;
190	190	struct ceph_pg pgid;
191	191	int r;
@@ -195,13 +195,8 @@ static long ceph_ioctl_get_dataloc(struct file file, void __user arg) · 3 unmodified lines
195	195	return -EFAULT;
196	196
197	197	down_read(&osdc->lock);
198		− r = ceph_calc_file_object_mapping(&ci->i_layout, dl.file_offset, len,
199		− &dl.object_no, &dl.object_offset,
200		− &olen);
201		− if (r < 0) {
202		− up_read(&osdc->lock);
203		− return -EIO;
204		− }
	198	+ ceph_calc_file_object_mapping(&ci->i_layout, dl.file_offset, 1,
	199	+ &dl.object_no, &dl.object_offset, &xlen);
205	200	dl.file_offset -= dl.object_offset;
206	201	dl.object_size = ci->i_layout.object_size;
207	202	dl.block_size = ci->i_layout.stripe_unit;

fs/ceph/locks.c+10−10

@@ -95,7 +95,7 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct inode *inode, · 94 unmodified lines
95	95	owner = secure_addr(fl->fl_owner);
96	96
97	97	dout("ceph_lock_message: rule: %d, op: %d, owner: %llx, pid: %llu, "
98		− "start: %llu, length: %llu, wait: %d, type: %d", (int)lock_type,
	98	+ "start: %llu, length: %llu, wait: %d, type: %d\n", (int)lock_type,
99	99	(int)operation, owner, (u64)fl->fl_pid, fl->fl_start, length,
100	100	wait, fl->fl_type);
101	101
@@ -132,7 +132,7 @@ static int ceph_lock_message(u8 lock_type, u16 operation, struct inode *inode, · 30 unmodified lines
132	132	}
133	133	ceph_mdsc_put_request(req);
134	134	dout("ceph_lock_message: rule: %d, op: %d, pid: %llu, start: %llu, "
135		− "length: %llu, wait: %d, type: %d, err code %d", (int)lock_type,
	135	+ "length: %llu, wait: %d, type: %d, err code %d\n", (int)lock_type,
136	136	(int)operation, (u64)fl->fl_pid, fl->fl_start,
137	137	length, wait, fl->fl_type, err);
138	138	return err;
@@ -226,7 +226,7 @@ int ceph_lock(struct file file, int cmd, struct file_lock fl) · 87 unmodified lines
226	226	if (__mandatory_lock(file->f_mapping->host) && fl->fl_type != F_UNLCK)
227	227	return -ENOLCK;
228	228
229		− dout("ceph_lock, fl_owner: %p", fl->fl_owner);
	229	+ dout("ceph_lock, fl_owner: %p\n", fl->fl_owner);
230	230
231	231	/* set wait bit as appropriate, then make command as Ceph expects it*/
232	232	if (IS_GETLK(cmd))
@@ -264,7 +264,7 @@ int ceph_lock(struct file file, int cmd, struct file_lock fl) · 31 unmodified lines
264	264	err = ceph_lock_message(CEPH_LOCK_FCNTL, op, inode, lock_cmd, wait, fl);
265	265	if (!err) {
266	266	if (op == CEPH_MDS_OP_SETFILELOCK) {
267		− dout("mds locked, locking locally");
	267	+ dout("mds locked, locking locally\n");
268	268	err = posix_lock_file(file, fl, NULL);
269	269	if (err) {
270	270	/* undo! This should only happen if
@@ -272,7 +272,7 @@ int ceph_lock(struct file file, int cmd, struct file_lock fl) · 1 unmodified line
272	272	* deadlock. */
273	273	ceph_lock_message(CEPH_LOCK_FCNTL, op, inode,
274	274	CEPH_LOCK_UNLOCK, 0, fl);
275		− dout("got %d on posix_lock_file, undid lock",
	275	+ dout("got %d on posix_lock_file, undid lock\n",
276	276	err);
277	277	}
278	278	}
@@ -294,7 +294,7 @@ int ceph_flock(struct file file, int cmd, struct file_lock fl) · 15 unmodified lines
294	294	if (fl->fl_type & LOCK_MAND)
295	295	return -EOPNOTSUPP;
296	296
297		− dout("ceph_flock, fl_file: %p", fl->fl_file);
	297	+ dout("ceph_flock, fl_file: %p\n", fl->fl_file);
298	298
299	299	spin_lock(&ci->i_ceph_lock);
300	300	if (ci->i_ceph_flags & CEPH_I_ERROR_FILELOCK) {
@@ -329,7 +329,7 @@ int ceph_flock(struct file file, int cmd, struct file_lock fl) · 28 unmodified lines
329	329	ceph_lock_message(CEPH_LOCK_FLOCK,
330	330	CEPH_MDS_OP_SETFILELOCK,
331	331	inode, CEPH_LOCK_UNLOCK, 0, fl);
332		− dout("got %d on locks_lock_file_wait, undid lock", err);
	332	+ dout("got %d on locks_lock_file_wait, undid lock\n", err);
333	333	}
334	334	}
335	335	return err;
@@ -356,7 +356,7 @@ void ceph_count_locks(struct inode inode, int fcntl_count, int *flock_count) · 20 unmodified lines
356	356	++(*flock_count);
357	357	spin_unlock(&ctx->flc_lock);
358	358	}
359		− dout("counted %d flock locks and %d fcntl locks",
	359	+ dout("counted %d flock locks and %d fcntl locks\n",
360	360	flock_count, fcntl_count);
361	361	}
362	362
@@ -384,7 +384,7 @@ static int lock_to_ceph_filelock(struct file_lock *lock, · 21 unmodified lines
384	384	cephlock->type = CEPH_LOCK_UNLOCK;
385	385	break;
386	386	default:
387		− dout("Have unknown lock type %d", lock->fl_type);
	387	+ dout("Have unknown lock type %d\n", lock->fl_type);
388	388	err = -EINVAL;
389	389	}
390	390
@@ -407,7 +407,7 @@ int ceph_encode_locks_to_buffer(struct inode *inode, · 16 unmodified lines
407	407	int seen_flock = 0;
408	408	int l = 0;
409	409
410		− dout("encoding %d flock and %d fcntl locks", num_flock_locks,
	410	+ dout("encoding %d flock and %d fcntl locks\n", num_flock_locks,
411	411	num_fcntl_locks);
412	412
413	413	if (!ctx)

fs/ceph/mds_client.c+58−29

@@ -100,6 +100,26 @@ static int parse_reply_info_in(void *p, void end, · 99 unmodified lines
100	100	} else
101	101	info->inline_version = CEPH_INLINE_NONE;
102	102
	103	+ if (features & CEPH_FEATURE_MDS_QUOTA) {
	104	+ u8 struct_v, struct_compat;
	105	+ u32 struct_len;
	106	+
	107	+ /*
	108	+ * both struct_v and struct_compat are expected to be >= 1
	109	+ */
	110	+ ceph_decode_8_safe(p, end, struct_v, bad);
	111	+ ceph_decode_8_safe(p, end, struct_compat, bad);
	112	+ if (!struct_v \|\| !struct_compat)
	113	+ goto bad;
	114	+ ceph_decode_32_safe(p, end, struct_len, bad);
	115	+ ceph_decode_need(p, end, struct_len, bad);
	116	+ ceph_decode_64_safe(p, end, info->max_bytes, bad);
	117	+ ceph_decode_64_safe(p, end, info->max_files, bad);
	118	+ } else {
	119	+ info->max_bytes = 0;
	120	+ info->max_files = 0;
	121	+ }
	122	+
103	123	info->pool_ns_len = 0;
104	124	info->pool_ns_data = NULL;
105	125	if (features & CEPH_FEATURE_FS_FILE_LAYOUT_V2) {
@@ -384,7 +404,7 @@ static struct ceph_mds_session get_session(struct ceph_mds_session s) · 278 unmodified lines
384	404	refcount_read(&s->s_ref)-1, refcount_read(&s->s_ref));
385	405	return s;
386	406	} else {
387		− dout("mdsc get_session %p 0 -- FAIL", s);
	407	+ dout("mdsc get_session %p 0 -- FAIL\n", s);
388	408	return NULL;
389	409	}
390	410	}
@@ -419,9 +439,10 @@ struct ceph_mds_session __ceph_lookup_mds_session(struct ceph_mds_client mdsc, · 28 unmodified lines
419	439
420	440	static bool __have_session(struct ceph_mds_client *mdsc, int mds)
421	441	{
422		− if (mds >= mdsc->max_sessions)
	442	+ if (mds >= mdsc->max_sessions \|\| !mdsc->sessions[mds])
423	443	return false;
424		− return mdsc->sessions[mds];
	444	+ else
	445	+ return true;
425	446	}
426	447
427	448	static int __verify_registered_session(struct ceph_mds_client *mdsc,
@@ -448,6 +469,25 @@ static struct ceph_mds_session register_session(struct ceph_mds_client mdsc, · 20 unmodified lines
448	469	s = kzalloc(sizeof(*s), GFP_NOFS);
449	470	if (!s)
450	471	return ERR_PTR(-ENOMEM);
	472	+
	473	+ if (mds >= mdsc->max_sessions) {
	474	+ int newmax = 1 << get_count_order(mds + 1);
	475	+ struct ceph_mds_session **sa;
	476	+
	477	+ dout("%s: realloc to %d\n", __func__, newmax);
	478	+ sa = kcalloc(newmax, sizeof(void *), GFP_NOFS);
	479	+ if (!sa)
	480	+ goto fail_realloc;
	481	+ if (mdsc->sessions) {
	482	+ memcpy(sa, mdsc->sessions,
	483	+ mdsc->max_sessions * sizeof(void *));
	484	+ kfree(mdsc->sessions);
	485	+ }
	486	+ mdsc->sessions = sa;
	487	+ mdsc->max_sessions = newmax;
	488	+ }
	489	+
	490	+ dout("%s: mds%d\n", __func__, mds);
451	491	s->s_mdsc = mdsc;
452	492	s->s_mds = mds;
453	493	s->s_state = CEPH_MDS_SESSION_NEW;
@@ -476,23 +516,6 @@ static struct ceph_mds_session register_session(struct ceph_mds_client mdsc, · 22 unmodified lines
476	516	INIT_LIST_HEAD(&s->s_cap_releases);
477	517	INIT_LIST_HEAD(&s->s_cap_flushing);
478	518
479		− dout("register_session mds%d\n", mds);
480		− if (mds >= mdsc->max_sessions) {
481		− int newmax = 1 << get_count_order(mds+1);
482		− struct ceph_mds_session **sa;
483		−
484		− dout("register_session realloc to %d\n", newmax);
485		− sa = kcalloc(newmax, sizeof(void *), GFP_NOFS);
486		− if (!sa)
487		− goto fail_realloc;
488		− if (mdsc->sessions) {
489		− memcpy(sa, mdsc->sessions,
490		− mdsc->max_sessions * sizeof(void *));
491		− kfree(mdsc->sessions);
492		− }
493		− mdsc->sessions = sa;
494		− mdsc->max_sessions = newmax;
495		− }
496	519	mdsc->sessions[mds] = s;
497	520	atomic_inc(&mdsc->num_sessions);
498	521	refcount_inc(&s->s_ref); /* one ref to sessions[], one to caller */
@@ -2531,10 +2554,10 @@ static void handle_reply(struct ceph_mds_session session, struct ceph_msg msg) · 2032 unmodified lines
2531	2554	* Otherwise we just have to return an ESTALE
2532	2555	*/
2533	2556	if (result == -ESTALE) {
2534		− dout("got ESTALE on request %llu", req->r_tid);
	2557	+ dout("got ESTALE on request %llu\n", req->r_tid);
2535	2558	req->r_resend_mds = -1;
2536	2559	if (req->r_direct_mode != USE_AUTH_MDS) {
2537		− dout("not using auth, setting for that now");
	2560	+ dout("not using auth, setting for that now\n");
2538	2561	req->r_direct_mode = USE_AUTH_MDS;
2539	2562	__do_request(mdsc, req);
2540	2563	mutex_unlock(&mdsc->mutex);
@@ -2542,13 +2565,13 @@ static void handle_reply(struct ceph_mds_session session, struct ceph_msg msg) · 1 unmodified line
2542	2565	} else {
2543	2566	int mds = __choose_mds(mdsc, req);
2544	2567	if (mds >= 0 && mds != req->r_session->s_mds) {
2545		− dout("but auth changed, so resending");
	2568	+ dout("but auth changed, so resending\n");
2546	2569	__do_request(mdsc, req);
2547	2570	mutex_unlock(&mdsc->mutex);
2548	2571	goto out;
2549	2572	}
2550	2573	}
2551		− dout("have to return ESTALE on request %llu", req->r_tid);
	2574	+ dout("have to return ESTALE on request %llu\n", req->r_tid);
2552	2575	}
2553	2576
2554	2577
@@ -3470,13 +3493,12 @@ void ceph_mdsc_lease_send_msg(struct ceph_mds_session *session, · 915 unmodified lines
3470	3493	}
3471	3494
3472	3495	/*
3473		− * drop all leases (and dentry refs) in preparation for umount
	3496	+ * lock unlock sessions, to wait ongoing session activities
3474	3497	*/
3475		−static void drop_leases(struct ceph_mds_client *mdsc)
	3498	+static void lock_unlock_sessions(struct ceph_mds_client *mdsc)
3476	3499	{
3477	3500	int i;
3478	3501
3479		− dout("drop_leases\n");
3480	3502	mutex_lock(&mdsc->mutex);
3481	3503	for (i = 0; i < mdsc->max_sessions; i++) {
3482	3504	struct ceph_mds_session *s = __ceph_lookup_mds_session(mdsc, i);
@@ -3572,7 +3594,6 @@ int ceph_mdsc_init(struct ceph_fs_client *fsc) · 89 unmodified lines
3572	3594	if (!mdsc)
3573	3595	return -ENOMEM;
3574	3596	mdsc->fsc = fsc;
3575		− fsc->mdsc = mdsc;
3576	3597	mutex_init(&mdsc->mutex);
3577	3598	mdsc->mdsmap = kzalloc(sizeof(*mdsc->mdsmap), GFP_NOFS);
3578	3599	if (!mdsc->mdsmap) {
@@ -3580,6 +3601,7 @@ int ceph_mdsc_init(struct ceph_fs_client *fsc) · 1 unmodified line
3580	3601	return -ENOMEM;
3581	3602	}
3582	3603
	3604	+ fsc->mdsc = mdsc;
3583	3605	init_completion(&mdsc->safe_umount_waiters);
3584	3606	init_waitqueue_head(&mdsc->session_close_wq);
3585	3607	INIT_LIST_HEAD(&mdsc->waiting_for_map);
@@ -3587,6 +3609,7 @@ int ceph_mdsc_init(struct ceph_fs_client *fsc) · 1 unmodified line
3587	3609	atomic_set(&mdsc->num_sessions, 0);
3588	3610	mdsc->max_sessions = 0;
3589	3611	mdsc->stopping = 0;
	3612	+ atomic64_set(&mdsc->quotarealms_count, 0);
3590	3613	mdsc->last_snap_seq = 0;
3591	3614	init_rwsem(&mdsc->snap_rwsem);
3592	3615	mdsc->snap_realms = RB_ROOT;
@@ -3660,7 +3683,7 @@ void ceph_mdsc_pre_umount(struct ceph_mds_client *mdsc) · 67 unmodified lines
3660	3683	dout("pre_umount\n");
3661	3684	mdsc->stopping = 1;
3662	3685
3663		− drop_leases(mdsc);
	3686	+ lock_unlock_sessions(mdsc);
3664	3687	ceph_flush_dirty_caps(mdsc);
3665	3688	wait_requests(mdsc);
3666	3689
@@ -3858,6 +3881,9 @@ void ceph_mdsc_destroy(struct ceph_fs_client *fsc) · 191 unmodified lines
3858	3881	struct ceph_mds_client *mdsc = fsc->mdsc;
3859	3882	dout("mdsc_destroy %p\n", mdsc);
3860	3883
	3884	+ if (!mdsc)
	3885	+ return;
	3886	+
3861	3887	/* flush out any connection work with references to us */
3862	3888	ceph_msgr_flush();
3863	3889
@@ -4077,6 +4103,9 @@ static void dispatch(struct ceph_connection con, struct ceph_msg msg) · 213 unmodified lines
4077	4103	case CEPH_MSG_CLIENT_LEASE:
4078	4104	handle_lease(mdsc, s, msg);
4079	4105	break;
	4106	+ case CEPH_MSG_CLIENT_QUOTA:
	4107	+ ceph_handle_quota(mdsc, s, msg);
	4108	+ break;
4080	4109
4081	4110	default:
4082	4111	pr_err("received unknown message type %d %s\n", type,

fs/ceph/mds_client.h+4−0

@@ -49,6 +49,8 @@ struct ceph_mds_reply_info_in { · 48 unmodified lines
49	49	char *inline_data;
50	50	u32 pool_ns_len;
51	51	char *pool_ns_data;
	52	+ u64 max_bytes;
	53	+ u64 max_files;
52	54	};
53	55
54	56	struct ceph_mds_reply_dir_entry {
@@ -312,6 +314,8 @@ struct ceph_mds_client { · 257 unmodified lines
312	314	int max_sessions; /* len of s_mds_sessions */
313	315	int stopping; /* true if shutting down */
314	316
	317	+ atomic64_t quotarealms_count; /* # realms with quota */
	318	+
315	319	/*
316	320	* snap_rwsem will cover cap linkage into snaprealms, and
317	321	* realm snap contexts. (later, we can do per-realm snap

fs/ceph/quota.c+361−0

@@ -0,0 +1,361 @@
	1	+// SPDX-License-Identifier: GPL-2.0
	2	+/*
	3	+ * quota.c - CephFS quota
	4	+ *
	5	+ * Copyright (C) 2017-2018 SUSE
	6	+ *
	7	+ * This program is free software; you can redistribute it and/or
	8	+ * modify it under the terms of the GNU General Public License
	9	+ * as published by the Free Software Foundation; either version 2
	10	+ * of the License, or (at your option) any later version.
	11	+ *
	12	+ * This program is distributed in the hope that it will be useful,
	13	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	+ * GNU General Public License for more details.
	16	+ *
	17	+ * You should have received a copy of the GNU General Public License
	18	+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
	19	+ */
	20	+
	21	+#include <linux/statfs.h>
	22	+
	23	+#include "super.h"
	24	+#include "mds_client.h"
	25	+
	26	+void ceph_adjust_quota_realms_count(struct inode *inode, bool inc)
	27	+{
	28	+ struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
	29	+ if (inc)
	30	+ atomic64_inc(&mdsc->quotarealms_count);
	31	+ else
	32	+ atomic64_dec(&mdsc->quotarealms_count);
	33	+}
	34	+
	35	+static inline bool ceph_has_realms_with_quotas(struct inode *inode)
	36	+{
	37	+ struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
	38	+ return atomic64_read(&mdsc->quotarealms_count) > 0;
	39	+}
	40	+
	41	+void ceph_handle_quota(struct ceph_mds_client *mdsc,
	42	+ struct ceph_mds_session *session,
	43	+ struct ceph_msg *msg)
	44	+{
	45	+ struct super_block *sb = mdsc->fsc->sb;
	46	+ struct ceph_mds_quota *h = msg->front.iov_base;
	47	+ struct ceph_vino vino;
	48	+ struct inode *inode;
	49	+ struct ceph_inode_info *ci;
	50	+
	51	+ if (msg->front.iov_len != sizeof(*h)) {
	52	+ pr_err("%s corrupt message mds%d len %d\n", __func__,
	53	+ session->s_mds, (int)msg->front.iov_len);
	54	+ ceph_msg_dump(msg);
	55	+ return;
	56	+ }
	57	+
	58	+ /* increment msg sequence number */
	59	+ mutex_lock(&session->s_mutex);
	60	+ session->s_seq++;
	61	+ mutex_unlock(&session->s_mutex);
	62	+
	63	+ /* lookup inode */
	64	+ vino.ino = le64_to_cpu(h->ino);
	65	+ vino.snap = CEPH_NOSNAP;
	66	+ inode = ceph_find_inode(sb, vino);
	67	+ if (!inode) {
	68	+ pr_warn("Failed to find inode %llu\n", vino.ino);
	69	+ return;
	70	+ }
	71	+ ci = ceph_inode(inode);
	72	+
	73	+ spin_lock(&ci->i_ceph_lock);
	74	+ ci->i_rbytes = le64_to_cpu(h->rbytes);
	75	+ ci->i_rfiles = le64_to_cpu(h->rfiles);
	76	+ ci->i_rsubdirs = le64_to_cpu(h->rsubdirs);
	77	+ __ceph_update_quota(ci, le64_to_cpu(h->max_bytes),
	78	+ le64_to_cpu(h->max_files));
	79	+ spin_unlock(&ci->i_ceph_lock);
	80	+
	81	+ iput(inode);
	82	+}
	83	+
	84	+/*
	85	+ * This function walks through the snaprealm for an inode and returns the
	86	+ * ceph_snap_realm for the first snaprealm that has quotas set (either max_files
	87	+ * or max_bytes). If the root is reached, return the root ceph_snap_realm
	88	+ * instead.
	89	+ *
	90	+ * Note that the caller is responsible for calling ceph_put_snap_realm() on the
	91	+ * returned realm.
	92	+ */
	93	+static struct ceph_snap_realm get_quota_realm(struct ceph_mds_client mdsc,
	94	+ struct inode *inode)
	95	+{
	96	+ struct ceph_inode_info *ci = NULL;
	97	+ struct ceph_snap_realm realm, next;
	98	+ struct inode *in;
	99	+ bool has_quota;
	100	+
	101	+ if (ceph_snap(inode) != CEPH_NOSNAP)
	102	+ return NULL;
	103	+
	104	+ realm = ceph_inode(inode)->i_snap_realm;
	105	+ if (realm)
	106	+ ceph_get_snap_realm(mdsc, realm);
	107	+ else
	108	+ pr_err_ratelimited("get_quota_realm: ino (%llx.%llx) "
	109	+ "null i_snap_realm\n", ceph_vinop(inode));
	110	+ while (realm) {
	111	+ spin_lock(&realm->inodes_with_caps_lock);
	112	+ in = realm->inode ? igrab(realm->inode) : NULL;
	113	+ spin_unlock(&realm->inodes_with_caps_lock);
	114	+ if (!in)
	115	+ break;
	116	+
	117	+ ci = ceph_inode(in);
	118	+ has_quota = __ceph_has_any_quota(ci);
	119	+ iput(in);
	120	+
	121	+ next = realm->parent;
	122	+ if (has_quota \|\| !next)
	123	+ return realm;
	124	+
	125	+ ceph_get_snap_realm(mdsc, next);
	126	+ ceph_put_snap_realm(mdsc, realm);
	127	+ realm = next;
	128	+ }
	129	+ if (realm)
	130	+ ceph_put_snap_realm(mdsc, realm);
	131	+
	132	+ return NULL;
	133	+}
	134	+
	135	+bool ceph_quota_is_same_realm(struct inode old, struct inode new)
	136	+{
	137	+ struct ceph_mds_client *mdsc = ceph_inode_to_client(old)->mdsc;
	138	+ struct ceph_snap_realm old_realm, new_realm;
	139	+ bool is_same;
	140	+
	141	+ down_read(&mdsc->snap_rwsem);
	142	+ old_realm = get_quota_realm(mdsc, old);
	143	+ new_realm = get_quota_realm(mdsc, new);
	144	+ is_same = (old_realm == new_realm);
	145	+ up_read(&mdsc->snap_rwsem);
	146	+
	147	+ if (old_realm)
	148	+ ceph_put_snap_realm(mdsc, old_realm);
	149	+ if (new_realm)
	150	+ ceph_put_snap_realm(mdsc, new_realm);
	151	+
	152	+ return is_same;
	153	+}
	154	+
	155	+enum quota_check_op {
	156	+ QUOTA_CHECK_MAX_FILES_OP, /* check quota max_files limit */
	157	+ QUOTA_CHECK_MAX_BYTES_OP, /* check quota max_files limit */
	158	+ QUOTA_CHECK_MAX_BYTES_APPROACHING_OP /* check if quota max_files
	159	+ limit is approaching */
	160	+};
	161	+
	162	+/*
	163	+ * check_quota_exceeded() will walk up the snaprealm hierarchy and, for each
	164	+ * realm, it will execute quota check operation defined by the 'op' parameter.
	165	+ * The snaprealm walk is interrupted if the quota check detects that the quota
	166	+ * is exceeded or if the root inode is reached.
	167	+ */
	168	+static bool check_quota_exceeded(struct inode *inode, enum quota_check_op op,
	169	+ loff_t delta)
	170	+{
	171	+ struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
	172	+ struct ceph_inode_info *ci;
	173	+ struct ceph_snap_realm realm, next;
	174	+ struct inode *in;
	175	+ u64 max, rvalue;
	176	+ bool exceeded = false;
	177	+
	178	+ if (ceph_snap(inode) != CEPH_NOSNAP)
	179	+ return false;
	180	+
	181	+ down_read(&mdsc->snap_rwsem);
	182	+ realm = ceph_inode(inode)->i_snap_realm;
	183	+ if (realm)
	184	+ ceph_get_snap_realm(mdsc, realm);
	185	+ else
	186	+ pr_err_ratelimited("check_quota_exceeded: ino (%llx.%llx) "
	187	+ "null i_snap_realm\n", ceph_vinop(inode));
	188	+ while (realm) {
	189	+ spin_lock(&realm->inodes_with_caps_lock);
	190	+ in = realm->inode ? igrab(realm->inode) : NULL;
	191	+ spin_unlock(&realm->inodes_with_caps_lock);
	192	+ if (!in)
	193	+ break;
	194	+
	195	+ ci = ceph_inode(in);
	196	+ spin_lock(&ci->i_ceph_lock);
	197	+ if (op == QUOTA_CHECK_MAX_FILES_OP) {
	198	+ max = ci->i_max_files;
	199	+ rvalue = ci->i_rfiles + ci->i_rsubdirs;
	200	+ } else {
	201	+ max = ci->i_max_bytes;
	202	+ rvalue = ci->i_rbytes;
	203	+ }
	204	+ spin_unlock(&ci->i_ceph_lock);
	205	+ switch (op) {
	206	+ case QUOTA_CHECK_MAX_FILES_OP:
	207	+ exceeded = (max && (rvalue >= max));
	208	+ break;
	209	+ case QUOTA_CHECK_MAX_BYTES_OP:
	210	+ exceeded = (max && (rvalue + delta > max));
	211	+ break;
	212	+ case QUOTA_CHECK_MAX_BYTES_APPROACHING_OP:
	213	+ if (max) {
	214	+ if (rvalue >= max)
	215	+ exceeded = true;
	216	+ else {
	217	+ /*
	218	+ * when we're writing more that 1/16th
	219	+ * of the available space
	220	+ */
	221	+ exceeded =
	222	+ (((max - rvalue) >> 4) < delta);
	223	+ }
	224	+ }
	225	+ break;
	226	+ default:
	227	+ /* Shouldn't happen */
	228	+ pr_warn("Invalid quota check op (%d)\n", op);
	229	+ exceeded = true; /* Just break the loop */
	230	+ }
	231	+ iput(in);
	232	+
	233	+ next = realm->parent;
	234	+ if (exceeded \|\| !next)
	235	+ break;
	236	+ ceph_get_snap_realm(mdsc, next);
	237	+ ceph_put_snap_realm(mdsc, realm);
	238	+ realm = next;
	239	+ }
	240	+ ceph_put_snap_realm(mdsc, realm);
	241	+ up_read(&mdsc->snap_rwsem);
	242	+
	243	+ return exceeded;
	244	+}
	245	+
	246	+/*
	247	+ * ceph_quota_is_max_files_exceeded - check if we can create a new file
	248	+ * @inode: directory where a new file is being created
	249	+ *
	250	+ * This functions returns true is max_files quota allows a new file to be
	251	+ * created. It is necessary to walk through the snaprealm hierarchy (until the
	252	+ * FS root) to check all realms with quotas set.
	253	+ */
	254	+bool ceph_quota_is_max_files_exceeded(struct inode *inode)
	255	+{
	256	+ if (!ceph_has_realms_with_quotas(inode))
	257	+ return false;
	258	+
	259	+ WARN_ON(!S_ISDIR(inode->i_mode));
	260	+
	261	+ return check_quota_exceeded(inode, QUOTA_CHECK_MAX_FILES_OP, 0);
	262	+}
	263	+
	264	+/*
	265	+ * ceph_quota_is_max_bytes_exceeded - check if we can write to a file
	266	+ * @inode: inode being written
	267	+ * @newsize: new size if write succeeds
	268	+ *
	269	+ * This functions returns true is max_bytes quota allows a file size to reach
	270	+ * @newsize; it returns false otherwise.
	271	+ */
	272	+bool ceph_quota_is_max_bytes_exceeded(struct inode *inode, loff_t newsize)
	273	+{
	274	+ loff_t size = i_size_read(inode);
	275	+
	276	+ if (!ceph_has_realms_with_quotas(inode))
	277	+ return false;
	278	+
	279	+ /* return immediately if we're decreasing file size */
	280	+ if (newsize <= size)
	281	+ return false;
	282	+
	283	+ return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_OP, (newsize - size));
	284	+}
	285	+
	286	+/*
	287	+ * ceph_quota_is_max_bytes_approaching - check if we're reaching max_bytes
	288	+ * @inode: inode being written
	289	+ * @newsize: new size if write succeeds
	290	+ *
	291	+ * This function returns true if the new file size @newsize will be consuming
	292	+ * more than 1/16th of the available quota space; it returns false otherwise.
	293	+ */
	294	+bool ceph_quota_is_max_bytes_approaching(struct inode *inode, loff_t newsize)
	295	+{
	296	+ loff_t size = ceph_inode(inode)->i_reported_size;
	297	+
	298	+ if (!ceph_has_realms_with_quotas(inode))
	299	+ return false;
	300	+
	301	+ /* return immediately if we're decreasing file size */
	302	+ if (newsize <= size)
	303	+ return false;
	304	+
	305	+ return check_quota_exceeded(inode, QUOTA_CHECK_MAX_BYTES_APPROACHING_OP,
	306	+ (newsize - size));
	307	+}
	308	+
	309	+/*
	310	+ * ceph_quota_update_statfs - if root has quota update statfs with quota status
	311	+ * @fsc: filesystem client instance
	312	+ * @buf: statfs to update
	313	+ *
	314	+ * If the mounted filesystem root has max_bytes quota set, update the filesystem
	315	+ * statistics with the quota status.
	316	+ *
	317	+ * This function returns true if the stats have been updated, false otherwise.
	318	+ */
	319	+bool ceph_quota_update_statfs(struct ceph_fs_client fsc, struct kstatfs buf)
	320	+{
	321	+ struct ceph_mds_client *mdsc = fsc->mdsc;
	322	+ struct ceph_inode_info *ci;
	323	+ struct ceph_snap_realm *realm;
	324	+ struct inode *in;
	325	+ u64 total = 0, used, free;
	326	+ bool is_updated = false;
	327	+
	328	+ down_read(&mdsc->snap_rwsem);
	329	+ realm = get_quota_realm(mdsc, d_inode(fsc->sb->s_root));
	330	+ up_read(&mdsc->snap_rwsem);
	331	+ if (!realm)
	332	+ return false;
	333	+
	334	+ spin_lock(&realm->inodes_with_caps_lock);
	335	+ in = realm->inode ? igrab(realm->inode) : NULL;
	336	+ spin_unlock(&realm->inodes_with_caps_lock);
	337	+ if (in) {
	338	+ ci = ceph_inode(in);
	339	+ spin_lock(&ci->i_ceph_lock);
	340	+ if (ci->i_max_bytes) {
	341	+ total = ci->i_max_bytes >> CEPH_BLOCK_SHIFT;
	342	+ used = ci->i_rbytes >> CEPH_BLOCK_SHIFT;
	343	+ /* It is possible for a quota to be exceeded.
	344	+ * Report 'zero' in that case
	345	+ */
	346	+ free = total > used ? total - used : 0;
	347	+ }
	348	+ spin_unlock(&ci->i_ceph_lock);
	349	+ if (total) {
	350	+ buf->f_blocks = total;
	351	+ buf->f_bfree = free;
	352	+ buf->f_bavail = free;
	353	+ is_updated = true;
	354	+ }
	355	+ iput(in);
	356	+ }
	357	+ ceph_put_snap_realm(mdsc, realm);
	358	+
	359	+ return is_updated;
	360	+}
	361	+

fs/ceph/snap.c+2−0

@@ -931,6 +931,8 @@ void ceph_handle_snap(struct ceph_mds_client *mdsc, · 930 unmodified lines
931	931	list_add(&ci->i_snap_realm_item,
932	932	&realm->inodes_with_caps);
933	933	ci->i_snap_realm = realm;
	934	+ if (realm->ino == ci->i_vino.ino)
	935	+ realm->inode = inode;
934	936	spin_unlock(&realm->inodes_with_caps_lock);
935	937
936	938	spin_unlock(&ci->i_ceph_lock);

fs/ceph/super.c+39−11

@@ -76,9 +76,18 @@ static int ceph_statfs(struct dentry dentry, struct kstatfs buf) · 75 unmodified lines
76	76	*/
77	77	buf->f_bsize = 1 << CEPH_BLOCK_SHIFT;
78	78	buf->f_frsize = 1 << CEPH_BLOCK_SHIFT;
79		− buf->f_blocks = le64_to_cpu(st.kb) >> (CEPH_BLOCK_SHIFT-10);
80		− buf->f_bfree = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
81		− buf->f_bavail = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
	79	+
	80	+ /*
	81	+ * By default use root quota for stats; fallback to overall filesystem
	82	+ * usage if using 'noquotadf' mount option or if the root dir doesn't
	83	+ * have max_bytes quota set.
	84	+ */
	85	+ if (ceph_test_mount_opt(fsc, NOQUOTADF) \|\|
	86	+ !ceph_quota_update_statfs(fsc, buf)) {
	87	+ buf->f_blocks = le64_to_cpu(st.kb) >> (CEPH_BLOCK_SHIFT-10);
	88	+ buf->f_bfree = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
	89	+ buf->f_bavail = le64_to_cpu(st.kb_avail) >> (CEPH_BLOCK_SHIFT-10);
	90	+ }
82	91
83	92	buf->f_files = le64_to_cpu(st.num_objects);
84	93	buf->f_ffree = -1;
@@ -151,6 +160,8 @@ enum { · 66 unmodified lines
151	160	Opt_acl,
152	161	#endif
153	162	Opt_noacl,
	163	+ Opt_quotadf,
	164	+ Opt_noquotadf,
154	165	};
155	166
156	167	static match_table_t fsopt_tokens = {
@@ -187,6 +198,8 @@ static match_table_t fsopt_tokens = { · 30 unmodified lines
187	198	{Opt_acl, "acl"},
188	199	#endif
189	200	{Opt_noacl, "noacl"},
	201	+ {Opt_quotadf, "quotadf"},
	202	+ {Opt_noquotadf, "noquotadf"},
190	203	{-1, NULL}
191	204	};
192	205
@@ -314,13 +327,16 @@ static int parse_fsopt_token(char c, void private) · 121 unmodified lines
314	327	break;
315	328	case Opt_fscache:
316	329	fsopt->flags \|= CEPH_MOUNT_OPT_FSCACHE;
	330	+ kfree(fsopt->fscache_uniq);
	331	+ fsopt->fscache_uniq = NULL;
317	332	break;
318	333	case Opt_nofscache:
319	334	fsopt->flags &= ~CEPH_MOUNT_OPT_FSCACHE;
	335	+ kfree(fsopt->fscache_uniq);
	336	+ fsopt->fscache_uniq = NULL;
320	337	break;
321	338	case Opt_poolperm:
322	339	fsopt->flags &= ~CEPH_MOUNT_OPT_NOPOOLPERM;
323		− printk ("pool perm");
324	340	break;
325	341	case Opt_nopoolperm:
326	342	fsopt->flags \|= CEPH_MOUNT_OPT_NOPOOLPERM;
@@ -331,6 +347,12 @@ static int parse_fsopt_token(char c, void private) · 4 unmodified lines
331	347	case Opt_norequire_active_mds:
332	348	fsopt->flags \|= CEPH_MOUNT_OPT_MOUNTWAIT;
333	349	break;
	350	+ case Opt_quotadf:
	351	+ fsopt->flags &= ~CEPH_MOUNT_OPT_NOQUOTADF;
	352	+ break;
	353	+ case Opt_noquotadf:
	354	+ fsopt->flags \|= CEPH_MOUNT_OPT_NOQUOTADF;
	355	+ break;
334	356	#ifdef CONFIG_CEPH_FS_POSIX_ACL
335	357	case Opt_acl:
336	358	fsopt->sb_flags \|= SB_POSIXACL;
@@ -513,13 +535,12 @@ static int ceph_show_options(struct seq_file m, struct dentry root) · 176 unmodified lines
513	535	if ((fsopt->flags & CEPH_MOUNT_OPT_DCACHE) == 0)
514	536	seq_puts(m, ",nodcache");
515	537	if (fsopt->flags & CEPH_MOUNT_OPT_FSCACHE) {
516		− if (fsopt->fscache_uniq)
517		− seq_printf(m, ",fsc=%s", fsopt->fscache_uniq);
518		− else
519		− seq_puts(m, ",fsc");
	538	+ seq_show_option(m, "fsc", fsopt->fscache_uniq);
520	539	}
521	540	if (fsopt->flags & CEPH_MOUNT_OPT_NOPOOLPERM)
522	541	seq_puts(m, ",nopoolperm");
	542	+ if (fsopt->flags & CEPH_MOUNT_OPT_NOQUOTADF)
	543	+ seq_puts(m, ",noquotadf");
523	544
524	545	#ifdef CONFIG_CEPH_FS_POSIX_ACL
525	546	if (fsopt->sb_flags & SB_POSIXACL)
@@ -529,7 +550,7 @@ static int ceph_show_options(struct seq_file m, struct dentry root) · 3 unmodified lines
529	550	#endif
530	551
531	552	if (fsopt->mds_namespace)
532		− seq_printf(m, ",mds_namespace=%s", fsopt->mds_namespace);
	553	+ seq_show_option(m, "mds_namespace", fsopt->mds_namespace);
533	554	if (fsopt->wsize)
534	555	seq_printf(m, ",wsize=%d", fsopt->wsize);
535	556	if (fsopt->rsize != CEPH_MAX_READ_SIZE)
@@ -679,6 +700,7 @@ struct kmem_cache *ceph_cap_cachep; · 143 unmodified lines
679	700	struct kmem_cache *ceph_cap_flush_cachep;
680	701	struct kmem_cache *ceph_dentry_cachep;
681	702	struct kmem_cache *ceph_file_cachep;
	703	+struct kmem_cache *ceph_dir_file_cachep;
682	704
683	705	static void ceph_inode_init_once(void *foo)
684	706	{
@@ -698,8 +720,7 @@ static int __init init_caches(void) · 13 unmodified lines
698	720	if (!ceph_inode_cachep)
699	721	return -ENOMEM;
700	722
701		− ceph_cap_cachep = KMEM_CACHE(ceph_cap,
702		− SLAB_RECLAIM_ACCOUNT\|SLAB_MEM_SPREAD);
	723	+ ceph_cap_cachep = KMEM_CACHE(ceph_cap, SLAB_MEM_SPREAD);
703	724	if (!ceph_cap_cachep)
704	725	goto bad_cap;
705	726	ceph_cap_flush_cachep = KMEM_CACHE(ceph_cap_flush,
@@ -716,6 +737,10 @@ static int __init init_caches(void) · 10 unmodified lines
716	737	if (!ceph_file_cachep)
717	738	goto bad_file;
718	739
	740	+ ceph_dir_file_cachep = KMEM_CACHE(ceph_dir_file_info, SLAB_MEM_SPREAD);
	741	+ if (!ceph_dir_file_cachep)
	742	+ goto bad_dir_file;
	743	+
719	744	error = ceph_fscache_register();
720	745	if (error)
721	746	goto bad_fscache;
@@ -723,6 +748,8 @@ static int __init init_caches(void) · 1 unmodified line
723	748	return 0;
724	749
725	750	bad_fscache:
	751	+ kmem_cache_destroy(ceph_dir_file_cachep);
	752	+bad_dir_file:
726	753	kmem_cache_destroy(ceph_file_cachep);
727	754	bad_file:
728	755	kmem_cache_destroy(ceph_dentry_cachep);
@@ -748,6 +775,7 @@ static void destroy_caches(void) · 19 unmodified lines
748	775	kmem_cache_destroy(ceph_cap_flush_cachep);
749	776	kmem_cache_destroy(ceph_dentry_cachep);
750	777	kmem_cache_destroy(ceph_file_cachep);
	778	+ kmem_cache_destroy(ceph_dir_file_cachep);
751	779
752	780	ceph_fscache_unregister();
753	781	}

fs/ceph/super.h+42−0

@@ -39,6 +39,7 @@ · 38 unmodified lines
39	39	#define CEPH_MOUNT_OPT_FSCACHE (1<<10) /* use fscache */
40	40	#define CEPH_MOUNT_OPT_NOPOOLPERM (1<<11) /* no pool permission check */
41	41	#define CEPH_MOUNT_OPT_MOUNTWAIT (1<<12) /* mount waits if no mds is up */
	42	+#define CEPH_MOUNT_OPT_NOQUOTADF (1<<13) /* no root dir quota in statfs */
42	43
43	44	#define CEPH_MOUNT_OPT_DEFAULT CEPH_MOUNT_OPT_DCACHE
44	45
@@ -310,6 +311,9 @@ struct ceph_inode_info { · 265 unmodified lines
310	311	u64 i_rbytes, i_rfiles, i_rsubdirs;
311	312	u64 i_files, i_subdirs;
312	313
	314	+ /* quotas */
	315	+ u64 i_max_bytes, i_max_files;
	316	+
313	317	struct rb_root i_fragtree;
314	318	int i_fragtree_nsplits;
315	319	struct mutex i_fragtree_mutex;
@@ -671,6 +675,10 @@ struct ceph_file_info { · 355 unmodified lines
671	675
672	676	spinlock_t rw_contexts_lock;
673	677	struct list_head rw_contexts;
	678	+};
	679	+
	680	+struct ceph_dir_file_info {
	681	+ struct ceph_file_info file_info;
674	682
675	683	/* readdir: position within the dir */
676	684	u32 frag;
@@ -748,6 +756,7 @@ struct ceph_readdir_cache_control { · 71 unmodified lines
748	756	*/
749	757	struct ceph_snap_realm {
750	758	u64 ino;
	759	+ struct inode *inode;
751	760	atomic_t nref;
752	761	struct rb_node node;
753	762
@@ -1066,4 +1075,37 @@ extern int ceph_locks_to_pagelist(struct ceph_filelock *flocks, · 312 unmodified lines
1066	1075	extern int ceph_fs_debugfs_init(struct ceph_fs_client *client);
1067	1076	extern void ceph_fs_debugfs_cleanup(struct ceph_fs_client *client);
1068	1077
	1078	+/* quota.c */
	1079	+static inline bool __ceph_has_any_quota(struct ceph_inode_info *ci)
	1080	+{
	1081	+ return ci->i_max_files \|\| ci->i_max_bytes;
	1082	+}
	1083	+
	1084	+extern void ceph_adjust_quota_realms_count(struct inode *inode, bool inc);
	1085	+
	1086	+static inline void __ceph_update_quota(struct ceph_inode_info *ci,
	1087	+ u64 max_bytes, u64 max_files)
	1088	+{
	1089	+ bool had_quota, has_quota;
	1090	+ had_quota = __ceph_has_any_quota(ci);
	1091	+ ci->i_max_bytes = max_bytes;
	1092	+ ci->i_max_files = max_files;
	1093	+ has_quota = __ceph_has_any_quota(ci);
	1094	+
	1095	+ if (had_quota != has_quota)
	1096	+ ceph_adjust_quota_realms_count(&ci->vfs_inode, has_quota);
	1097	+}
	1098	+
	1099	+extern void ceph_handle_quota(struct ceph_mds_client *mdsc,
	1100	+ struct ceph_mds_session *session,
	1101	+ struct ceph_msg *msg);
	1102	+extern bool ceph_quota_is_max_files_exceeded(struct inode *inode);
	1103	+extern bool ceph_quota_is_same_realm(struct inode old, struct inode new);
	1104	+extern bool ceph_quota_is_max_bytes_exceeded(struct inode *inode,
	1105	+ loff_t newlen);
	1106	+extern bool ceph_quota_is_max_bytes_approaching(struct inode *inode,
	1107	+ loff_t newlen);
	1108	+extern bool ceph_quota_update_statfs(struct ceph_fs_client *fsc,
	1109	+ struct kstatfs *buf);
	1110	+
1069	1111	#endif /* _FS_CEPH_SUPER_H */

fs/ceph/xattr.c+44−0

@@ -224,6 +224,31 @@ static size_t ceph_vxattrcb_dir_rctime(struct ceph_inode_info ci, char val, · 223 unmodified lines
224	224	(long)ci->i_rctime.tv_nsec);
225	225	}
226	226
	227	+/* quotas */
	228	+
	229	+static bool ceph_vxattrcb_quota_exists(struct ceph_inode_info *ci)
	230	+{
	231	+ return (ci->i_max_files \|\| ci->i_max_bytes);
	232	+}
	233	+
	234	+static size_t ceph_vxattrcb_quota(struct ceph_inode_info ci, char val,
	235	+ size_t size)
	236	+{
	237	+ return snprintf(val, size, "max_bytes=%llu max_files=%llu",
	238	+ ci->i_max_bytes, ci->i_max_files);
	239	+}
	240	+
	241	+static size_t ceph_vxattrcb_quota_max_bytes(struct ceph_inode_info *ci,
	242	+ char *val, size_t size)
	243	+{
	244	+ return snprintf(val, size, "%llu", ci->i_max_bytes);
	245	+}
	246	+
	247	+static size_t ceph_vxattrcb_quota_max_files(struct ceph_inode_info *ci,
	248	+ char *val, size_t size)
	249	+{
	250	+ return snprintf(val, size, "%llu", ci->i_max_files);
	251	+}
227	252
228	253	#define CEPH_XATTR_NAME(_type, _name) XATTR_CEPH_PREFIX #_type "." #_name
229	254	#define CEPH_XATTR_NAME2(_type, _name, _name2) \
@@ -247,6 +272,15 @@ static size_t ceph_vxattrcb_dir_rctime(struct ceph_inode_info ci, char val, · 17 unmodified lines
247	272	.hidden = true, \
248	273	.exists_cb = ceph_vxattrcb_layout_exists, \
249	274	}
	275	+#define XATTR_QUOTA_FIELD(_type, _name) \
	276	+ { \
	277	+ .name = CEPH_XATTR_NAME(_type, _name), \
	278	+ .name_size = sizeof(CEPH_XATTR_NAME(_type, _name)), \
	279	+ .getxattr_cb = ceph_vxattrcb_ ## _type ## _ ## _name, \
	280	+ .readonly = false, \
	281	+ .hidden = true, \
	282	+ .exists_cb = ceph_vxattrcb_quota_exists, \
	283	+ }
250	284
251	285	static struct ceph_vxattr ceph_dir_vxattrs[] = {
252	286	{
@@ -270,6 +304,16 @@ static struct ceph_vxattr ceph_dir_vxattrs[] = { · 17 unmodified lines
270	304	XATTR_NAME_CEPH(dir, rsubdirs),
271	305	XATTR_NAME_CEPH(dir, rbytes),
272	306	XATTR_NAME_CEPH(dir, rctime),
	307	+ {
	308	+ .name = "ceph.quota",
	309	+ .name_size = sizeof("ceph.quota"),
	310	+ .getxattr_cb = ceph_vxattrcb_quota,
	311	+ .readonly = false,
	312	+ .hidden = true,
	313	+ .exists_cb = ceph_vxattrcb_quota_exists,
	314	+ },
	315	+ XATTR_QUOTA_FIELD(quota, max_bytes),
	316	+ XATTR_QUOTA_FIELD(quota, max_files),
273	317	{ .name = NULL, 0 } /* Required table terminator */
274	318	};
275	319	static size_t ceph_dir_vxattrs_name_size; /* total size of all names */

include/linux/ceph/ceph_features.h+1−0

@@ -204,6 +204,7 @@ DEFINE_CEPH_FEATURE_DEPRECATED(63, 1, RESERVED_BROKEN, LUMINOUS) // client-facin · 203 unmodified lines
204	204	CEPH_FEATURE_OSD_PRIMARY_AFFINITY \| \
205	205	CEPH_FEATURE_MSGR_KEEPALIVE2 \| \
206	206	CEPH_FEATURE_OSD_POOLRESEND \| \
	207	+ CEPH_FEATURE_MDS_QUOTA \| \
207	208	CEPH_FEATURE_CRUSH_V4 \| \
208	209	CEPH_FEATURE_NEW_OSDOP_ENCODING \| \
209	210	CEPH_FEATURE_SERVER_JEWEL \| \

include/linux/ceph/ceph_fs.h+17−0

@@ -134,6 +134,7 @@ struct ceph_dir_layout { · 133 unmodified lines
134	134	#define CEPH_MSG_CLIENT_LEASE 0x311
135	135	#define CEPH_MSG_CLIENT_SNAP 0x312
136	136	#define CEPH_MSG_CLIENT_CAPRELEASE 0x313
	137	+#define CEPH_MSG_CLIENT_QUOTA 0x314
137	138
138	139	/* pool ops */
139	140	#define CEPH_MSG_POOLOP_REPLY 48
@@ -807,4 +808,20 @@ struct ceph_mds_snap_realm { · 667 unmodified lines
807	808	} __attribute__ ((packed));
808	809	/* followed by my snap list, then prior parent snap list */
809	810
	811	+/*
	812	+ * quotas
	813	+ */
	814	+struct ceph_mds_quota {
	815	+ __le64 ino; /* ino */
	816	+ struct ceph_timespec rctime;
	817	+ __le64 rbytes; /* dir stats */
	818	+ __le64 rfiles;
	819	+ __le64 rsubdirs;
	820	+ __u8 struct_v; /* compat */
	821	+ __u8 struct_compat;
	822	+ __le32 struct_len;
	823	+ __le64 max_bytes; /* quota max. bytes */
	824	+ __le64 max_files; /* quota max. files */
	825	+} __attribute__ ((packed));
	826	+
810	827	#endif

include/linux/ceph/libceph.h+1−0

@@ -262,6 +262,7 @@ extern struct kmem_cache *ceph_cap_cachep; · 261 unmodified lines
262	262	extern struct kmem_cache *ceph_cap_flush_cachep;
263	263	extern struct kmem_cache *ceph_dentry_cachep;
264	264	extern struct kmem_cache *ceph_file_cachep;
	265	+extern struct kmem_cache *ceph_dir_file_cachep;
265	266
266	267	/* ceph_common.c */
267	268	extern bool libceph_compatible(void *data);

include/linux/ceph/messenger.h+93−8

@@ -76,6 +76,7 @@ enum ceph_msg_data_type { · 75 unmodified lines
76	76	#ifdef CONFIG_BLOCK
77	77	CEPH_MSG_DATA_BIO, /* data source/destination is a bio list */
78	78	#endif /* CONFIG_BLOCK */
	79	+ CEPH_MSG_DATA_BVECS, /* data source/destination is a bio_vec array */
79	80	};
80	81
81	82	static __inline__ bool ceph_msg_data_type_valid(enum ceph_msg_data_type type)
@@ -87,22 +88,106 @@ static __inline__ bool ceph_msg_data_type_valid(enum ceph_msg_data_type type) · 5 unmodified lines
87	88	#ifdef CONFIG_BLOCK
88	89	case CEPH_MSG_DATA_BIO:
89	90	#endif /* CONFIG_BLOCK */
	91	+ case CEPH_MSG_DATA_BVECS:
90	92	return true;
91	93	default:
92	94	return false;
93	95	}
94	96	}
95	97
	98	+#ifdef CONFIG_BLOCK
	99	+
	100	+struct ceph_bio_iter {
	101	+ struct bio *bio;
	102	+ struct bvec_iter iter;
	103	+};
	104	+
	105	+#define __ceph_bio_iter_advance_step(it, n, STEP) do { \
	106	+ unsigned int __n = (n), __cur_n; \
	107	+ \
	108	+ while (__n) { \
	109	+ BUG_ON(!(it)->iter.bi_size); \
	110	+ __cur_n = min((it)->iter.bi_size, __n); \
	111	+ (void)(STEP); \
	112	+ bio_advance_iter((it)->bio, &(it)->iter, __cur_n); \
	113	+ if (!(it)->iter.bi_size && (it)->bio->bi_next) { \
	114	+ dout("__ceph_bio_iter_advance_step next bio\n"); \
	115	+ (it)->bio = (it)->bio->bi_next; \
	116	+ (it)->iter = (it)->bio->bi_iter; \
	117	+ } \
	118	+ __n -= __cur_n; \
	119	+ } \
	120	+} while (0)
	121	+
	122	+/*
	123	+ * Advance @it by @n bytes.
	124	+ */
	125	+#define ceph_bio_iter_advance(it, n) \
	126	+ __ceph_bio_iter_advance_step(it, n, 0)
	127	+
	128	+/*
	129	+ * Advance @it by @n bytes, executing BVEC_STEP for each bio_vec.
	130	+ */
	131	+#define ceph_bio_iter_advance_step(it, n, BVEC_STEP) \
	132	+ __ceph_bio_iter_advance_step(it, n, ({ \
	133	+ struct bio_vec bv; \
	134	+ struct bvec_iter __cur_iter; \
	135	+ \
	136	+ __cur_iter = (it)->iter; \
	137	+ __cur_iter.bi_size = __cur_n; \
	138	+ __bio_for_each_segment(bv, (it)->bio, __cur_iter, __cur_iter) \
	139	+ (void)(BVEC_STEP); \
	140	+ }))
	141	+
	142	+#endif /* CONFIG_BLOCK */
	143	+
	144	+struct ceph_bvec_iter {
	145	+ struct bio_vec *bvecs;
	146	+ struct bvec_iter iter;
	147	+};
	148	+
	149	+#define __ceph_bvec_iter_advance_step(it, n, STEP) do { \
	150	+ BUG_ON((n) > (it)->iter.bi_size); \
	151	+ (void)(STEP); \
	152	+ bvec_iter_advance((it)->bvecs, &(it)->iter, (n)); \
	153	+} while (0)
	154	+
	155	+/*
	156	+ * Advance @it by @n bytes.
	157	+ */
	158	+#define ceph_bvec_iter_advance(it, n) \
	159	+ __ceph_bvec_iter_advance_step(it, n, 0)
	160	+
	161	+/*
	162	+ * Advance @it by @n bytes, executing BVEC_STEP for each bio_vec.
	163	+ */
	164	+#define ceph_bvec_iter_advance_step(it, n, BVEC_STEP) \
	165	+ __ceph_bvec_iter_advance_step(it, n, ({ \
	166	+ struct bio_vec bv; \
	167	+ struct bvec_iter __cur_iter; \
	168	+ \
	169	+ __cur_iter = (it)->iter; \
	170	+ __cur_iter.bi_size = (n); \
	171	+ for_each_bvec(bv, (it)->bvecs, __cur_iter, __cur_iter) \
	172	+ (void)(BVEC_STEP); \
	173	+ }))
	174	+
	175	+#define ceph_bvec_iter_shorten(it, n) do { \
	176	+ BUG_ON((n) > (it)->iter.bi_size); \
	177	+ (it)->iter.bi_size = (n); \
	178	+} while (0)
	179	+
96	180	struct ceph_msg_data {
97	181	struct list_head links; /* ceph_msg->data */
98	182	enum ceph_msg_data_type type;
99	183	union {
100	184	#ifdef CONFIG_BLOCK
101	185	struct {
102		− struct bio *bio;
103		− size_t bio_length;
	186	+ struct ceph_bio_iter bio_pos;
	187	+ u32 bio_length;
104	188	};
105	189	#endif /* CONFIG_BLOCK */
	190	+ struct ceph_bvec_iter bvec_pos;
106	191	struct {
107	192	struct page *pages; / NOT OWNER. */
108	193	size_t length; /* total # bytes */
@@ -122,11 +207,9 @@ struct ceph_msg_data_cursor { · 13 unmodified lines
122	207	bool need_crc; /* crc update needed */
123	208	union {
124	209	#ifdef CONFIG_BLOCK
125		− struct { /* bio */
126		− struct bio bio; / bio from list */
127		− struct bvec_iter bvec_iter;
128		− };
	210	+ struct ceph_bio_iter bio_iter;
129	211	#endif /* CONFIG_BLOCK */
	212	+ struct bvec_iter bvec_iter;
130	213	struct { /* pages */
131	214	unsigned int page_offset; /* offset in page */
132	215	unsigned short page_index; /* index in array */
@@ -290,9 +373,11 @@ extern void ceph_msg_data_add_pages(struct ceph_msg msg, struct page *pages, · 157 unmodified lines
290	373	extern void ceph_msg_data_add_pagelist(struct ceph_msg *msg,
291	374	struct ceph_pagelist *pagelist);
292	375	#ifdef CONFIG_BLOCK
293		−extern void ceph_msg_data_add_bio(struct ceph_msg msg, struct bio bio,
294		− size_t length);
	376	+void ceph_msg_data_add_bio(struct ceph_msg msg, struct ceph_bio_iter bio_pos,
	377	+ u32 length);
295	378	#endif /* CONFIG_BLOCK */
	379	+void ceph_msg_data_add_bvecs(struct ceph_msg *msg,
	380	+ struct ceph_bvec_iter *bvec_pos);
296	381
297	382	extern struct ceph_msg *ceph_msg_new(int type, int front_len, gfp_t flags,
298	383	bool can_fail);

include/linux/ceph/osd_client.h+14−5

@@ -57,6 +57,7 @@ enum ceph_osd_data_type { · 56 unmodified lines
57	57	#ifdef CONFIG_BLOCK
58	58	CEPH_OSD_DATA_TYPE_BIO,
59	59	#endif /* CONFIG_BLOCK */
	60	+ CEPH_OSD_DATA_TYPE_BVECS,
60	61	};
61	62
62	63	struct ceph_osd_data {
@@ -72,10 +73,11 @@ struct ceph_osd_data { · 9 unmodified lines
72	73	struct ceph_pagelist *pagelist;
73	74	#ifdef CONFIG_BLOCK
74	75	struct {
75		− struct bio bio; / list of bios */
76		− size_t bio_length; /* total in list */
	76	+ struct ceph_bio_iter bio_pos;
	77	+ u32 bio_length;
77	78	};
78	79	#endif /* CONFIG_BLOCK */
	80	+ struct ceph_bvec_iter bvec_pos;
79	81	};
80	82	};
81	83
@@ -405,10 +407,14 @@ extern void osd_req_op_extent_osd_data_pagelist(struct ceph_osd_request *, · 323 unmodified lines
405	407	unsigned int which,
406	408	struct ceph_pagelist *pagelist);
407	409	#ifdef CONFIG_BLOCK
408		−extern void osd_req_op_extent_osd_data_bio(struct ceph_osd_request *,
409		− unsigned int which,
410		− struct bio *bio, size_t bio_length);
	410	+void osd_req_op_extent_osd_data_bio(struct ceph_osd_request *osd_req,
	411	+ unsigned int which,
	412	+ struct ceph_bio_iter *bio_pos,
	413	+ u32 bio_length);
411	414	#endif /* CONFIG_BLOCK */
	415	+void osd_req_op_extent_osd_data_bvec_pos(struct ceph_osd_request *osd_req,
	416	+ unsigned int which,
	417	+ struct ceph_bvec_iter *bvec_pos);
412	418
413	419	extern void osd_req_op_cls_request_data_pagelist(struct ceph_osd_request *,
414	420	unsigned int which,
@@ -418,6 +424,9 @@ extern void osd_req_op_cls_request_data_pages(struct ceph_osd_request *, · 3 unmodified lines
418	424	struct page **pages, u64 length,
419	425	u32 alignment, bool pages_from_pool,
420	426	bool own_pages);
	427	+void osd_req_op_cls_request_data_bvecs(struct ceph_osd_request *osd_req,
	428	+ unsigned int which,
	429	+ struct bio_vec *bvecs, u32 bytes);
421	430	extern void osd_req_op_cls_response_data_pages(struct ceph_osd_request *,
422	431	unsigned int which,
423	432	struct page **pages, u64 length,

include/linux/ceph/osdmap.h+0−6

@@ -5,7 +5,6 @@ · 4 unmodified lines
5	5	#include <linux/rbtree.h>
6	6	#include <linux/ceph/types.h>
7	7	#include <linux/ceph/decode.h>
8		−#include <linux/ceph/ceph_fs.h>
9	8	#include <linux/crush/crush.h>
10	9
11	10	/*
@@ -280,11 +279,6 @@ bool ceph_osds_changed(const struct ceph_osds *old_acting, · 268 unmodified lines
280	279	const struct ceph_osds *new_acting,
281	280	bool any_change);
282	281
283		−/* calculate mapping of a file extent to an object */
284		−extern int ceph_calc_file_object_mapping(struct ceph_file_layout *layout,
285		− u64 off, u64 len,
286		− u64 bno, u64 oxoff, u64 *oxlen);
287		−
288	282	int __ceph_object_locator_to_pg(struct ceph_pg_pool_info *pi,
289	283	const struct ceph_object_id *oid,
290	284	const struct ceph_object_locator *oloc,

include/linux/ceph/striper.h+69−0

@@ -0,0 +1,69 @@
	1	+/* SPDX-License-Identifier: GPL-2.0 */
	2	+#ifndef _LINUX_CEPH_STRIPER_H
	3	+#define _LINUX_CEPH_STRIPER_H
	4	+
	5	+#include <linux/list.h>
	6	+#include <linux/types.h>
	7	+
	8	+struct ceph_file_layout;
	9	+
	10	+void ceph_calc_file_object_mapping(struct ceph_file_layout *l,
	11	+ u64 off, u64 len,
	12	+ u64 objno, u64 objoff, u32 *xlen);
	13	+
	14	+struct ceph_object_extent {
	15	+ struct list_head oe_item;
	16	+ u64 oe_objno;
	17	+ u64 oe_off;
	18	+ u64 oe_len;
	19	+};
	20	+
	21	+static inline void ceph_object_extent_init(struct ceph_object_extent *ex)
	22	+{
	23	+ INIT_LIST_HEAD(&ex->oe_item);
	24	+}
	25	+
	26	+/*
	27	+ * Called for each mapped stripe unit.
	28	+ *
	29	+ * @bytes: number of bytes mapped, i.e. the minimum of the full length
	30	+ * requested (file extent length) or the remainder of the stripe
	31	+ * unit within an object
	32	+ */
	33	+typedef void (ceph_object_extent_fn_t)(struct ceph_object_extent ex,
	34	+ u32 bytes, void *arg);
	35	+
	36	+int ceph_file_to_extents(struct ceph_file_layout *l, u64 off, u64 len,
	37	+ struct list_head *object_extents,
	38	+ struct ceph_object_extent alloc_fn(void arg),
	39	+ void *alloc_arg,
	40	+ ceph_object_extent_fn_t action_fn,
	41	+ void *action_arg);
	42	+int ceph_iterate_extents(struct ceph_file_layout *l, u64 off, u64 len,
	43	+ struct list_head *object_extents,
	44	+ ceph_object_extent_fn_t action_fn,
	45	+ void *action_arg);
	46	+
	47	+struct ceph_file_extent {
	48	+ u64 fe_off;
	49	+ u64 fe_len;
	50	+};
	51	+
	52	+static inline u64 ceph_file_extents_bytes(struct ceph_file_extent *file_extents,
	53	+ u32 num_file_extents)
	54	+{
	55	+ u64 bytes = 0;
	56	+ u32 i;
	57	+
	58	+ for (i = 0; i < num_file_extents; i++)
	59	+ bytes += file_extents[i].fe_len;
	60	+
	61	+ return bytes;
	62	+}
	63	+
	64	+int ceph_extent_to_file(struct ceph_file_layout *l,
	65	+ u64 objno, u64 objoff, u64 objlen,
	66	+ struct ceph_file_extent **file_extents,
	67	+ u32 *num_file_extents);
	68	+
	69	+#endif

net/ceph/Makefile+1−0

@@ -8,6 +8,7 @@ libceph-y := ceph_common.o messenger.o msgpool.o buffer.o pagelist.o \ · 7 unmodified lines
8	8	mon_client.o \
9	9	cls_lock_client.o \
10	10	osd_client.o osdmap.o crush/crush.o crush/mapper.o crush/hash.o \
	11	+ striper.o \
11	12	debugfs.o \
12	13	auth.o auth_none.o \
13	14	crypto.o armor.o \

net/ceph/ceph_common.c+7−1

@@ -72,6 +72,7 @@ const char *ceph_msg_type_name(int type) · 71 unmodified lines
72	72	case CEPH_MSG_MON_GET_VERSION: return "mon_get_version";
73	73	case CEPH_MSG_MON_GET_VERSION_REPLY: return "mon_get_version_reply";
74	74	case CEPH_MSG_MDS_MAP: return "mds_map";
	75	+ case CEPH_MSG_FS_MAP_USER: return "fs_map_user";
75	76	case CEPH_MSG_CLIENT_SESSION: return "client_session";
76	77	case CEPH_MSG_CLIENT_RECONNECT: return "client_reconnect";
77	78	case CEPH_MSG_CLIENT_REQUEST: return "client_request";
@@ -79,8 +80,13 @@ const char *ceph_msg_type_name(int type) · 1 unmodified line
79	80	case CEPH_MSG_CLIENT_REPLY: return "client_reply";
80	81	case CEPH_MSG_CLIENT_CAPS: return "client_caps";
81	82	case CEPH_MSG_CLIENT_CAPRELEASE: return "client_cap_release";
	83	+ case CEPH_MSG_CLIENT_QUOTA: return "client_quota";
82	84	case CEPH_MSG_CLIENT_SNAP: return "client_snap";
83	85	case CEPH_MSG_CLIENT_LEASE: return "client_lease";
	86	+ case CEPH_MSG_POOLOP_REPLY: return "poolop_reply";
	87	+ case CEPH_MSG_POOLOP: return "poolop";
	88	+ case CEPH_MSG_MON_COMMAND: return "mon_command";
	89	+ case CEPH_MSG_MON_COMMAND_ACK: return "mon_command_ack";
84	90	case CEPH_MSG_OSD_MAP: return "osd_map";
85	91	case CEPH_MSG_OSD_OP: return "osd_op";
86	92	case CEPH_MSG_OSD_OPREPLY: return "osd_opreply";
@@ -217,7 +223,7 @@ static int parse_fsid(const char str, struct ceph_fsid fsid) · 130 unmodified lines
217	223
218	224	if (i == 16)
219	225	err = 0;
220		− dout("parse_fsid ret %d got fsid %pU", err, fsid);
	226	+ dout("parse_fsid ret %d got fsid %pU\n", err, fsid);
221	227	return err;
222	228	}
223	229

net/ceph/crypto.c+4−2

@@ -347,10 +347,12 @@ struct key_type key_type_ceph = { · 346 unmodified lines
347	347	.destroy = ceph_key_destroy,
348	348	};
349	349
350		−int ceph_crypto_init(void) {
	350	+int __init ceph_crypto_init(void)
	351	+{
351	352	return register_key_type(&key_type_ceph);
352	353	}
353	354
354		−void ceph_crypto_shutdown(void) {
	355	+void ceph_crypto_shutdown(void)
	356	+{
355	357	unregister_key_type(&key_type_ceph);
356	358	}

net/ceph/debugfs.c+7−10

@@ -389,7 +389,7 @@ CEPH_DEFINE_SHOW_FUNC(monc_show) · 388 unmodified lines
389	389	CEPH_DEFINE_SHOW_FUNC(osdc_show)
390	390	CEPH_DEFINE_SHOW_FUNC(client_options_show)
391	391
392		−int ceph_debugfs_init(void)
	392	+int __init ceph_debugfs_init(void)
393	393	{
394	394	ceph_debugfs_dir = debugfs_create_dir("ceph", NULL);
395	395	if (!ceph_debugfs_dir)
@@ -418,7 +418,7 @@ int ceph_debugfs_client_init(struct ceph_client *client) · 22 unmodified lines
418	418	goto out;
419	419
420	420	client->monc.debugfs_file = debugfs_create_file("monc",
421		− 0600,
	421	+ 0400,
422	422	client->debugfs_dir,
423	423	client,
424	424	&monc_show_fops);
@@ -426,7 +426,7 @@ int ceph_debugfs_client_init(struct ceph_client *client) · 1 unmodified line
426	426	goto out;
427	427
428	428	client->osdc.debugfs_file = debugfs_create_file("osdc",
429		− 0600,
	429	+ 0400,
430	430	client->debugfs_dir,
431	431	client,
432	432	&osdc_show_fops);
@@ -434,7 +434,7 @@ int ceph_debugfs_client_init(struct ceph_client *client) · 1 unmodified line
434	434	goto out;
435	435
436	436	client->debugfs_monmap = debugfs_create_file("monmap",
437		− 0600,
	437	+ 0400,
438	438	client->debugfs_dir,
439	439	client,
440	440	&monmap_show_fops);
@@ -442,7 +442,7 @@ int ceph_debugfs_client_init(struct ceph_client *client) · 1 unmodified line
442	442	goto out;
443	443
444	444	client->debugfs_osdmap = debugfs_create_file("osdmap",
445		− 0600,
	445	+ 0400,
446	446	client->debugfs_dir,
447	447	client,
448	448	&osdmap_show_fops);
@@ -450,7 +450,7 @@ int ceph_debugfs_client_init(struct ceph_client *client) · 1 unmodified line
450	450	goto out;
451	451
452	452	client->debugfs_options = debugfs_create_file("client_options",
453		− 0600,
	453	+ 0400,
454	454	client->debugfs_dir,
455	455	client,
456	456	&client_options_show_fops);
@@ -477,7 +477,7 @@ void ceph_debugfs_client_cleanup(struct ceph_client *client) · 20 unmodified lines
477	477
478	478	#else /* CONFIG_DEBUG_FS */
479	479
480		−int ceph_debugfs_init(void)
	480	+int __init ceph_debugfs_init(void)
481	481	{
482	482	return 0;
483	483	}
@@ -496,6 +496,3 @@ void ceph_debugfs_client_cleanup(struct ceph_client *client) · 12 unmodified lines
496	496	}
497	497
498	498	#endif /* CONFIG_DEBUG_FS */
499		−
500		−EXPORT_SYMBOL(ceph_debugfs_init);
501		−EXPORT_SYMBOL(ceph_debugfs_cleanup);

net/ceph/messenger.c+119−69

@@ -277,7 +277,7 @@ static void _ceph_msgr_exit(void) · 276 unmodified lines
277	277	ceph_msgr_slab_exit();
278	278	}
279	279
280		−int ceph_msgr_init(void)
	280	+int __init ceph_msgr_init(void)
281	281	{
282	282	if (ceph_msgr_slab_init())
283	283	return -ENOMEM;
@@ -299,7 +299,6 @@ int ceph_msgr_init(void) · 15 unmodified lines
299	299
300	300	return -ENOMEM;
301	301	}
302		−EXPORT_SYMBOL(ceph_msgr_init);
303	302
304	303	void ceph_msgr_exit(void)
305	304	{
@@ -307,7 +306,6 @@ void ceph_msgr_exit(void) · 1 unmodified line
307	306
308	307	_ceph_msgr_exit();
309	308	}
310		−EXPORT_SYMBOL(ceph_msgr_exit);
311	309
312	310	void ceph_msgr_flush(void)
313	311	{
@@ -839,93 +837,112 @@ static void ceph_msg_data_bio_cursor_init(struct ceph_msg_data_cursor *cursor, · 525 unmodified lines
839	837	size_t length)
840	838	{
841	839	struct ceph_msg_data *data = cursor->data;
842		− struct bio *bio;
	840	+ struct ceph_bio_iter *it = &cursor->bio_iter;
843	841
844		− BUG_ON(data->type != CEPH_MSG_DATA_BIO);
	842	+ cursor->resid = min_t(size_t, length, data->bio_length);
	843	+ *it = data->bio_pos;
	844	+ if (cursor->resid < it->iter.bi_size)
	845	+ it->iter.bi_size = cursor->resid;
845	846
846		− bio = data->bio;
847		− BUG_ON(!bio);
848		−
849		− cursor->resid = min(length, data->bio_length);
850		− cursor->bio = bio;
851		− cursor->bvec_iter = bio->bi_iter;
852		− cursor->last_piece =
853		− cursor->resid <= bio_iter_len(bio, cursor->bvec_iter);
	847	+ BUG_ON(cursor->resid < bio_iter_len(it->bio, it->iter));
	848	+ cursor->last_piece = cursor->resid == bio_iter_len(it->bio, it->iter);
854	849	}
855	850
856	851	static struct page ceph_msg_data_bio_next(struct ceph_msg_data_cursor cursor,
857	852	size_t *page_offset,
858	853	size_t *length)
859	854	{
860		− struct ceph_msg_data *data = cursor->data;
861		− struct bio *bio;
862		− struct bio_vec bio_vec;
863		−
864		− BUG_ON(data->type != CEPH_MSG_DATA_BIO);
865		−
866		− bio = cursor->bio;
867		− BUG_ON(!bio);
868		−
869		− bio_vec = bio_iter_iovec(bio, cursor->bvec_iter);
870		−
871		− *page_offset = (size_t) bio_vec.bv_offset;
872		− BUG_ON(*page_offset >= PAGE_SIZE);
873		− if (cursor->last_piece) /* pagelist offset is always 0 */
874		− *length = cursor->resid;
875		− else
876		− *length = (size_t) bio_vec.bv_len;
877		− BUG_ON(*length > cursor->resid);
878		− BUG_ON(page_offset + length > PAGE_SIZE);
	855	+ struct bio_vec bv = bio_iter_iovec(cursor->bio_iter.bio,
	856	+ cursor->bio_iter.iter);
879	857
880		− return bio_vec.bv_page;
	858	+ *page_offset = bv.bv_offset;
	859	+ *length = bv.bv_len;
	860	+ return bv.bv_page;
881	861	}
882	862
883	863	static bool ceph_msg_data_bio_advance(struct ceph_msg_data_cursor *cursor,
884	864	size_t bytes)
885	865	{
886		− struct bio *bio;
887		− struct bio_vec bio_vec;
	866	+ struct ceph_bio_iter *it = &cursor->bio_iter;
888	867
889		− BUG_ON(cursor->data->type != CEPH_MSG_DATA_BIO);
	868	+ BUG_ON(bytes > cursor->resid);
	869	+ BUG_ON(bytes > bio_iter_len(it->bio, it->iter));
	870	+ cursor->resid -= bytes;
	871	+ bio_advance_iter(it->bio, &it->iter, bytes);
890	872
891		− bio = cursor->bio;
892		− BUG_ON(!bio);
	873	+ if (!cursor->resid) {
	874	+ BUG_ON(!cursor->last_piece);
	875	+ return false; /* no more data */
	876	+ }
893	877
894		− bio_vec = bio_iter_iovec(bio, cursor->bvec_iter);
	878	+ if (!bytes \|\| (it->iter.bi_size && it->iter.bi_bvec_done))
	879	+ return false; /* more bytes to process in this segment */
895	880
896		− /* Advance the cursor offset */
	881	+ if (!it->iter.bi_size) {
	882	+ it->bio = it->bio->bi_next;
	883	+ it->iter = it->bio->bi_iter;
	884	+ if (cursor->resid < it->iter.bi_size)
	885	+ it->iter.bi_size = cursor->resid;
	886	+ }
897	887
898		− BUG_ON(cursor->resid < bytes);
899		− cursor->resid -= bytes;
	888	+ BUG_ON(cursor->last_piece);
	889	+ BUG_ON(cursor->resid < bio_iter_len(it->bio, it->iter));
	890	+ cursor->last_piece = cursor->resid == bio_iter_len(it->bio, it->iter);
	891	+ return true;
	892	+}
	893	+#endif /* CONFIG_BLOCK */
900	894
901		− bio_advance_iter(bio, &cursor->bvec_iter, bytes);
	895	+static void ceph_msg_data_bvecs_cursor_init(struct ceph_msg_data_cursor *cursor,
	896	+ size_t length)
	897	+{
	898	+ struct ceph_msg_data *data = cursor->data;
	899	+ struct bio_vec *bvecs = data->bvec_pos.bvecs;
902	900
903		− if (bytes < bio_vec.bv_len)
904		− return false; /* more bytes to process in this segment */
	901	+ cursor->resid = min_t(size_t, length, data->bvec_pos.iter.bi_size);
	902	+ cursor->bvec_iter = data->bvec_pos.iter;
	903	+ cursor->bvec_iter.bi_size = cursor->resid;
905	904
906		− /* Move on to the next segment, and possibly the next bio */
	905	+ BUG_ON(cursor->resid < bvec_iter_len(bvecs, cursor->bvec_iter));
	906	+ cursor->last_piece =
	907	+ cursor->resid == bvec_iter_len(bvecs, cursor->bvec_iter);
	908	+}
907	909
908		− if (!cursor->bvec_iter.bi_size) {
909		− bio = bio->bi_next;
910		− cursor->bio = bio;
911		− if (bio)
912		− cursor->bvec_iter = bio->bi_iter;
913		− else
914		− memset(&cursor->bvec_iter, 0,
915		− sizeof(cursor->bvec_iter));
916		− }
	910	+static struct page ceph_msg_data_bvecs_next(struct ceph_msg_data_cursor cursor,
	911	+ size_t *page_offset,
	912	+ size_t *length)
	913	+{
	914	+ struct bio_vec bv = bvec_iter_bvec(cursor->data->bvec_pos.bvecs,
	915	+ cursor->bvec_iter);
	916	+
	917	+ *page_offset = bv.bv_offset;
	918	+ *length = bv.bv_len;
	919	+ return bv.bv_page;
	920	+}
	921	+
	922	+static bool ceph_msg_data_bvecs_advance(struct ceph_msg_data_cursor *cursor,
	923	+ size_t bytes)
	924	+{
	925	+ struct bio_vec *bvecs = cursor->data->bvec_pos.bvecs;
	926	+
	927	+ BUG_ON(bytes > cursor->resid);
	928	+ BUG_ON(bytes > bvec_iter_len(bvecs, cursor->bvec_iter));
	929	+ cursor->resid -= bytes;
	930	+ bvec_iter_advance(bvecs, &cursor->bvec_iter, bytes);
917	931
918		− if (!cursor->last_piece) {
919		− BUG_ON(!cursor->resid);
920		− BUG_ON(!bio);
921		− /* A short read is OK, so use <= rather than == */
922		− if (cursor->resid <= bio_iter_len(bio, cursor->bvec_iter))
923		− cursor->last_piece = true;
	932	+ if (!cursor->resid) {
	933	+ BUG_ON(!cursor->last_piece);
	934	+ return false; /* no more data */
924	935	}
925	936
	937	+ if (!bytes \|\| cursor->bvec_iter.bi_bvec_done)
	938	+ return false; /* more bytes to process in this segment */
	939	+
	940	+ BUG_ON(cursor->last_piece);
	941	+ BUG_ON(cursor->resid < bvec_iter_len(bvecs, cursor->bvec_iter));
	942	+ cursor->last_piece =
	943	+ cursor->resid == bvec_iter_len(bvecs, cursor->bvec_iter);
926	944	return true;
927	945	}
928		−#endif /* CONFIG_BLOCK */
929	946
930	947	/*
931	948	* For a page array, a piece comes from the first page in the array
@@ -1110,6 +1127,9 @@ static void __ceph_msg_data_cursor_init(struct ceph_msg_data_cursor *cursor) · 178 unmodified lines
1110	1127	ceph_msg_data_bio_cursor_init(cursor, length);
1111	1128	break;
1112	1129	#endif /* CONFIG_BLOCK */
	1130	+ case CEPH_MSG_DATA_BVECS:
	1131	+ ceph_msg_data_bvecs_cursor_init(cursor, length);
	1132	+ break;
1113	1133	case CEPH_MSG_DATA_NONE:
1114	1134	default:
1115	1135	/* BUG(); */
@@ -1158,14 +1178,19 @@ static struct page ceph_msg_data_next(struct ceph_msg_data_cursor cursor, · 42 unmodified lines
1158	1178	page = ceph_msg_data_bio_next(cursor, page_offset, length);
1159	1179	break;
1160	1180	#endif /* CONFIG_BLOCK */
	1181	+ case CEPH_MSG_DATA_BVECS:
	1182	+ page = ceph_msg_data_bvecs_next(cursor, page_offset, length);
	1183	+ break;
1161	1184	case CEPH_MSG_DATA_NONE:
1162	1185	default:
1163	1186	page = NULL;
1164	1187	break;
1165	1188	}
	1189	+
1166	1190	BUG_ON(!page);
1167	1191	BUG_ON(page_offset + length > PAGE_SIZE);
1168	1192	BUG_ON(!*length);
	1193	+ BUG_ON(*length > cursor->resid);
1169	1194	if (last_piece)
1170	1195	*last_piece = cursor->last_piece;
1171	1196
@@ -1194,6 +1219,9 @@ static void ceph_msg_data_advance(struct ceph_msg_data_cursor *cursor, · 22 unmodified lines
1194	1219	new_piece = ceph_msg_data_bio_advance(cursor, bytes);
1195	1220	break;
1196	1221	#endif /* CONFIG_BLOCK */
	1222	+ case CEPH_MSG_DATA_BVECS:
	1223	+ new_piece = ceph_msg_data_bvecs_advance(cursor, bytes);
	1224	+ break;
1197	1225	case CEPH_MSG_DATA_NONE:
1198	1226	default:
1199	1227	BUG();
@@ -1575,13 +1603,18 @@ static int write_partial_message_data(struct ceph_connection *con) · 375 unmodified lines
1575	1603	* been revoked, so use the zero page.
1576	1604	*/
1577	1605	crc = do_datacrc ? le32_to_cpu(msg->footer.data_crc) : 0;
1578		− while (cursor->resid) {
	1606	+ while (cursor->total_resid) {
1579	1607	struct page *page;
1580	1608	size_t page_offset;
1581	1609	size_t length;
1582	1610	bool last_piece;
1583	1611	int ret;
1584	1612
	1613	+ if (!cursor->resid) {
	1614	+ ceph_msg_data_advance(cursor, 0);
	1615	+ continue;
	1616	+ }
	1617	+
1585	1618	page = ceph_msg_data_next(cursor, &page_offset, &length,
1586	1619	&last_piece);
1587	1620	ret = ceph_tcp_sendpage(con->sock, page, page_offset,
@@ -2297,7 +2330,12 @@ static int read_partial_msg_data(struct ceph_connection *con) · 709 unmodified lines
2297	2330
2298	2331	if (do_datacrc)
2299	2332	crc = con->in_data_crc;
2300		− while (cursor->resid) {
	2333	+ while (cursor->total_resid) {
	2334	+ if (!cursor->resid) {
	2335	+ ceph_msg_data_advance(cursor, 0);
	2336	+ continue;
	2337	+ }
	2338	+
2301	2339	page = ceph_msg_data_next(cursor, &page_offset, &length, NULL);
2302	2340	ret = ceph_tcp_recvpage(con->sock, page, page_offset, length);
2303	2341	if (ret <= 0) {
@@ -3262,16 +3300,14 @@ void ceph_msg_data_add_pagelist(struct ceph_msg *msg, · 958 unmodified lines
3262	3300	EXPORT_SYMBOL(ceph_msg_data_add_pagelist);
3263	3301
3264	3302	#ifdef CONFIG_BLOCK
3265		−void ceph_msg_data_add_bio(struct ceph_msg msg, struct bio bio,
3266		− size_t length)
	3303	+void ceph_msg_data_add_bio(struct ceph_msg msg, struct ceph_bio_iter bio_pos,
	3304	+ u32 length)
3267	3305	{
3268	3306	struct ceph_msg_data *data;
3269	3307
3270		− BUG_ON(!bio);
3271		−
3272	3308	data = ceph_msg_data_create(CEPH_MSG_DATA_BIO);
3273	3309	BUG_ON(!data);
3274		− data->bio = bio;
	3310	+ data->bio_pos = *bio_pos;
3275	3311	data->bio_length = length;
3276	3312
3277	3313	list_add_tail(&data->links, &msg->data);
@@ -3280,6 +3316,20 @@ void ceph_msg_data_add_bio(struct ceph_msg msg, struct bio bio, · 2 unmodified lines
3280	3316	EXPORT_SYMBOL(ceph_msg_data_add_bio);
3281	3317	#endif /* CONFIG_BLOCK */
3282	3318
	3319	+void ceph_msg_data_add_bvecs(struct ceph_msg *msg,
	3320	+ struct ceph_bvec_iter *bvec_pos)
	3321	+{
	3322	+ struct ceph_msg_data *data;
	3323	+
	3324	+ data = ceph_msg_data_create(CEPH_MSG_DATA_BVECS);
	3325	+ BUG_ON(!data);
	3326	+ data->bvec_pos = *bvec_pos;
	3327	+
	3328	+ list_add_tail(&data->links, &msg->data);
	3329	+ msg->data_length += bvec_pos->iter.bi_size;
	3330	+}
	3331	+EXPORT_SYMBOL(ceph_msg_data_add_bvecs);
	3332	+
3283	3333	/*
3284	3334	* construct a new message with given type, size
3285	3335	* the new msg has a ref count of 1.

net/ceph/mon_client.c+1−1

@@ -60,7 +60,7 @@ struct ceph_monmap ceph_monmap_decode(void p, void *end) · 59 unmodified lines
60	60	num_mon = ceph_decode_32(&p);
61	61	ceph_decode_need(&p, end, num_mon*sizeof(m->mon_inst[0]), bad);
62	62
63		− if (num_mon >= CEPH_MAX_MON)
	63	+ if (num_mon > CEPH_MAX_MON)
64	64	goto bad;
65	65	m = kmalloc(sizeof(m) + sizeof(m->mon_inst[0])num_mon, GFP_NOFS);
66	66	if (m == NULL)

net/ceph/osd_client.c+53−14

@@ -20,6 +20,7 @@ · 19 unmodified lines
20	20	#include <linux/ceph/decode.h>
21	21	#include <linux/ceph/auth.h>
22	22	#include <linux/ceph/pagelist.h>
	23	+#include <linux/ceph/striper.h>
23	24
24	25	#define OSD_OPREPLY_FRONT_LEN 512
25	26
@@ -103,13 +104,12 @@ static int calc_layout(struct ceph_file_layout layout, u64 off, u64 plen, · 77 unmodified lines
103	104	u64 objnum, u64 objoff, u64 *objlen)
104	105	{
105	106	u64 orig_len = *plen;
106		− int r;
	107	+ u32 xlen;
107	108
108	109	/* object extent? */
109		− r = ceph_calc_file_object_mapping(layout, off, orig_len, objnum,
110		− objoff, objlen);
111		− if (r < 0)
112		− return r;
	110	+ ceph_calc_file_object_mapping(layout, off, orig_len, objnum,
	111	+ objoff, &xlen);
	112	+ *objlen = xlen;
113	113	if (*objlen < orig_len) {
114	114	plen = objlen;
115	115	dout(" skipping last %llu, final file extent %llu~%llu\n",
@@ -117,7 +117,6 @@ static int calc_layout(struct ceph_file_layout layout, u64 off, u64 plen, · 1 unmodified line
117	117	}
118	118
119	119	dout("calc_layout objnum=%llx %llu~%llu\n", objnum, objoff, *objlen);
120		−
121	120	return 0;
122	121	}
123	122
@@ -148,14 +147,22 @@ static void ceph_osd_data_pagelist_init(struct ceph_osd_data *osd_data, · 24 unmodified lines
148	147
149	148	#ifdef CONFIG_BLOCK
150	149	static void ceph_osd_data_bio_init(struct ceph_osd_data *osd_data,
151		− struct bio *bio, size_t bio_length)
	150	+ struct ceph_bio_iter *bio_pos,
	151	+ u32 bio_length)
152	152	{
153	153	osd_data->type = CEPH_OSD_DATA_TYPE_BIO;
154		− osd_data->bio = bio;
	154	+ osd_data->bio_pos = *bio_pos;
155	155	osd_data->bio_length = bio_length;
156	156	}
157	157	#endif /* CONFIG_BLOCK */
158	158
	159	+static void ceph_osd_data_bvecs_init(struct ceph_osd_data *osd_data,
	160	+ struct ceph_bvec_iter *bvec_pos)
	161	+{
	162	+ osd_data->type = CEPH_OSD_DATA_TYPE_BVECS;
	163	+ osd_data->bvec_pos = *bvec_pos;
	164	+}
	165	+
159	166	#define osd_req_op_data(oreq, whch, typ, fld) \
160	167	({ \
161	168	struct ceph_osd_request *__oreq = (oreq); \
@@ -218,16 +225,29 @@ EXPORT_SYMBOL(osd_req_op_extent_osd_data_pagelist); · 56 unmodified lines
218	225
219	226	#ifdef CONFIG_BLOCK
220	227	void osd_req_op_extent_osd_data_bio(struct ceph_osd_request *osd_req,
221		− unsigned int which, struct bio *bio, size_t bio_length)
	228	+ unsigned int which,
	229	+ struct ceph_bio_iter *bio_pos,
	230	+ u32 bio_length)
222	231	{
223	232	struct ceph_osd_data *osd_data;
224	233
225	234	osd_data = osd_req_op_data(osd_req, which, extent, osd_data);
226		− ceph_osd_data_bio_init(osd_data, bio, bio_length);
	235	+ ceph_osd_data_bio_init(osd_data, bio_pos, bio_length);
227	236	}
228	237	EXPORT_SYMBOL(osd_req_op_extent_osd_data_bio);
229	238	#endif /* CONFIG_BLOCK */
230	239
	240	+void osd_req_op_extent_osd_data_bvec_pos(struct ceph_osd_request *osd_req,
	241	+ unsigned int which,
	242	+ struct ceph_bvec_iter *bvec_pos)
	243	+{
	244	+ struct ceph_osd_data *osd_data;
	245	+
	246	+ osd_data = osd_req_op_data(osd_req, which, extent, osd_data);
	247	+ ceph_osd_data_bvecs_init(osd_data, bvec_pos);
	248	+}
	249	+EXPORT_SYMBOL(osd_req_op_extent_osd_data_bvec_pos);
	250	+
231	251	static void osd_req_op_cls_request_info_pagelist(
232	252	struct ceph_osd_request *osd_req,
233	253	unsigned int which, struct ceph_pagelist *pagelist)
@@ -265,6 +285,23 @@ void osd_req_op_cls_request_data_pages(struct ceph_osd_request *osd_req, · 31 unmodified lines
265	285	}
266	286	EXPORT_SYMBOL(osd_req_op_cls_request_data_pages);
267	287
	288	+void osd_req_op_cls_request_data_bvecs(struct ceph_osd_request *osd_req,
	289	+ unsigned int which,
	290	+ struct bio_vec *bvecs, u32 bytes)
	291	+{
	292	+ struct ceph_osd_data *osd_data;
	293	+ struct ceph_bvec_iter it = {
	294	+ .bvecs = bvecs,
	295	+ .iter = { .bi_size = bytes },
	296	+ };
	297	+
	298	+ osd_data = osd_req_op_data(osd_req, which, cls, request_data);
	299	+ ceph_osd_data_bvecs_init(osd_data, &it);
	300	+ osd_req->r_ops[which].cls.indata_len += bytes;
	301	+ osd_req->r_ops[which].indata_len += bytes;
	302	+}
	303	+EXPORT_SYMBOL(osd_req_op_cls_request_data_bvecs);
	304	+
268	305	void osd_req_op_cls_response_data_pages(struct ceph_osd_request *osd_req,
269	306	unsigned int which, struct page **pages, u64 length,
270	307	u32 alignment, bool pages_from_pool, bool own_pages)
@@ -290,6 +327,8 @@ static u64 ceph_osd_data_length(struct ceph_osd_data *osd_data) · 19 unmodified lines
290	327	case CEPH_OSD_DATA_TYPE_BIO:
291	328	return (u64)osd_data->bio_length;
292	329	#endif /* CONFIG_BLOCK */
	330	+ case CEPH_OSD_DATA_TYPE_BVECS:
	331	+ return osd_data->bvec_pos.iter.bi_size;
293	332	default:
294	333	WARN(true, "unrecognized data type %d\n", (int)osd_data->type);
295	334	return 0;
@@ -828,8 +867,10 @@ static void ceph_osdc_msg_data_add(struct ceph_msg *msg, · 532 unmodified lines
828	867	ceph_msg_data_add_pagelist(msg, osd_data->pagelist);
829	868	#ifdef CONFIG_BLOCK
830	869	} else if (osd_data->type == CEPH_OSD_DATA_TYPE_BIO) {
831		− ceph_msg_data_add_bio(msg, osd_data->bio, length);
	870	+ ceph_msg_data_add_bio(msg, &osd_data->bio_pos, length);
832	871	#endif
	872	+ } else if (osd_data->type == CEPH_OSD_DATA_TYPE_BVECS) {
	873	+ ceph_msg_data_add_bvecs(msg, &osd_data->bvec_pos);
833	874	} else {
834	875	BUG_ON(osd_data->type != CEPH_OSD_DATA_TYPE_NONE);
835	876	}
@@ -5065,7 +5106,7 @@ int ceph_osdc_writepages(struct ceph_osd_client *osdc, struct ceph_vino vino, · 4229 unmodified lines
5065	5106	}
5066	5107	EXPORT_SYMBOL(ceph_osdc_writepages);
5067	5108
5068		−int ceph_osdc_setup(void)
	5109	+int __init ceph_osdc_setup(void)
5069	5110	{
5070	5111	size_t size = sizeof(struct ceph_osd_request) +
5071	5112	CEPH_OSD_SLAB_OPS * sizeof(struct ceph_osd_req_op);
@@ -5076,7 +5117,6 @@ int ceph_osdc_setup(void) · 4 unmodified lines
5076	5117
5077	5118	return ceph_osd_request_cache ? 0 : -ENOMEM;
5078	5119	}
5079		−EXPORT_SYMBOL(ceph_osdc_setup);
5080	5120
5081	5121	void ceph_osdc_cleanup(void)
5082	5122	{
@@ -5084,7 +5124,6 @@ void ceph_osdc_cleanup(void) · 1 unmodified line
5084	5124	kmem_cache_destroy(ceph_osd_request_cache);
5085	5125	ceph_osd_request_cache = NULL;
5086	5126	}
5087		−EXPORT_SYMBOL(ceph_osdc_cleanup);
5088	5127
5089	5128	/*
5090	5129	* handle incoming message

net/ceph/osdmap.c+0−71

@@ -4,7 +4,6 @@ · 3 unmodified lines
4	4
5	5	#include <linux/module.h>
6	6	#include <linux/slab.h>
7		−#include <asm/div64.h>
8	7
9	8	#include <linux/ceph/libceph.h>
10	9	#include <linux/ceph/osdmap.h>
@@ -2140,76 +2139,6 @@ bool ceph_osds_changed(const struct ceph_osds *old_acting, · 2129 unmodified lines
2140	2139	return false;
2141	2140	}
2142	2141
2143		−/*
2144		− * calculate file layout from given offset, length.
2145		− * fill in correct oid, logical length, and object extent
2146		− * offset, length.
2147		− *
2148		− * for now, we write only a single su, until we can
2149		− * pass a stride back to the caller.
2150		− */
2151		−int ceph_calc_file_object_mapping(struct ceph_file_layout *layout,
2152		− u64 off, u64 len,
2153		− u64 *ono,
2154		− u64 oxoff, u64 oxlen)
2155		−{
2156		− u32 osize = layout->object_size;
2157		− u32 su = layout->stripe_unit;
2158		− u32 sc = layout->stripe_count;
2159		− u32 bl, stripeno, stripepos, objsetno;
2160		− u32 su_per_object;
2161		− u64 t, su_offset;
2162		−
2163		− dout("mapping %llu~%llu osize %u fl_su %u\n", off, len,
2164		− osize, su);
2165		− if (su == 0 \|\| sc == 0)
2166		− goto invalid;
2167		− su_per_object = osize / su;
2168		− if (su_per_object == 0)
2169		− goto invalid;
2170		− dout("osize %u / su %u = su_per_object %u\n", osize, su,
2171		− su_per_object);
2172		−
2173		− if ((su & ~PAGE_MASK) != 0)
2174		− goto invalid;
2175		−
2176		− /* bl = off / su; /
2177		− t = off;
2178		− do_div(t, su);
2179		− bl = t;
2180		− dout("off %llu / su %u = bl %u\n", off, su, bl);
2181		−
2182		− stripeno = bl / sc;
2183		− stripepos = bl % sc;
2184		− objsetno = stripeno / su_per_object;
2185		−
2186		− ono = objsetno sc + stripepos;
2187		− dout("objset %u * sc %u = ono %u\n", objsetno, sc, (unsigned int)*ono);
2188		−
2189		− /* oxoff = off % layout->fl_stripe_unit; # offset in su */
2190		− t = off;
2191		− su_offset = do_div(t, su);
2192		− oxoff = su_offset + (stripeno % su_per_object) su;
2193		−
2194		− /*
2195		− * Calculate the length of the extent being written to the selected
2196		− * object. This is the minimum of the full length requested (len) or
2197		− * the remainder of the current stripe being written to.
2198		− */
2199		− *oxlen = min_t(u64, len, su - su_offset);
2200		−
2201		− dout(" obj extent %llu~%llu\n", oxoff, oxlen);
2202		− return 0;
2203		−
2204		−invalid:
2205		− dout(" invalid layout\n");
2206		− *ono = 0;
2207		− *oxoff = 0;
2208		− *oxlen = 0;
2209		− return -EINVAL;
2210		−}
2211		−EXPORT_SYMBOL(ceph_calc_file_object_mapping);
2212		−
2213	2142	/*
2214	2143	* Map an object into a PG.
2215	2144	*

net/ceph/striper.c+261−0

@@ -0,0 +1,261 @@
	1	+/* SPDX-License-Identifier: GPL-2.0 */
	2	+
	3	+#include <linux/ceph/ceph_debug.h>
	4	+
	5	+#include <linux/math64.h>
	6	+#include <linux/slab.h>
	7	+
	8	+#include <linux/ceph/striper.h>
	9	+#include <linux/ceph/types.h>
	10	+
	11	+/*
	12	+ * Map a file extent to a stripe unit within an object.
	13	+ * Fill in objno, offset into object, and object extent length (i.e. the
	14	+ * number of bytes mapped, less than or equal to @l->stripe_unit).
	15	+ *
	16	+ * Example for stripe_count = 3, stripes_per_object = 4:
	17	+ *
	18	+ * blockno \| 0 3 6 9 \| 1 4 7 10 \| 2 5 8 11 \| 12 15 18 21 \| 13 16 19
	19	+ * stripeno \| 0 1 2 3 \| 0 1 2 3 \| 0 1 2 3 \| 4 5 6 7 \| 4 5 6
	20	+ * stripepos \| 0 \| 1 \| 2 \| 0 \| 1
	21	+ * objno \| 0 \| 1 \| 2 \| 3 \| 4
	22	+ * objsetno \| 0 \| 1
	23	+ */
	24	+void ceph_calc_file_object_mapping(struct ceph_file_layout *l,
	25	+ u64 off, u64 len,
	26	+ u64 objno, u64 objoff, u32 *xlen)
	27	+{
	28	+ u32 stripes_per_object = l->object_size / l->stripe_unit;
	29	+ u64 blockno; /* which su in the file (i.e. globally) */
	30	+ u32 blockoff; /* offset into su */
	31	+ u64 stripeno; /* which stripe */
	32	+ u32 stripepos; /* which su in the stripe,
	33	+ which object in the object set */
	34	+ u64 objsetno; /* which object set */
	35	+ u32 objsetpos; /* which stripe in the object set */
	36	+
	37	+ blockno = div_u64_rem(off, l->stripe_unit, &blockoff);
	38	+ stripeno = div_u64_rem(blockno, l->stripe_count, &stripepos);
	39	+ objsetno = div_u64_rem(stripeno, stripes_per_object, &objsetpos);
	40	+
	41	+ objno = objsetno l->stripe_count + stripepos;
	42	+ objoff = objsetpos l->stripe_unit + blockoff;
	43	+ *xlen = min_t(u64, len, l->stripe_unit - blockoff);
	44	+}
	45	+EXPORT_SYMBOL(ceph_calc_file_object_mapping);
	46	+
	47	+/*
	48	+ * Return the last extent with given objno (@object_extents is sorted
	49	+ * by objno). If not found, return NULL and set @add_pos so that the
	50	+ * new extent can be added with list_add(add_pos, new_ex).
	51	+ */
	52	+static struct ceph_object_extent *
	53	+lookup_last(struct list_head *object_extents, u64 objno,
	54	+ struct list_head **add_pos)
	55	+{
	56	+ struct list_head *pos;
	57	+
	58	+ list_for_each_prev(pos, object_extents) {
	59	+ struct ceph_object_extent *ex =
	60	+ list_entry(pos, typeof(*ex), oe_item);
	61	+
	62	+ if (ex->oe_objno == objno)
	63	+ return ex;
	64	+
	65	+ if (ex->oe_objno < objno)
	66	+ break;
	67	+ }
	68	+
	69	+ *add_pos = pos;
	70	+ return NULL;
	71	+}
	72	+
	73	+static struct ceph_object_extent *
	74	+lookup_containing(struct list_head *object_extents, u64 objno,
	75	+ u64 objoff, u32 xlen)
	76	+{
	77	+ struct ceph_object_extent *ex;
	78	+
	79	+ list_for_each_entry(ex, object_extents, oe_item) {
	80	+ if (ex->oe_objno == objno &&
	81	+ ex->oe_off <= objoff &&
	82	+ ex->oe_off + ex->oe_len >= objoff + xlen) /* paranoia */
	83	+ return ex;
	84	+
	85	+ if (ex->oe_objno > objno)
	86	+ break;
	87	+ }
	88	+
	89	+ return NULL;
	90	+}
	91	+
	92	+/*
	93	+ * Map a file extent to a sorted list of object extents.
	94	+ *
	95	+ * We want only one (or as few as possible) object extents per object.
	96	+ * Adjacent object extents will be merged together, each returned object
	97	+ * extent may reverse map to multiple different file extents.
	98	+ *
	99	+ * Call @alloc_fn for each new object extent and @action_fn for each
	100	+ * mapped stripe unit, whether it was merged into an already allocated
	101	+ * object extent or started a new object extent.
	102	+ *
	103	+ * Newly allocated object extents are added to @object_extents.
	104	+ * To keep @object_extents sorted, successive calls to this function
	105	+ * must map successive file extents (i.e. the list of file extents that
	106	+ * are mapped using the same @object_extents must be sorted).
	107	+ *
	108	+ * The caller is responsible for @object_extents.
	109	+ */
	110	+int ceph_file_to_extents(struct ceph_file_layout *l, u64 off, u64 len,
	111	+ struct list_head *object_extents,
	112	+ struct ceph_object_extent alloc_fn(void arg),
	113	+ void *alloc_arg,
	114	+ ceph_object_extent_fn_t action_fn,
	115	+ void *action_arg)
	116	+{
	117	+ struct ceph_object_extent last_ex, ex;
	118	+
	119	+ while (len) {
	120	+ struct list_head *add_pos = NULL;
	121	+ u64 objno, objoff;
	122	+ u32 xlen;
	123	+
	124	+ ceph_calc_file_object_mapping(l, off, len, &objno, &objoff,
	125	+ &xlen);
	126	+
	127	+ last_ex = lookup_last(object_extents, objno, &add_pos);
	128	+ if (!last_ex \|\| last_ex->oe_off + last_ex->oe_len != objoff) {
	129	+ ex = alloc_fn(alloc_arg);
	130	+ if (!ex)
	131	+ return -ENOMEM;
	132	+
	133	+ ex->oe_objno = objno;
	134	+ ex->oe_off = objoff;
	135	+ ex->oe_len = xlen;
	136	+ if (action_fn)
	137	+ action_fn(ex, xlen, action_arg);
	138	+
	139	+ if (!last_ex)
	140	+ list_add(&ex->oe_item, add_pos);
	141	+ else
	142	+ list_add(&ex->oe_item, &last_ex->oe_item);
	143	+ } else {
	144	+ last_ex->oe_len += xlen;
	145	+ if (action_fn)
	146	+ action_fn(last_ex, xlen, action_arg);
	147	+ }
	148	+
	149	+ off += xlen;
	150	+ len -= xlen;
	151	+ }
	152	+
	153	+ for (last_ex = list_first_entry(object_extents, typeof(*ex), oe_item),
	154	+ ex = list_next_entry(last_ex, oe_item);
	155	+ &ex->oe_item != object_extents;
	156	+ last_ex = ex, ex = list_next_entry(ex, oe_item)) {
	157	+ if (last_ex->oe_objno > ex->oe_objno \|\|
	158	+ (last_ex->oe_objno == ex->oe_objno &&
	159	+ last_ex->oe_off + last_ex->oe_len >= ex->oe_off)) {
	160	+ WARN(1, "%s: object_extents list not sorted!\n",
	161	+ __func__);
	162	+ return -EINVAL;
	163	+ }
	164	+ }
	165	+
	166	+ return 0;
	167	+}
	168	+EXPORT_SYMBOL(ceph_file_to_extents);
	169	+
	170	+/*
	171	+ * A stripped down, non-allocating version of ceph_file_to_extents(),
	172	+ * for when @object_extents is already populated.
	173	+ */
	174	+int ceph_iterate_extents(struct ceph_file_layout *l, u64 off, u64 len,
	175	+ struct list_head *object_extents,
	176	+ ceph_object_extent_fn_t action_fn,
	177	+ void *action_arg)
	178	+{
	179	+ while (len) {
	180	+ struct ceph_object_extent *ex;
	181	+ u64 objno, objoff;
	182	+ u32 xlen;
	183	+
	184	+ ceph_calc_file_object_mapping(l, off, len, &objno, &objoff,
	185	+ &xlen);
	186	+
	187	+ ex = lookup_containing(object_extents, objno, objoff, xlen);
	188	+ if (!ex) {
	189	+ WARN(1, "%s: objno %llu %llu~%u not found!\n",
	190	+ __func__, objno, objoff, xlen);
	191	+ return -EINVAL;
	192	+ }
	193	+
	194	+ action_fn(ex, xlen, action_arg);
	195	+
	196	+ off += xlen;
	197	+ len -= xlen;
	198	+ }
	199	+
	200	+ return 0;
	201	+}
	202	+EXPORT_SYMBOL(ceph_iterate_extents);
	203	+
	204	+/*
	205	+ * Reverse map an object extent to a sorted list of file extents.
	206	+ *
	207	+ * On success, the caller is responsible for:
	208	+ *
	209	+ * kfree(file_extents)
	210	+ */
	211	+int ceph_extent_to_file(struct ceph_file_layout *l,
	212	+ u64 objno, u64 objoff, u64 objlen,
	213	+ struct ceph_file_extent **file_extents,
	214	+ u32 *num_file_extents)
	215	+{
	216	+ u32 stripes_per_object = l->object_size / l->stripe_unit;
	217	+ u64 blockno; /* which su */
	218	+ u32 blockoff; /* offset into su */
	219	+ u64 stripeno; /* which stripe */
	220	+ u32 stripepos; /* which su in the stripe,
	221	+ which object in the object set */
	222	+ u64 objsetno; /* which object set */
	223	+ u32 i = 0;
	224	+
	225	+ if (!objlen) {
	226	+ *file_extents = NULL;
	227	+ *num_file_extents = 0;
	228	+ return 0;
	229	+ }
	230	+
	231	+ *num_file_extents = DIV_ROUND_UP_ULL(objoff + objlen, l->stripe_unit) -
	232	+ DIV_ROUND_DOWN_ULL(objoff, l->stripe_unit);
	233	+ file_extents = kmalloc_array(num_file_extents, sizeof(**file_extents),
	234	+ GFP_NOIO);
	235	+ if (!*file_extents)
	236	+ return -ENOMEM;
	237	+
	238	+ div_u64_rem(objoff, l->stripe_unit, &blockoff);
	239	+ while (objlen) {
	240	+ u64 off, len;
	241	+
	242	+ objsetno = div_u64_rem(objno, l->stripe_count, &stripepos);
	243	+ stripeno = div_u64(objoff, l->stripe_unit) +
	244	+ objsetno * stripes_per_object;
	245	+ blockno = stripeno * l->stripe_count + stripepos;
	246	+ off = blockno * l->stripe_unit + blockoff;
	247	+ len = min_t(u64, objlen, l->stripe_unit - blockoff);
	248	+
	249	+ (*file_extents)[i].fe_off = off;
	250	+ (*file_extents)[i].fe_len = len;
	251	+
	252	+ blockoff = 0;
	253	+ objoff += len;
	254	+ objlen -= len;
	255	+ i++;
	256	+ }
	257	+
	258	+ BUG_ON(i != *num_file_extents);
	259	+ return 0;
	260	+}
	261	+EXPORT_SYMBOL(ceph_extent_to_file);

Merge tag 'ceph-for-4.17-rc1' of git://github.com/ceph/ceph-client

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code