lael-labs/linux

Documentation/filesystems/ceph.txt+14−0

@@ -158,6 +158,20 @@ Mount Options · 157 unmodified lines
158	copies. Currently, it's only used in copy_file_range, which will revert	158	copies. Currently, it's only used in copy_file_range, which will revert
159	to the default VFS implementation if this option is used.	159	to the default VFS implementation if this option is used.
160		160
		161	recover_session=<no\|clean>
		162	Set auto reconnect mode in the case where the client is blacklisted. The
		163	available modes are "no" and "clean". The default is "no".
		164
		165	* no: never attempt to reconnect when client detects that it has been
		166	blacklisted. Operations will generally fail after being blacklisted.
		167
		168	* clean: client reconnects to the ceph cluster automatically when it
		169	detects that it has been blacklisted. During reconnect, client drops
		170	dirty data/metadata, invalidates page caches and writable file handles.
		171	After reconnect, file locks become stale because the MDS loses track
		172	of them. If an inode contains any stale file locks, read/write on the
		173	inode is not allowed until applications release all stale file locks.
		174
161	More Information	175	More Information
162	================	176	================
163		177

drivers/block/rbd.c+12−6

 	mutex_init(&img_request->state_mutex);
 	kref_init(&img_request->kref);
-	dout("%s: rbd_dev %p %s -> img %p\n", __func__, rbd_dev,
-	     obj_op_name(op_type), img_request);
 	return img_request;
 }
 	__set_bit(IMG_REQ_CHILD, &child_img_req->flags);
 	child_img_req->obj_request = obj_req;
+	dout("%s child_img_req %p for obj_req %p\n", __func__, child_img_req,
+	     obj_req);
 	if (!rbd_img_is_write(img_req)) {
 		switch (img_req->data_type) {
 		case OBJ_REQUEST_BIO:
 	img_request->rq = rq;
 	snapc = NULL; /* img_request consumes a ref */
+	dout("%s rbd_dev %p img_req %p %s %llu~%llu\n", __func__, rbd_dev,
+	     img_request, obj_op_name(op_type), offset, length);
 	if (op_type == OBJ_OP_DISCARD || op_type == OBJ_OP_ZEROOUT)
 		result = rbd_img_fill_nodata(img_request, offset, length);
 	else
 static int rbd_dev_v2_object_prefix(struct rbd_device *rbd_dev)
 {
+	size_t size;
 	void *reply_buf;
 	int ret;
 	void *p;
-	reply_buf = kzalloc(RBD_OBJ_PREFIX_LEN_MAX, GFP_KERNEL);
+	/* Response will be an encoded string, which includes a length */
+	size = sizeof(__le32) + RBD_OBJ_PREFIX_LEN_MAX;
+	reply_buf = kzalloc(size, GFP_KERNEL);
 	if (!reply_buf)
 		return -ENOMEM;
 	ret = rbd_obj_method_sync(rbd_dev, &rbd_dev->header_oid,
 				  &rbd_dev->header_oloc, "get_object_prefix",
-				  NULL, 0, reply_buf, RBD_OBJ_PREFIX_LEN_MAX);
+				  NULL, 0, reply_buf, size);
 	dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
 	if (ret < 0)
 		goto out;
 	dout("rbd id object name is %s\n", oid.name);
 	/* Response will be an encoded string, which includes a length */
 	size = sizeof (__le32) + RBD_IMAGE_ID_LEN_MAX;
 	response = kzalloc(size, GFP_NOIO);
 	if (!response) {
 	ret = rbd_obj_method_sync(rbd_dev, &oid, &rbd_dev->header_oloc,
 				  "get_id", NULL, 0,
-				  response, RBD_IMAGE_ID_LEN_MAX);
+				  response, size);
 	dout("%s: rbd_obj_method_sync returned %d\n", __func__, ret);
 	if (ret == -ENOENT) {
 		image_id = kstrdup("", GFP_KERNEL);

fs/ceph/Makefile+1−1

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

fs/ceph/addr.c+30−31

 {
 	struct inode *inode = file_inode(filp);
 	struct ceph_inode_info *ci = ceph_inode(inode);
-	struct ceph_osd_client *osdc =
+	struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
-		&ceph_inode_to_client(inode)->client->osdc;
 	int err = 0;
 	u64 off = page_offset(page);
 	u64 len = PAGE_SIZE;
 	dout("readpage inode %p file %p page %p index %lu\n",
 	     inode, filp, page, page->index);
-	err = ceph_osdc_readpages(osdc, ceph_vino(inode), &ci->i_layout,
+	err = ceph_osdc_readpages(&fsc->client->osdc, ceph_vino(inode),
-				  off, &len,
+				  &ci->i_layout, off, &len,
 				  ci->i_truncate_seq, ci->i_truncate_size,
 				  &page, 1, 0);
 	if (err == -ENOENT)
 	if (err < 0) {
 		SetPageError(page);
 		ceph_fscache_readpage_cancel(inode, page);
+		if (err == -EBLACKLISTED)
+			fsc->blacklisted = true;
 		goto out;
 	}
 	if (err < PAGE_SIZE)
 	int i;
 	dout("finish_read %p req %p rc %d bytes %d\n", inode, req, rc, bytes);
+	if (rc == -EBLACKLISTED)
+		ceph_inode_to_client(inode)->blacklisted = true;
 	/* unlock all pages, zeroing any data we didn't read */
 	osd_data = osd_req_op_extent_osd_data(req, 0);
 		/* caller of readpages does not hold buffer and read caps
 		 * (fadvise, madvise and readahead cases) */
 		int want = CEPH_CAP_FILE_CACHE;
-		ret = ceph_try_get_caps(ci, CEPH_CAP_FILE_RD, want, true, &got);
+		ret = ceph_try_get_caps(inode, CEPH_CAP_FILE_RD, want,
+					true, &got);
 		if (ret < 0) {
 			dout("start_read %p, error getting cap\n", inode);
 		} else if (!(got & want)) {
 /*
  * Write a single page, but leave the page locked.
  *
- * If we get a write error, set the page error bit, but still adjust the
+ * If we get a write error, mark the mapping for error, but still adjust the
  * dirty page accounting (i.e., page is no longer dirty).
  */
 static int writepage_nounlock(struct page *page, struct writeback_control *wbc)
 			end_page_writeback(page);
 			return err;
 		}
+		if (err == -EBLACKLISTED)
+			fsc->blacklisted = true;
 		dout("writepage setting page/mapping error %d %p\n",
 		     err, page);
-		SetPageError(page);
 		mapping_set_error(&inode->i_data, err);
 		wbc->pages_skipped++;
 	} else {
 	return err;
 }
-/*
- * lame release_pages helper.  release_pages() isn't exported to
- * modules.
- */
-static void ceph_release_pages(struct page **pages, int num)
-{
-	struct pagevec pvec;
-	int i;
-	pagevec_init(&pvec);
-	for (i = 0; i < num; i++) {
-		if (pagevec_add(&pvec, pages[i]) == 0)
-			pagevec_release(&pvec);
-	}
-	pagevec_release(&pvec);
-}
 /*
  * async writeback completion handler.
  *
 	if (rc < 0) {
 		mapping_set_error(mapping, rc);
 		ceph_set_error_write(ci);
+		if (rc == -EBLACKLISTED)
+			fsc->blacklisted = true;
 	} else {
 		ceph_clear_error_write(ci);
 	}
 		dout("writepages_finish %p wrote %llu bytes cleaned %d pages\n",
 		     inode, osd_data->length, rc >= 0 ? num_pages : 0);
-		ceph_release_pages(osd_data->pages, num_pages);
+		release_pages(osd_data->pages, num_pages);
 	}
 	ceph_put_wrbuffer_cap_refs(ci, total_pages, snapc);
 		want = CEPH_CAP_FILE_CACHE;
 	got = 0;
-	err = ceph_get_caps(ci, CEPH_CAP_FILE_RD, want, -1, &got, &pinned_page);
+	err = ceph_get_caps(vma->vm_file, CEPH_CAP_FILE_RD, want, -1,
+			    &got, &pinned_page);
 	if (err < 0)
 		goto out_restore;
 	if (!prealloc_cf)
 		return VM_FAULT_OOM;
+	sb_start_pagefault(inode->i_sb);
 	ceph_block_sigs(&oldset);
 	if (ci->i_inline_version != CEPH_INLINE_NONE) {
 		want = CEPH_CAP_FILE_BUFFER;
 	got = 0;
-	err = ceph_get_caps(ci, CEPH_CAP_FILE_WR, want, off + len,
+	err = ceph_get_caps(vma->vm_file, CEPH_CAP_FILE_WR, want, off + len,
 			    &got, NULL);
 	if (err < 0)
 		goto out_free;
 	ceph_put_cap_refs(ci, got);
 out_free:
 	ceph_restore_sigs(&oldset);
+	sb_end_pagefault(inode->i_sb);
 	ceph_free_cap_flush(prealloc_cf);
 	if (err < 0)
 		ret = vmf_error(err);
 	if (err >= 0 || err == -ENOENT)
 		have |= POOL_READ;
-	else if (err != -EPERM)
+	else if (err != -EPERM) {
+		if (err == -EBLACKLISTED)
+			fsc->blacklisted = true;
 		goto out_unlock;
+	}
 	if (err2 == 0 || err2 == -EEXIST)
 		have |= POOL_WRITE;
 	else if (err2 != -EPERM) {
+		if (err2 == -EBLACKLISTED)
+			fsc->blacklisted = true;
 		err = err2;
 		goto out_unlock;
 	}
 	return err;
 }
-int ceph_pool_perm_check(struct ceph_inode_info *ci, int need)
+int ceph_pool_perm_check(struct inode *inode, int need)
 {
-	s64 pool;
+	struct ceph_inode_info *ci = ceph_inode(inode);
 	struct ceph_string *pool_ns;
+	s64 pool;
 	int ret, flags;
 	if (ci->i_vino.snap != CEPH_NOSNAP) {
 		return 0;
 	}
-	if (ceph_test_mount_opt(ceph_inode_to_client(&ci->vfs_inode),
+	if (ceph_test_mount_opt(ceph_inode_to_client(inode),
 				NOPOOLPERM))
 		return 0;

fs/ceph/cache.c+2−0

@@ -6,6 +6,8 @@ · 5 unmodified lines
6	* Written by Milosz Tanski (milosz@adfin.com)	6	* Written by Milosz Tanski (milosz@adfin.com)
7	*/	7	*/
8		8
		9	#include <linux/ceph/ceph_debug.h>
		10
9	#include "super.h"	11	#include "super.h"
10	#include "cache.h"	12	#include "cache.h"
11		13

fs/ceph/caps.c+88−85

 	return cap;
 }
-/*
- * Return id of any MDS with a cap, preferably FILE_WR|BUFFER|EXCL, else -1.
- */
-static int __ceph_get_cap_mds(struct ceph_inode_info *ci)
-{
-	struct ceph_cap *cap;
-	int mds = -1;
-	struct rb_node *p;
-	/* prefer mds with WR|BUFFER|EXCL caps */
-	for (p = rb_first(&ci->i_caps); p; p = rb_next(p)) {
-		cap = rb_entry(p, struct ceph_cap, ci_node);
-		mds = cap->mds;
-		if (cap->issued & (CEPH_CAP_FILE_WR |
-				   CEPH_CAP_FILE_BUFFER |
-				   CEPH_CAP_FILE_EXCL))
-			break;
-	}
-	return mds;
-}
-int ceph_get_cap_mds(struct inode *inode)
-{
-	struct ceph_inode_info *ci = ceph_inode(inode);
-	int mds;
-	spin_lock(&ci->i_ceph_lock);
-	mds = __ceph_get_cap_mds(ceph_inode(inode));
-	spin_unlock(&ci->i_ceph_lock);
-	return mds;
-}
 /*
  * Called under i_ceph_lock.
  */
 /*
  * Add a capability under the given MDS session.
  *
- * Caller should hold session snap_rwsem (read) and s_mutex.
+ * Caller should hold session snap_rwsem (read) and ci->i_ceph_lock
  *
  * @fmode is the open file mode, if we are opening a file, otherwise
  * it is < 0.  (This is so we can atomically add the cap and add an
 	struct ceph_cap *cap;
 	int mds = session->s_mds;
 	int actual_wanted;
+	u32 gen;
+	lockdep_assert_held(&ci->i_ceph_lock);
 	dout("add_cap %p mds%d cap %llx %s seq %d\n", inode,
 	     session->s_mds, cap_id, ceph_cap_string(issued), seq);
 	if (fmode >= 0)
 		wanted |= ceph_caps_for_mode(fmode);
+	spin_lock(&session->s_gen_ttl_lock);
+	gen = session->s_cap_gen;
+	spin_unlock(&session->s_gen_ttl_lock);
 	cap = __get_cap_for_mds(ci, mds);
 	if (!cap) {
 		cap = *new_cap;
 		list_move_tail(&cap->session_caps, &session->s_caps);
 		spin_unlock(&session->s_cap_lock);
-		if (cap->cap_gen < session->s_cap_gen)
+		if (cap->cap_gen < gen)
 			cap->issued = cap->implemented = CEPH_CAP_PIN;
 		/*
 	cap->seq = seq;
 	cap->issue_seq = seq;
 	cap->mseq = mseq;
-	cap->cap_gen = session->s_cap_gen;
+	cap->cap_gen = gen;
 	if (fmode >= 0)
 		__ceph_get_fmode(ci, fmode);
  * Make note of max_size reported/requested from mds, revoked caps
  * that have now been implemented.
  *
- * Make half-hearted attempt ot to invalidate page cache if we are
- * dropping RDCACHE.  Note that this will leave behind locked pages
- * that we'll then need to deal with elsewhere.
- *
  * Return non-zero if delayed release, or we experienced an error
  * such that the caller should requeue + retry later.
  *
  * Add dirty inode to the flushing list.  Assigned a seq number so we
  * can wait for caps to flush without starving.
  *
- * Called under i_ceph_lock.
+ * Called under i_ceph_lock. Returns the flush tid.
  */
-static int __mark_caps_flushing(struct inode *inode,
+static u64 __mark_caps_flushing(struct inode *inode,
 				struct ceph_mds_session *session, bool wake,
-				u64 *flush_tid, u64 *oldest_flush_tid)
+				u64 *oldest_flush_tid)
 {
 	struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
 	struct ceph_inode_info *ci = ceph_inode(inode);
 	list_add_tail(&cf->i_list, &ci->i_cap_flush_list);
-	*flush_tid = cf->tid;
+	return cf->tid;
-	return flushing;
 }
 /*
 		}
 ack:
-		if (ci->i_ceph_flags & CEPH_I_NOFLUSH) {
-			dout(" skipping %p I_NOFLUSH set\n", inode);
-			continue;
-		}
 		if (session && session != cap->session) {
 			dout("oops, wrong session %p mutex\n", session);
 			mutex_unlock(&session->s_mutex);
 		}
 		if (cap == ci->i_auth_cap && ci->i_dirty_caps) {
-			flushing = __mark_caps_flushing(inode, session, false,
+			flushing = ci->i_dirty_caps;
-							&flush_tid,
+			flush_tid = __mark_caps_flushing(inode, session, false,
-							&oldest_flush_tid);
+							 &oldest_flush_tid);
 		} else {
 			flushing = 0;
 			flush_tid = 0;
 retry:
 	spin_lock(&ci->i_ceph_lock);
 retry_locked:
-	if (ci->i_ceph_flags & CEPH_I_NOFLUSH) {
-		spin_unlock(&ci->i_ceph_lock);
-		dout("try_flush_caps skipping %p I_NOFLUSH set\n", inode);
-		goto out;
-	}
 	if (ci->i_dirty_caps && ci->i_auth_cap) {
 		struct ceph_cap *cap = ci->i_auth_cap;
 		int delayed;
-		if (!session || session != cap->session) {
+		if (session != cap->session) {
 			spin_unlock(&ci->i_ceph_lock);
 			if (session)
 				mutex_unlock(&session->s_mutex);
 			goto retry_locked;
 		}
-		flushing = __mark_caps_flushing(inode, session, true,
+		flushing = ci->i_dirty_caps;
-						&flush_tid, &oldest_flush_tid);
+		flush_tid = __mark_caps_flushing(inode, session, true,
+						 &oldest_flush_tid);
 		/* __send_cap drops i_ceph_lock */
 		delayed = __send_cap(mdsc, cap, CEPH_CAP_OP_FLUSH,
 int ceph_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
+	struct ceph_file_info *fi = file->private_data;
 	struct inode *inode = file->f_mapping->host;
 	struct ceph_inode_info *ci = ceph_inode(inode);
 	u64 flush_tid;
-	int ret;
+	int ret, err;
 	int dirty;
 	dout("fsync %p%s\n", inode, datasync ? " datasync" : "");
 	ret = file_write_and_wait_range(file, start, end);
-	if (ret < 0)
-		goto out;
 	if (datasync)
 		goto out;
 	dirty = try_flush_caps(inode, &flush_tid);
 	dout("fsync dirty caps are %s\n", ceph_cap_string(dirty));
-	ret = unsafe_request_wait(inode);
+	err = unsafe_request_wait(inode);
 	/*
 	 * only wait on non-file metadata writeback (the mds
 	 * can recover size and mtime, so we don't need to
 	 * wait for that)
 	 */
-	if (!ret && (dirty & ~CEPH_CAP_ANY_FILE_WR)) {
+	if (!err && (dirty & ~CEPH_CAP_ANY_FILE_WR)) {
-		ret = wait_event_interruptible(ci->i_cap_wq,
+		err = wait_event_interruptible(ci->i_cap_wq,
 					caps_are_flushed(inode, flush_tid));
 	}
+	if (err < 0)
+		ret = err;
+	if (errseq_check(&ci->i_meta_err, READ_ONCE(fi->meta_err))) {
+		spin_lock(&file->f_lock);
+		err = errseq_check_and_advance(&ci->i_meta_err,
+					       &fi->meta_err);
+		spin_unlock(&file->f_lock);
+		if (err < 0)
+			ret = err;
+	}
 out:
 	dout("fsync %p%s result=%d\n", inode, datasync ? " datasync" : "", ret);
 	return ret;
  *
  * FIXME: how does a 0 return differ from -EAGAIN?
  */
-static int try_get_cap_refs(struct ceph_inode_info *ci, int need, int want,
+enum {
-			    loff_t endoff, bool nonblock, int *got)
+	NON_BLOCKING	= 1,
+	CHECK_FILELOCK	= 2,
+};
+static int try_get_cap_refs(struct inode *inode, int need, int want,
+			    loff_t endoff, int flags, int *got)
 {
-	struct inode *inode = &ci->vfs_inode;
+	struct ceph_inode_info *ci = ceph_inode(inode);
 	struct ceph_mds_client *mdsc = ceph_inode_to_client(inode)->mdsc;
 	int ret = 0;
 	int have, implemented;
 again:
 	spin_lock(&ci->i_ceph_lock);
+	if ((flags & CHECK_FILELOCK) &&
+	    (ci->i_ceph_flags & CEPH_I_ERROR_FILELOCK)) {
+		dout("try_get_cap_refs %p error filelock\n", inode);
+		ret = -EIO;
+		goto out_unlock;
+	}
 	/* make sure file is actually open */
 	file_wanted = __ceph_caps_file_wanted(ci);
 	if ((file_wanted & need) != need) {
 					 * we can not call down_read() when
 					 * task isn't in TASK_RUNNING state
 					 */
-					if (nonblock) {
+					if (flags & NON_BLOCKING) {
 						ret = -EAGAIN;
 						goto out_unlock;
 					}
 		ceph_check_caps(ci, CHECK_CAPS_AUTHONLY, NULL);
 }
-int ceph_try_get_caps(struct ceph_inode_info *ci, int need, int want,
+int ceph_try_get_caps(struct inode *inode, int need, int want,
 		      bool nonblock, int *got)
 {
 	int ret;
 	BUG_ON(need & ~CEPH_CAP_FILE_RD);
 	BUG_ON(want & ~(CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO|CEPH_CAP_FILE_SHARED));
-	ret = ceph_pool_perm_check(ci, need);
+	ret = ceph_pool_perm_check(inode, need);
 	if (ret < 0)
 		return ret;
-	ret = try_get_cap_refs(ci, need, want, 0, nonblock, got);
+	ret = try_get_cap_refs(inode, need, want, 0,
+			       (nonblock ? NON_BLOCKING : 0), got);
 	return ret == -EAGAIN ? 0 : ret;
 }
  * due to a small max_size, make sure we check_max_size (and possibly
  * ask the mds) so we don't get hung up indefinitely.
  */
-int ceph_get_caps(struct ceph_inode_info *ci, int need, int want,
+int ceph_get_caps(struct file *filp, int need, int want,
 		  loff_t endoff, int *got, struct page **pinned_page)
 {
-	int _got, ret;
+	struct ceph_file_info *fi = filp->private_data;
+	struct inode *inode = file_inode(filp);
+	struct ceph_inode_info *ci = ceph_inode(inode);
+	struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
+	int ret, _got, flags;
-	ret = ceph_pool_perm_check(ci, need);
+	ret = ceph_pool_perm_check(inode, need);
 	if (ret < 0)
 		return ret;
+	if ((fi->fmode & CEPH_FILE_MODE_WR) &&
+	    fi->filp_gen != READ_ONCE(fsc->filp_gen))
+		return -EBADF;
 	while (true) {
 		if (endoff > 0)
-			check_max_size(&ci->vfs_inode, endoff);
+			check_max_size(inode, endoff);
+		flags = atomic_read(&fi->num_locks) ? CHECK_FILELOCK : 0;
 		_got = 0;
-		ret = try_get_cap_refs(ci, need, want, endoff,
+		ret = try_get_cap_refs(inode, need, want, endoff,
-				       false, &_got);
+				       flags, &_got);
 		if (ret == -EAGAIN)
 			continue;
 		if (!ret) {
 			DEFINE_WAIT_FUNC(wait, woken_wake_function);
 			add_wait_queue(&ci->i_cap_wq, &wait);
-			while (!(ret = try_get_cap_refs(ci, need, want, endoff,
+			flags |= NON_BLOCKING;
-							true, &_got))) {
+			while (!(ret = try_get_cap_refs(inode, need, want,
+							endoff, flags, &_got))) {
 				if (signal_pending(current)) {
 					ret = -ERESTARTSYS;
 					break;
 			if (ret == -EAGAIN)
 				continue;
 		}
+		if ((fi->fmode & CEPH_FILE_MODE_WR) &&
+		    fi->filp_gen != READ_ONCE(fsc->filp_gen)) {
+			if (ret >= 0 && _got)
+				ceph_put_cap_refs(ci, _got);
+			return -EBADF;
+		}
 		if (ret < 0) {
 			if (ret == -ESTALE) {
 				/* session was killed, try renew caps */
-				ret = ceph_renew_caps(&ci->vfs_inode);
+				ret = ceph_renew_caps(inode);
 				if (ret == 0)
 					continue;
 			}
 		if (ci->i_inline_version != CEPH_INLINE_NONE &&
 		    (_got & (CEPH_CAP_FILE_CACHE|CEPH_CAP_FILE_LAZYIO)) &&
-		    i_size_read(&ci->vfs_inode) > 0) {
+		    i_size_read(inode) > 0) {
 			struct page *page =
-				find_get_page(ci->vfs_inode.i_mapping, 0);
+				find_get_page(inode->i_mapping, 0);
 			if (page) {
 				if (PageUptodate(page)) {
 					*pinned_page = page;
 			 * getattr request will bring inline data into
 			 * page cache
 			 */
-			ret = __ceph_do_getattr(&ci->vfs_inode, NULL,
+			ret = __ceph_do_getattr(inode, NULL,
 						CEPH_STAT_CAP_INLINE_DATA,
 						true);
 			if (ret < 0)

fs/ceph/debugfs.c+0−1

@@ -294,7 +294,6 @@ void ceph_fs_debugfs_init(struct ceph_fs_client *fsc) · 293 unmodified lines
294		294
295	void ceph_fs_debugfs_init(struct ceph_fs_client *fsc)	295	void ceph_fs_debugfs_init(struct ceph_fs_client *fsc)
296	{	296	{
297	return 0;
298	}	297	}
299		298
300	void ceph_fs_debugfs_cleanup(struct ceph_fs_client *fsc)	299	void ceph_fs_debugfs_cleanup(struct ceph_fs_client *fsc)

fs/ceph/export.c+30−30

@@ -35,7 +35,7 @@ struct ceph_nfs_snapfh { · 34 unmodified lines
35	static int ceph_encode_snapfh(struct inode inode, u32 rawfh, int *max_len,	35	static int ceph_encode_snapfh(struct inode inode, u32 rawfh, int *max_len,
36	struct inode *parent_inode)	36	struct inode *parent_inode)
37	{	37	{
38	const static int snap_handle_length =	38	static const int snap_handle_length =
39	sizeof(struct ceph_nfs_snapfh) >> 2;	39	sizeof(struct ceph_nfs_snapfh) >> 2;
40	struct ceph_nfs_snapfh sfh = (void )rawfh;	40	struct ceph_nfs_snapfh sfh = (void )rawfh;
41	u64 snapid = ceph_snap(inode);	41	u64 snapid = ceph_snap(inode);
@@ -85,9 +85,9 @@ out: · 43 unmodified lines
85	static int ceph_encode_fh(struct inode inode, u32 rawfh, int *max_len,	85	static int ceph_encode_fh(struct inode inode, u32 rawfh, int *max_len,
86	struct inode *parent_inode)	86	struct inode *parent_inode)
87	{	87	{
88	const static int handle_length =	88	static const int handle_length =
89	sizeof(struct ceph_nfs_fh) >> 2;	89	sizeof(struct ceph_nfs_fh) >> 2;
90	const static int connected_handle_length =	90	static const int connected_handle_length =
91	sizeof(struct ceph_nfs_confh) >> 2;	91	sizeof(struct ceph_nfs_confh) >> 2;
92	int type;	92	int type;
93		93
@@ -458,33 +458,33 @@ static int __get_snap_name(struct dentry parent, char name, · 364 unmodified lines
458	if (err < 0)	458	if (err < 0)
459	goto out;	459	goto out;
460		460
461	rinfo = &req->r_reply_info;	461	rinfo = &req->r_reply_info;
462	for (i = 0; i < rinfo->dir_nr; i++) {	462	for (i = 0; i < rinfo->dir_nr; i++) {
463	rde = rinfo->dir_entries + i;	463	rde = rinfo->dir_entries + i;
464	BUG_ON(!rde->inode.in);	464	BUG_ON(!rde->inode.in);
465	if (ceph_snap(inode) ==	465	if (ceph_snap(inode) ==
466	le64_to_cpu(rde->inode.in->snapid)) {	466	le64_to_cpu(rde->inode.in->snapid)) {
467	memcpy(name, rde->name, rde->name_len);	467	memcpy(name, rde->name, rde->name_len);
468	name[rde->name_len] = '\0';	468	name[rde->name_len] = '\0';
469	err = 0;	469	err = 0;
470	goto out;	470	goto out;
471	}	471	}
472	}	472	}
473		473
474	if (rinfo->dir_end)	474	if (rinfo->dir_end)
475	break;	475	break;
476		476
477	BUG_ON(rinfo->dir_nr <= 0);	477	BUG_ON(rinfo->dir_nr <= 0);
478	rde = rinfo->dir_entries + (rinfo->dir_nr - 1);	478	rde = rinfo->dir_entries + (rinfo->dir_nr - 1);
479	next_offset += rinfo->dir_nr;	479	next_offset += rinfo->dir_nr;
480	last_name = kstrndup(rde->name, rde->name_len, GFP_KERNEL);	480	last_name = kstrndup(rde->name, rde->name_len, GFP_KERNEL);
481	if (!last_name) {	481	if (!last_name) {
482	err = -ENOMEM;	482	err = -ENOMEM;
483	goto out;	483	goto out;
484	}	484	}
485		485
486	ceph_mdsc_put_request(req);	486	ceph_mdsc_put_request(req);
487	req = NULL;	487	req = NULL;
488	}	488	}
489	err = -ENOENT;	489	err = -ENOENT;
490	out:	490	out:

fs/ceph/file.c+64−40

@@ -15,6 +15,7 @@ · 14 unmodified lines
15	#include "super.h"	15	#include "super.h"
16	#include "mds_client.h"	16	#include "mds_client.h"
17	#include "cache.h"	17	#include "cache.h"
		18	#include "io.h"
18		19
19	static __le32 ceph_flags_sys2wire(u32 flags)	20	static __le32 ceph_flags_sys2wire(u32 flags)
20	{	21	{
@@ -201,6 +202,7 @@ out: · 180 unmodified lines
201	static int ceph_init_file_info(struct inode inode, struct file file,	202	static int ceph_init_file_info(struct inode inode, struct file file,
202	int fmode, bool isdir)	203	int fmode, bool isdir)
203	{	204	{
		205	struct ceph_inode_info *ci = ceph_inode(inode);
204	struct ceph_file_info *fi;	206	struct ceph_file_info *fi;
205		207
206	dout("%s %p %p 0%o (%s)\n", __func__, inode, file,	208	dout("%s %p %p 0%o (%s)\n", __func__, inode, file,
@@ -211,7 +213,7 @@ static int ceph_init_file_info(struct inode inode, struct file file, · 4 unmodified lines
211	struct ceph_dir_file_info *dfi =	213	struct ceph_dir_file_info *dfi =
212	kmem_cache_zalloc(ceph_dir_file_cachep, GFP_KERNEL);	214	kmem_cache_zalloc(ceph_dir_file_cachep, GFP_KERNEL);
213	if (!dfi) {	215	if (!dfi) {
214	ceph_put_fmode(ceph_inode(inode), fmode); /* clean up */	216	ceph_put_fmode(ci, fmode); /* clean up */
215	return -ENOMEM;	217	return -ENOMEM;
216	}	218	}
217		219
@@ -222,7 +224,7 @@ static int ceph_init_file_info(struct inode inode, struct file file, · 4 unmodified lines
222	} else {	224	} else {
223	fi = kmem_cache_zalloc(ceph_file_cachep, GFP_KERNEL);	225	fi = kmem_cache_zalloc(ceph_file_cachep, GFP_KERNEL);
224	if (!fi) {	226	if (!fi) {
225	ceph_put_fmode(ceph_inode(inode), fmode); /* clean up */	227	ceph_put_fmode(ci, fmode); /* clean up */
226	return -ENOMEM;	228	return -ENOMEM;
227	}	229	}
228		230
@@ -232,6 +234,8 @@ static int ceph_init_file_info(struct inode inode, struct file file, · 3 unmodified lines
232	fi->fmode = fmode;	234	fi->fmode = fmode;
233	spin_lock_init(&fi->rw_contexts_lock);	235	spin_lock_init(&fi->rw_contexts_lock);
234	INIT_LIST_HEAD(&fi->rw_contexts);	236	INIT_LIST_HEAD(&fi->rw_contexts);
		237	fi->meta_err = errseq_sample(&ci->i_meta_err);
		238	fi->filp_gen = READ_ONCE(ceph_inode_to_client(inode)->filp_gen);
235		239
236	return 0;	240	return 0;
237	}	241	}
@@ -695,7 +699,13 @@ static ssize_t ceph_sync_read(struct kiocb iocb, struct iov_iter to, · 457 unmodified lines
695	ceph_release_page_vector(pages, num_pages);	699	ceph_release_page_vector(pages, num_pages);
696	}	700	}
697		701
698	if (ret <= 0 \|\| off >= i_size \|\| !more)	702	if (ret < 0) {
		703	if (ret == -EBLACKLISTED)
		704	fsc->blacklisted = true;
		705	break;
		706	}
		707
		708	if (off >= i_size \|\| !more)
699	break;	709	break;
700	}	710	}
701		711
@@ -921,7 +931,7 @@ ceph_direct_read_write(struct kiocb iocb, struct iov_iter iter, · 219 unmodified lines
921	struct ceph_aio_request *aio_req = NULL;	931	struct ceph_aio_request *aio_req = NULL;
922	int num_pages = 0;	932	int num_pages = 0;
923	int flags;	933	int flags;
924	int ret;	934	int ret = 0;
925	struct timespec64 mtime = current_time(inode);	935	struct timespec64 mtime = current_time(inode);
926	size_t count = iov_iter_count(iter);	936	size_t count = iov_iter_count(iter);
927	loff_t pos = iocb->ki_pos;	937	loff_t pos = iocb->ki_pos;
@@ -935,11 +945,6 @@ ceph_direct_read_write(struct kiocb iocb, struct iov_iter iter, · 7 unmodified lines
935	(write ? "write" : "read"), file, pos, (unsigned)count,	945	(write ? "write" : "read"), file, pos, (unsigned)count,
936	snapc, snapc ? snapc->seq : 0);	946	snapc, snapc ? snapc->seq : 0);
937		947
938	ret = filemap_write_and_wait_range(inode->i_mapping,
939	pos, pos + count - 1);
940	if (ret < 0)
941	return ret;
942
943	if (write) {	948	if (write) {
944	int ret2 = invalidate_inode_pages2_range(inode->i_mapping,	949	int ret2 = invalidate_inode_pages2_range(inode->i_mapping,
945	pos >> PAGE_SHIFT,	950	pos >> PAGE_SHIFT,
@@ -1260,7 +1265,8 @@ again: · 314 unmodified lines
1260	want = CEPH_CAP_FILE_CACHE \| CEPH_CAP_FILE_LAZYIO;	1265	want = CEPH_CAP_FILE_CACHE \| CEPH_CAP_FILE_LAZYIO;
1261	else	1266	else
1262	want = CEPH_CAP_FILE_CACHE;	1267	want = CEPH_CAP_FILE_CACHE;
1263	ret = ceph_get_caps(ci, CEPH_CAP_FILE_RD, want, -1, &got, &pinned_page);	1268	ret = ceph_get_caps(filp, CEPH_CAP_FILE_RD, want, -1,
		1269	&got, &pinned_page);
1264	if (ret < 0)	1270	if (ret < 0)
1265	return ret;	1271	return ret;
1266		1272
@@ -1274,12 +1280,16 @@ again: · 7 unmodified lines
1274		1280
1275	if (ci->i_inline_version == CEPH_INLINE_NONE) {	1281	if (ci->i_inline_version == CEPH_INLINE_NONE) {
1276	if (!retry_op && (iocb->ki_flags & IOCB_DIRECT)) {	1282	if (!retry_op && (iocb->ki_flags & IOCB_DIRECT)) {
		1283	ceph_start_io_direct(inode);
1277	ret = ceph_direct_read_write(iocb, to,	1284	ret = ceph_direct_read_write(iocb, to,
1278	NULL, NULL);	1285	NULL, NULL);
		1286	ceph_end_io_direct(inode);
1279	if (ret >= 0 && ret < len)	1287	if (ret >= 0 && ret < len)
1280	retry_op = CHECK_EOF;	1288	retry_op = CHECK_EOF;
1281	} else {	1289	} else {
		1290	ceph_start_io_read(inode);
1282	ret = ceph_sync_read(iocb, to, &retry_op);	1291	ret = ceph_sync_read(iocb, to, &retry_op);
		1292	ceph_end_io_read(inode);
1283	}	1293	}
1284	} else {	1294	} else {
1285	retry_op = READ_INLINE;	1295	retry_op = READ_INLINE;
@@ -1290,7 +1300,9 @@ again: · 4 unmodified lines
1290	inode, ceph_vinop(inode), iocb->ki_pos, (unsigned)len,	1300	inode, ceph_vinop(inode), iocb->ki_pos, (unsigned)len,
1291	ceph_cap_string(got));	1301	ceph_cap_string(got));
1292	ceph_add_rw_context(fi, &rw_ctx);	1302	ceph_add_rw_context(fi, &rw_ctx);
		1303	ceph_start_io_read(inode);
1293	ret = generic_file_read_iter(iocb, to);	1304	ret = generic_file_read_iter(iocb, to);
		1305	ceph_end_io_read(inode);
1294	ceph_del_rw_context(fi, &rw_ctx);	1306	ceph_del_rw_context(fi, &rw_ctx);
1295	}	1307	}
1296	dout("aio_read %p %llx.%llx dropping cap refs on %s = %d\n",	1308	dout("aio_read %p %llx.%llx dropping cap refs on %s = %d\n",
@@ -1399,7 +1411,10 @@ static ssize_t ceph_write_iter(struct kiocb iocb, struct iov_iter from) · 102 unmodified lines
1399	return -ENOMEM;	1411	return -ENOMEM;
1400		1412
1401	retry_snap:	1413	retry_snap:
1402	inode_lock(inode);	1414	if (iocb->ki_flags & IOCB_DIRECT)
		1415	ceph_start_io_direct(inode);
		1416	else
		1417	ceph_start_io_write(inode);
1403		1418
1404	/* We can write back this queue in page reclaim */	1419	/* We can write back this queue in page reclaim */
1405	current->backing_dev_info = inode_to_bdi(inode);	1420	current->backing_dev_info = inode_to_bdi(inode);
@@ -1457,7 +1472,7 @@ retry_snap: · 51 unmodified lines
1457	else	1472	else
1458	want = CEPH_CAP_FILE_BUFFER;	1473	want = CEPH_CAP_FILE_BUFFER;
1459	got = 0;	1474	got = 0;
1460	err = ceph_get_caps(ci, CEPH_CAP_FILE_WR, want, pos + count,	1475	err = ceph_get_caps(file, CEPH_CAP_FILE_WR, want, pos + count,
1461	&got, NULL);	1476	&got, NULL);
1462	if (err < 0)	1477	if (err < 0)
1463	goto out;	1478	goto out;
@@ -1470,7 +1485,6 @@ retry_snap: · 6 unmodified lines
1470	(ci->i_ceph_flags & CEPH_I_ERROR_WRITE)) {	1485	(ci->i_ceph_flags & CEPH_I_ERROR_WRITE)) {
1471	struct ceph_snap_context *snapc;	1486	struct ceph_snap_context *snapc;
1472	struct iov_iter data;	1487	struct iov_iter data;
1473	inode_unlock(inode);
1474		1488
1475	spin_lock(&ci->i_ceph_lock);	1489	spin_lock(&ci->i_ceph_lock);
1476	if (__ceph_have_pending_cap_snap(ci)) {	1490	if (__ceph_have_pending_cap_snap(ci)) {
@@ -1487,11 +1501,14 @@ retry_snap: · 10 unmodified lines
1487		1501
1488	/* we might need to revert back to that point */	1502	/* we might need to revert back to that point */
1489	data = *from;	1503	data = *from;
1490	if (iocb->ki_flags & IOCB_DIRECT)	1504	if (iocb->ki_flags & IOCB_DIRECT) {
1491	written = ceph_direct_read_write(iocb, &data, snapc,	1505	written = ceph_direct_read_write(iocb, &data, snapc,
1492	&prealloc_cf);	1506	&prealloc_cf);
1493	else	1507	ceph_end_io_direct(inode);
		1508	} else {
1494	written = ceph_sync_write(iocb, &data, pos, snapc);	1509	written = ceph_sync_write(iocb, &data, pos, snapc);
		1510	ceph_end_io_write(inode);
		1511	}
1495	if (written > 0)	1512	if (written > 0)
1496	iov_iter_advance(from, written);	1513	iov_iter_advance(from, written);
1497	ceph_put_snap_context(snapc);	1514	ceph_put_snap_context(snapc);
@@ -1506,7 +1523,7 @@ retry_snap: · 8 unmodified lines
1506	written = generic_perform_write(file, from, pos);	1523	written = generic_perform_write(file, from, pos);
1507	if (likely(written >= 0))	1524	if (likely(written >= 0))
1508	iocb->ki_pos = pos + written;	1525	iocb->ki_pos = pos + written;
1509	inode_unlock(inode);	1526	ceph_end_io_write(inode);
1510	}	1527	}
1511		1528
1512	if (written >= 0) {	1529	if (written >= 0) {
@@ -1541,9 +1558,11 @@ retry_snap: · 28 unmodified lines
1541	}	1558	}
1542		1559
1543	goto out_unlocked;	1560	goto out_unlocked;
1544
1545	out:	1561	out:
1546	inode_unlock(inode);	1562	if (iocb->ki_flags & IOCB_DIRECT)
		1563	ceph_end_io_direct(inode);
		1564	else
		1565	ceph_end_io_write(inode);
1547	out_unlocked:	1566	out_unlocked:
1548	ceph_free_cap_flush(prealloc_cf);	1567	ceph_free_cap_flush(prealloc_cf);
1549	current->backing_dev_info = NULL;	1568	current->backing_dev_info = NULL;
@@ -1781,7 +1800,7 @@ static long ceph_fallocate(struct file *file, int mode, · 231 unmodified lines
1781	else	1800	else
1782	want = CEPH_CAP_FILE_BUFFER;	1801	want = CEPH_CAP_FILE_BUFFER;
1783		1802
1784	ret = ceph_get_caps(ci, CEPH_CAP_FILE_WR, want, endoff, &got, NULL);	1803	ret = ceph_get_caps(file, CEPH_CAP_FILE_WR, want, endoff, &got, NULL);
1785	if (ret < 0)	1804	if (ret < 0)
1786	goto unlock;	1805	goto unlock;
1787		1806
@@ -1810,16 +1829,15 @@ unlock: · 22 unmodified lines
1810	* src_ci. Two attempts are made to obtain both caps, and an error is return if	1829	* src_ci. Two attempts are made to obtain both caps, and an error is return if
1811	* this fails; zero is returned on success.	1830	* this fails; zero is returned on success.
1812	*/	1831	*/
1813	static int get_rd_wr_caps(struct ceph_inode_info *src_ci,	1832	static int get_rd_wr_caps(struct file src_filp, int src_got,
1814	loff_t src_endoff, int *src_got,	1833	struct file *dst_filp,
1815	struct ceph_inode_info *dst_ci,
1816	loff_t dst_endoff, int *dst_got)	1834	loff_t dst_endoff, int *dst_got)
1817	{	1835	{
1818	int ret = 0;	1836	int ret = 0;
1819	bool retrying = false;	1837	bool retrying = false;
1820		1838
1821	retry_caps:	1839	retry_caps:
1822	ret = ceph_get_caps(dst_ci, CEPH_CAP_FILE_WR, CEPH_CAP_FILE_BUFFER,	1840	ret = ceph_get_caps(dst_filp, CEPH_CAP_FILE_WR, CEPH_CAP_FILE_BUFFER,
1823	dst_endoff, dst_got, NULL);	1841	dst_endoff, dst_got, NULL);
1824	if (ret < 0)	1842	if (ret < 0)
1825	return ret;	1843	return ret;
@@ -1829,24 +1847,24 @@ retry_caps: · 3 unmodified lines
1829	* we would risk a deadlock by using ceph_get_caps. Thus, we'll do some	1847	* we would risk a deadlock by using ceph_get_caps. Thus, we'll do some
1830	* retry dance instead to try to get both capabilities.	1848	* retry dance instead to try to get both capabilities.
1831	*/	1849	*/
1832	ret = ceph_try_get_caps(src_ci, CEPH_CAP_FILE_RD, CEPH_CAP_FILE_SHARED,	1850	ret = ceph_try_get_caps(file_inode(src_filp),
		1851	CEPH_CAP_FILE_RD, CEPH_CAP_FILE_SHARED,
1833	false, src_got);	1852	false, src_got);
1834	if (ret <= 0) {	1853	if (ret <= 0) {
1835	/* Start by dropping dst_ci caps and getting src_ci caps */	1854	/* Start by dropping dst_ci caps and getting src_ci caps */
1836	ceph_put_cap_refs(dst_ci, *dst_got);	1855	ceph_put_cap_refs(ceph_inode(file_inode(dst_filp)), *dst_got);
1837	if (retrying) {	1856	if (retrying) {
1838	if (!ret)	1857	if (!ret)
1839	/* ceph_try_get_caps masks EAGAIN */	1858	/* ceph_try_get_caps masks EAGAIN */
1840	ret = -EAGAIN;	1859	ret = -EAGAIN;
1841	return ret;	1860	return ret;
1842	}	1861	}
1843	ret = ceph_get_caps(src_ci, CEPH_CAP_FILE_RD,	1862	ret = ceph_get_caps(src_filp, CEPH_CAP_FILE_RD,
1844	CEPH_CAP_FILE_SHARED, src_endoff,	1863	CEPH_CAP_FILE_SHARED, -1, src_got, NULL);
1845	src_got, NULL);
1846	if (ret < 0)	1864	if (ret < 0)
1847	return ret;	1865	return ret;
1848	/... drop src_ci caps too, and retry /	1866	/... drop src_ci caps too, and retry /
1849	ceph_put_cap_refs(src_ci, *src_got);	1867	ceph_put_cap_refs(ceph_inode(file_inode(src_filp)), *src_got);
1850	retrying = true;	1868	retrying = true;
1851	goto retry_caps;	1869	goto retry_caps;
1852	}	1870	}
@@ -1904,6 +1922,7 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off, · 51 unmodified lines
1904	struct ceph_inode_info *src_ci = ceph_inode(src_inode);	1922	struct ceph_inode_info *src_ci = ceph_inode(src_inode);
1905	struct ceph_inode_info *dst_ci = ceph_inode(dst_inode);	1923	struct ceph_inode_info *dst_ci = ceph_inode(dst_inode);
1906	struct ceph_cap_flush *prealloc_cf;	1924	struct ceph_cap_flush *prealloc_cf;
		1925	struct ceph_fs_client *src_fsc = ceph_inode_to_client(src_inode);
1907	struct ceph_object_locator src_oloc, dst_oloc;	1926	struct ceph_object_locator src_oloc, dst_oloc;
1908	struct ceph_object_id src_oid, dst_oid;	1927	struct ceph_object_id src_oid, dst_oid;
1909	loff_t endoff = 0, size;	1928	loff_t endoff = 0, size;
@@ -1913,10 +1932,16 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off, · 3 unmodified lines
1913	int src_got = 0, dst_got = 0, err, dirty;	1932	int src_got = 0, dst_got = 0, err, dirty;
1914	bool do_final_copy = false;	1933	bool do_final_copy = false;
1915		1934
1916	if (src_inode == dst_inode)	1935	if (src_inode->i_sb != dst_inode->i_sb) {
1917	return -EINVAL;	1936	struct ceph_fs_client *dst_fsc = ceph_inode_to_client(dst_inode);
1918	if (src_inode->i_sb != dst_inode->i_sb)	1937
1919	return -EXDEV;	1938	if (ceph_fsid_compare(&src_fsc->client->fsid,
		1939	&dst_fsc->client->fsid)) {
		1940	dout("Copying files across clusters: src: %pU dst: %pU\n",
		1941	&src_fsc->client->fsid, &dst_fsc->client->fsid);
		1942	return -EXDEV;
		1943	}
		1944	}
1920	if (ceph_snap(dst_inode) != CEPH_NOSNAP)	1945	if (ceph_snap(dst_inode) != CEPH_NOSNAP)
1921	return -EROFS;	1946	return -EROFS;
1922		1947
@@ -1928,7 +1953,7 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off, · 5 unmodified lines
1928	* efficient).	1953	* efficient).
1929	*/	1954	*/
1930		1955
1931	if (ceph_test_mount_opt(ceph_inode_to_client(src_inode), NOCOPYFROM))	1956	if (ceph_test_mount_opt(src_fsc, NOCOPYFROM))
1932	return -EOPNOTSUPP;	1957	return -EOPNOTSUPP;
1933		1958
1934	if ((src_ci->i_layout.stripe_unit != dst_ci->i_layout.stripe_unit) \|\|	1959	if ((src_ci->i_layout.stripe_unit != dst_ci->i_layout.stripe_unit) \|\|
@@ -1960,8 +1985,8 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off, · 25 unmodified lines
1960	* clients may have dirty data in their caches. And OSDs know nothing	1985	* clients may have dirty data in their caches. And OSDs know nothing
1961	* about caps, so they can't safely do the remote object copies.	1986	* about caps, so they can't safely do the remote object copies.
1962	*/	1987	*/
1963	err = get_rd_wr_caps(src_ci, (src_off + len), &src_got,	1988	err = get_rd_wr_caps(src_file, &src_got,
1964	dst_ci, (dst_off + len), &dst_got);	1989	dst_file, (dst_off + len), &dst_got);
1965	if (err < 0) {	1990	if (err < 0) {
1966	dout("get_rd_wr_caps returned %d\n", err);	1991	dout("get_rd_wr_caps returned %d\n", err);
1967	ret = -EOPNOTSUPP;	1992	ret = -EOPNOTSUPP;
@@ -2018,9 +2043,8 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off, · 50 unmodified lines
2018	goto out;	2043	goto out;
2019	}	2044	}
2020	len -= ret;	2045	len -= ret;
2021	err = get_rd_wr_caps(src_ci, (src_off + len),	2046	err = get_rd_wr_caps(src_file, &src_got,
2022	&src_got, dst_ci,	2047	dst_file, (dst_off + len), &dst_got);
2023	(dst_off + len), &dst_got);
2024	if (err < 0)	2048	if (err < 0)
2025	goto out;	2049	goto out;
2026	err = is_file_size_ok(src_inode, dst_inode,	2050	err = is_file_size_ok(src_inode, dst_inode,
@@ -2044,7 +2068,7 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off, · 17 unmodified lines
2044	dst_ci->i_vino.ino, dst_objnum);	2068	dst_ci->i_vino.ino, dst_objnum);
2045	/* Do an object remote copy */	2069	/* Do an object remote copy */
2046	err = ceph_osdc_copy_from(	2070	err = ceph_osdc_copy_from(
2047	&ceph_inode_to_client(src_inode)->client->osdc,	2071	&src_fsc->client->osdc,
2048	src_ci->i_vino.snap, 0,	2072	src_ci->i_vino.snap, 0,
2049	&src_oid, &src_oloc,	2073	&src_oid, &src_oloc,
2050	CEPH_OSD_OP_FLAG_FADVISE_SEQUENTIAL \|	2074	CEPH_OSD_OP_FLAG_FADVISE_SEQUENTIAL \|

fs/ceph/inode.c+29−21

 	ceph_fscache_inode_init(ci);
+	ci->i_meta_err = 0;
 	return &ci->vfs_inode;
 }
 	/* update inode */
 	inode->i_rdev = le32_to_cpu(info->rdev);
-	inode->i_blkbits = fls(le32_to_cpu(info->layout.fl_stripe_unit)) - 1;
+	/* directories have fl_stripe_unit set to zero */
+	if (le32_to_cpu(info->layout.fl_stripe_unit))
+		inode->i_blkbits =
+			fls(le32_to_cpu(info->layout.fl_stripe_unit)) - 1;
+	else
+		inode->i_blkbits = CEPH_BLOCK_SHIFT;
 	__ceph_update_quota(ci, iinfo->max_bytes, iinfo->max_files);
 int __ceph_setattr(struct inode *inode, struct iattr *attr)
 {
 	struct ceph_inode_info *ci = ceph_inode(inode);
-	const unsigned int ia_valid = attr->ia_valid;
+	unsigned int ia_valid = attr->ia_valid;
 	struct ceph_mds_request *req;
 	struct ceph_mds_client *mdsc = ceph_sb_to_client(inode->i_sb)->mdsc;
 	struct ceph_cap_flush *prealloc_cf;
 				   CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
 		}
 	}
+	if (ia_valid & ATTR_SIZE) {
+		dout("setattr %p size %lld -> %lld\n", inode,
+		     inode->i_size, attr->ia_size);
+		if ((issued & CEPH_CAP_FILE_EXCL) &&
+		    attr->ia_size > inode->i_size) {
+			i_size_write(inode, attr->ia_size);
+			inode->i_blocks = calc_inode_blocks(attr->ia_size);
+			ci->i_reported_size = attr->ia_size;
+			dirtied |= CEPH_CAP_FILE_EXCL;
+			ia_valid |= ATTR_MTIME;
+		} else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
+			   attr->ia_size != inode->i_size) {
+			req->r_args.setattr.size = cpu_to_le64(attr->ia_size);
+			req->r_args.setattr.old_size =
+				cpu_to_le64(inode->i_size);
+			mask |= CEPH_SETATTR_SIZE;
+			release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL |
+				   CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
+		}
+	}
 	if (ia_valid & ATTR_MTIME) {
 		dout("setattr %p mtime %lld.%ld -> %lld.%ld\n", inode,
 		     inode->i_mtime.tv_sec, inode->i_mtime.tv_nsec,
 				   CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
 		}
 	}
-	if (ia_valid & ATTR_SIZE) {
-		dout("setattr %p size %lld -> %lld\n", inode,
-		     inode->i_size, attr->ia_size);
-		if ((issued & CEPH_CAP_FILE_EXCL) &&
-		    attr->ia_size > inode->i_size) {
-			i_size_write(inode, attr->ia_size);
-			inode->i_blocks = calc_inode_blocks(attr->ia_size);
-			ci->i_reported_size = attr->ia_size;
-			dirtied |= CEPH_CAP_FILE_EXCL;
-		} else if ((issued & CEPH_CAP_FILE_SHARED) == 0 ||
-			   attr->ia_size != inode->i_size) {
-			req->r_args.setattr.size = cpu_to_le64(attr->ia_size);
-			req->r_args.setattr.old_size =
-				cpu_to_le64(inode->i_size);
-			mask |= CEPH_SETATTR_SIZE;
-			release |= CEPH_CAP_FILE_SHARED | CEPH_CAP_FILE_EXCL |
-				   CEPH_CAP_FILE_RD | CEPH_CAP_FILE_WR;
-		}
-	}
 	/* these do nothing */
 	if (ia_valid & ATTR_CTIME) {

fs/ceph/io.c+163−0

@@ -0,0 +1,163 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/*
	3	* Copyright (c) 2016 Trond Myklebust
	4	* Copyright (c) 2019 Jeff Layton
	5	*
	6	* I/O and data path helper functionality.
	7	*
	8	* Heavily borrowed from equivalent code in fs/nfs/io.c
	9	*/
	10
	11	#include <linux/ceph/ceph_debug.h>
	12
	13	#include <linux/types.h>
	14	#include <linux/kernel.h>
	15	#include <linux/rwsem.h>
	16	#include <linux/fs.h>
	17
	18	#include "super.h"
	19	#include "io.h"
	20
	21	/* Call with exclusively locked inode->i_rwsem */
	22	static void ceph_block_o_direct(struct ceph_inode_info ci, struct inode inode)
	23	{
	24	lockdep_assert_held_write(&inode->i_rwsem);
	25
	26	if (READ_ONCE(ci->i_ceph_flags) & CEPH_I_ODIRECT) {
	27	spin_lock(&ci->i_ceph_lock);
	28	ci->i_ceph_flags &= ~CEPH_I_ODIRECT;
	29	spin_unlock(&ci->i_ceph_lock);
	30	inode_dio_wait(inode);
	31	}
	32	}
	33
	34	/**
	35	* ceph_start_io_read - declare the file is being used for buffered reads
	36	* @inode: file inode
	37	*
	38	* Declare that a buffered read operation is about to start, and ensure
	39	* that we block all direct I/O.
	40	* On exit, the function ensures that the CEPH_I_ODIRECT flag is unset,
	41	* and holds a shared lock on inode->i_rwsem to ensure that the flag
	42	* cannot be changed.
	43	* In practice, this means that buffered read operations are allowed to
	44	* execute in parallel, thanks to the shared lock, whereas direct I/O
	45	* operations need to wait to grab an exclusive lock in order to set
	46	* CEPH_I_ODIRECT.
	47	* Note that buffered writes and truncates both take a write lock on
	48	* inode->i_rwsem, meaning that those are serialised w.r.t. the reads.
	49	*/
	50	void
	51	ceph_start_io_read(struct inode *inode)
	52	{
	53	struct ceph_inode_info *ci = ceph_inode(inode);
	54
	55	/* Be an optimist! */
	56	down_read(&inode->i_rwsem);
	57	if (!(READ_ONCE(ci->i_ceph_flags) & CEPH_I_ODIRECT))
	58	return;
	59	up_read(&inode->i_rwsem);
	60	/* Slow path.... */
	61	down_write(&inode->i_rwsem);
	62	ceph_block_o_direct(ci, inode);
	63	downgrade_write(&inode->i_rwsem);
	64	}
	65
	66	/**
	67	* ceph_end_io_read - declare that the buffered read operation is done
	68	* @inode: file inode
	69	*
	70	* Declare that a buffered read operation is done, and release the shared
	71	* lock on inode->i_rwsem.
	72	*/
	73	void
	74	ceph_end_io_read(struct inode *inode)
	75	{
	76	up_read(&inode->i_rwsem);
	77	}
	78
	79	/**
	80	* ceph_start_io_write - declare the file is being used for buffered writes
	81	* @inode: file inode
	82	*
	83	* Declare that a buffered write operation is about to start, and ensure
	84	* that we block all direct I/O.
	85	*/
	86	void
	87	ceph_start_io_write(struct inode *inode)
	88	{
	89	down_write(&inode->i_rwsem);
	90	ceph_block_o_direct(ceph_inode(inode), inode);
	91	}
	92
	93	/**
	94	* ceph_end_io_write - declare that the buffered write operation is done
	95	* @inode: file inode
	96	*
	97	* Declare that a buffered write operation is done, and release the
	98	* lock on inode->i_rwsem.
	99	*/
	100	void
	101	ceph_end_io_write(struct inode *inode)
	102	{
	103	up_write(&inode->i_rwsem);
	104	}
	105
	106	/* Call with exclusively locked inode->i_rwsem */
	107	static void ceph_block_buffered(struct ceph_inode_info ci, struct inode inode)
	108	{
	109	lockdep_assert_held_write(&inode->i_rwsem);
	110
	111	if (!(READ_ONCE(ci->i_ceph_flags) & CEPH_I_ODIRECT)) {
	112	spin_lock(&ci->i_ceph_lock);
	113	ci->i_ceph_flags \|= CEPH_I_ODIRECT;
	114	spin_unlock(&ci->i_ceph_lock);
	115	/* FIXME: unmap_mapping_range? */
	116	filemap_write_and_wait(inode->i_mapping);
	117	}
	118	}
	119
	120	/**
	121	* ceph_end_io_direct - declare the file is being used for direct i/o
	122	* @inode: file inode
	123	*
	124	* Declare that a direct I/O operation is about to start, and ensure
	125	* that we block all buffered I/O.
	126	* On exit, the function ensures that the CEPH_I_ODIRECT flag is set,
	127	* and holds a shared lock on inode->i_rwsem to ensure that the flag
	128	* cannot be changed.
	129	* In practice, this means that direct I/O operations are allowed to
	130	* execute in parallel, thanks to the shared lock, whereas buffered I/O
	131	* operations need to wait to grab an exclusive lock in order to clear
	132	* CEPH_I_ODIRECT.
	133	* Note that buffered writes and truncates both take a write lock on
	134	* inode->i_rwsem, meaning that those are serialised w.r.t. O_DIRECT.
	135	*/
	136	void
	137	ceph_start_io_direct(struct inode *inode)
	138	{
	139	struct ceph_inode_info *ci = ceph_inode(inode);
	140
	141	/* Be an optimist! */
	142	down_read(&inode->i_rwsem);
	143	if (READ_ONCE(ci->i_ceph_flags) & CEPH_I_ODIRECT)
	144	return;
	145	up_read(&inode->i_rwsem);
	146	/* Slow path.... */
	147	down_write(&inode->i_rwsem);
	148	ceph_block_buffered(ci, inode);
	149	downgrade_write(&inode->i_rwsem);
	150	}
	151
	152	/**
	153	* ceph_end_io_direct - declare that the direct i/o operation is done
	154	* @inode: file inode
	155	*
	156	* Declare that a direct I/O operation is done, and release the shared
	157	* lock on inode->i_rwsem.
	158	*/
	159	void
	160	ceph_end_io_direct(struct inode *inode)
	161	{
	162	up_read(&inode->i_rwsem);
	163	}

fs/ceph/io.h+12−0

@@ -0,0 +1,12 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _FS_CEPH_IO_H
	3	#define _FS_CEPH_IO_H
	4
	5	void ceph_start_io_read(struct inode *inode);
	6	void ceph_end_io_read(struct inode *inode);
	7	void ceph_start_io_write(struct inode *inode);
	8	void ceph_end_io_write(struct inode *inode);
	9	void ceph_start_io_direct(struct inode *inode);
	10	void ceph_end_io_direct(struct inode *inode);
	11
	12	#endif /* FS_CEPH_IO_H */

fs/ceph/locks.c+6−2

 static void ceph_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
 {
-	struct inode *inode = file_inode(src->fl_file);
+	struct ceph_file_info *fi = dst->fl_file->private_data;
+	struct inode *inode = file_inode(dst->fl_file);
 	atomic_inc(&ceph_inode(inode)->i_filelock_ref);
+	atomic_inc(&fi->num_locks);
 }
 static void ceph_fl_release_lock(struct file_lock *fl)
 {
+	struct ceph_file_info *fi = fl->fl_file->private_data;
 	struct inode *inode = file_inode(fl->fl_file);
 	struct ceph_inode_info *ci = ceph_inode(inode);
+	atomic_dec(&fi->num_locks);
 	if (atomic_dec_and_test(&ci->i_filelock_ref)) {
 		/* clear error when all locks are released */
 		spin_lock(&ci->i_ceph_lock);
 		 * window. Caller function will decrease the counter.
 		 */
 		fl->fl_ops = &ceph_fl_lock_ops;
-		atomic_inc(&ceph_inode(inode)->i_filelock_ref);
+		fl->fl_ops->fl_copy_lock(fl, NULL);
 	}
 	if (operation != CEPH_MDS_OP_SETFILELOCK || cmd == CEPH_LOCK_UNLOCK)

fs/ceph/mds_client.c+82−28

@@ -639,7 +639,6 @@ static struct ceph_mds_session register_session(struct ceph_mds_client mdsc, · 638 unmodified lines
639	s->s_renew_seq = 0;	639	s->s_renew_seq = 0;
640	INIT_LIST_HEAD(&s->s_caps);	640	INIT_LIST_HEAD(&s->s_caps);
641	s->s_nr_caps = 0;	641	s->s_nr_caps = 0;
642	s->s_trim_caps = 0;
643	refcount_set(&s->s_ref, 1);	642	refcount_set(&s->s_ref, 1);
644	INIT_LIST_HEAD(&s->s_waiting);	643	INIT_LIST_HEAD(&s->s_waiting);
645	INIT_LIST_HEAD(&s->s_unsafe);	644	INIT_LIST_HEAD(&s->s_unsafe);
@@ -1270,6 +1269,7 @@ static void cleanup_session_requests(struct ceph_mds_client *mdsc, · 624 unmodified lines
1270	{	1269	{
1271	struct ceph_mds_request *req;	1270	struct ceph_mds_request *req;
1272	struct rb_node *p;	1271	struct rb_node *p;
		1272	struct ceph_inode_info *ci;
1273		1273
1274	dout("cleanup_session_requests mds%d\n", session->s_mds);	1274	dout("cleanup_session_requests mds%d\n", session->s_mds);
1275	mutex_lock(&mdsc->mutex);	1275	mutex_lock(&mdsc->mutex);
@@ -1278,6 +1278,16 @@ static void cleanup_session_requests(struct ceph_mds_client *mdsc, · 2 unmodified lines
1278	struct ceph_mds_request, r_unsafe_item);	1278	struct ceph_mds_request, r_unsafe_item);
1279	pr_warn_ratelimited(" dropping unsafe request %llu\n",	1279	pr_warn_ratelimited(" dropping unsafe request %llu\n",
1280	req->r_tid);	1280	req->r_tid);
		1281	if (req->r_target_inode) {
		1282	/* dropping unsafe change of inode's attributes */
		1283	ci = ceph_inode(req->r_target_inode);
		1284	errseq_set(&ci->i_meta_err, -EIO);
		1285	}
		1286	if (req->r_unsafe_dir) {
		1287	/* dropping unsafe directory operation */
		1288	ci = ceph_inode(req->r_unsafe_dir);
		1289	errseq_set(&ci->i_meta_err, -EIO);
		1290	}
1281	__unregister_request(mdsc, req);	1291	__unregister_request(mdsc, req);
1282	}	1292	}
1283	/* zero r_attempts, so kick_requests() will re-send requests */	1293	/* zero r_attempts, so kick_requests() will re-send requests */
@@ -1370,7 +1380,7 @@ static int remove_session_caps_cb(struct inode inode, struct ceph_cap cap, · 86 unmodified lines
1370	struct ceph_fs_client fsc = (struct ceph_fs_client )arg;	1380	struct ceph_fs_client fsc = (struct ceph_fs_client )arg;
1371	struct ceph_inode_info *ci = ceph_inode(inode);	1381	struct ceph_inode_info *ci = ceph_inode(inode);
1372	LIST_HEAD(to_remove);	1382	LIST_HEAD(to_remove);
1373	bool drop = false;	1383	bool dirty_dropped = false;
1374	bool invalidate = false;	1384	bool invalidate = false;
1375		1385
1376	dout("removing cap %p, ci is %p, inode is %p\n",	1386	dout("removing cap %p, ci is %p, inode is %p\n",
@@ -1383,9 +1393,12 @@ static int remove_session_caps_cb(struct inode inode, struct ceph_cap cap, · 6 unmodified lines
1383	struct ceph_cap_flush *cf;	1393	struct ceph_cap_flush *cf;
1384	struct ceph_mds_client *mdsc = fsc->mdsc;	1394	struct ceph_mds_client *mdsc = fsc->mdsc;
1385		1395
1386	if (ci->i_wrbuffer_ref > 0 &&	1396	if (READ_ONCE(fsc->mount_state) == CEPH_MOUNT_SHUTDOWN) {
1387	READ_ONCE(fsc->mount_state) == CEPH_MOUNT_SHUTDOWN)	1397	if (inode->i_data.nrpages > 0)
1388	invalidate = true;	1398	invalidate = true;
		1399	if (ci->i_wrbuffer_ref > 0)
		1400	mapping_set_error(&inode->i_data, -EIO);
		1401	}
1389		1402
1390	while (!list_empty(&ci->i_cap_flush_list)) {	1403	while (!list_empty(&ci->i_cap_flush_list)) {
1391	cf = list_first_entry(&ci->i_cap_flush_list,	1404	cf = list_first_entry(&ci->i_cap_flush_list,
@@ -1405,7 +1418,7 @@ static int remove_session_caps_cb(struct inode inode, struct ceph_cap cap, · 13 unmodified lines
1405	inode, ceph_ino(inode));	1418	inode, ceph_ino(inode));
1406	ci->i_dirty_caps = 0;	1419	ci->i_dirty_caps = 0;
1407	list_del_init(&ci->i_dirty_item);	1420	list_del_init(&ci->i_dirty_item);
1408	drop = true;	1421	dirty_dropped = true;
1409	}	1422	}
1410	if (!list_empty(&ci->i_flushing_item)) {	1423	if (!list_empty(&ci->i_flushing_item)) {
1411	pr_warn_ratelimited(	1424	pr_warn_ratelimited(
@@ -1415,10 +1428,22 @@ static int remove_session_caps_cb(struct inode inode, struct ceph_cap cap, · 3 unmodified lines
1415	ci->i_flushing_caps = 0;	1428	ci->i_flushing_caps = 0;
1416	list_del_init(&ci->i_flushing_item);	1429	list_del_init(&ci->i_flushing_item);
1417	mdsc->num_cap_flushing--;	1430	mdsc->num_cap_flushing--;
1418	drop = true;	1431	dirty_dropped = true;
1419	}	1432	}
1420	spin_unlock(&mdsc->cap_dirty_lock);	1433	spin_unlock(&mdsc->cap_dirty_lock);
1421		1434
		1435	if (dirty_dropped) {
		1436	errseq_set(&ci->i_meta_err, -EIO);
		1437
		1438	if (ci->i_wrbuffer_ref_head == 0 &&
		1439	ci->i_wr_ref == 0 &&
		1440	ci->i_dirty_caps == 0 &&
		1441	ci->i_flushing_caps == 0) {
		1442	ceph_put_snap_context(ci->i_head_snapc);
		1443	ci->i_head_snapc = NULL;
		1444	}
		1445	}
		1446
1422	if (atomic_read(&ci->i_filelock_ref) > 0) {	1447	if (atomic_read(&ci->i_filelock_ref) > 0) {
1423	/* make further file lock syscall return -EIO */	1448	/* make further file lock syscall return -EIO */
1424	ci->i_ceph_flags \|= CEPH_I_ERROR_FILELOCK;	1449	ci->i_ceph_flags \|= CEPH_I_ERROR_FILELOCK;
@@ -1430,15 +1455,6 @@ static int remove_session_caps_cb(struct inode inode, struct ceph_cap cap, · 5 unmodified lines
1430	list_add(&ci->i_prealloc_cap_flush->i_list, &to_remove);	1455	list_add(&ci->i_prealloc_cap_flush->i_list, &to_remove);
1431	ci->i_prealloc_cap_flush = NULL;	1456	ci->i_prealloc_cap_flush = NULL;
1432	}	1457	}
1433
1434	if (drop &&
1435	ci->i_wrbuffer_ref_head == 0 &&
1436	ci->i_wr_ref == 0 &&
1437	ci->i_dirty_caps == 0 &&
1438	ci->i_flushing_caps == 0) {
1439	ceph_put_snap_context(ci->i_head_snapc);
1440	ci->i_head_snapc = NULL;
1441	}
1442	}	1458	}
1443	spin_unlock(&ci->i_ceph_lock);	1459	spin_unlock(&ci->i_ceph_lock);
1444	while (!list_empty(&to_remove)) {	1460	while (!list_empty(&to_remove)) {
@@ -1452,7 +1468,7 @@ static int remove_session_caps_cb(struct inode inode, struct ceph_cap cap, · 7 unmodified lines
1452	wake_up_all(&ci->i_cap_wq);	1468	wake_up_all(&ci->i_cap_wq);
1453	if (invalidate)	1469	if (invalidate)
1454	ceph_queue_invalidate(inode);	1470	ceph_queue_invalidate(inode);
1455	if (drop)	1471	if (dirty_dropped)
1456	iput(inode);	1472	iput(inode);
1457	return 0;	1473	return 0;
1458	}	1474	}
@@ -1705,11 +1721,11 @@ out: · 246 unmodified lines
1705	*/	1721	*/
1706	static int trim_caps_cb(struct inode inode, struct ceph_cap cap, void *arg)	1722	static int trim_caps_cb(struct inode inode, struct ceph_cap cap, void *arg)
1707	{	1723	{
1708	struct ceph_mds_session *session = arg;	1724	int *remaining = arg;
1709	struct ceph_inode_info *ci = ceph_inode(inode);	1725	struct ceph_inode_info *ci = ceph_inode(inode);
1710	int used, wanted, oissued, mine;	1726	int used, wanted, oissued, mine;
1711		1727
1712	if (session->s_trim_caps <= 0)	1728	if (*remaining <= 0)
1713	return -1;	1729	return -1;
1714		1730
1715	spin_lock(&ci->i_ceph_lock);	1731	spin_lock(&ci->i_ceph_lock);
@@ -1746,7 +1762,7 @@ static int trim_caps_cb(struct inode inode, struct ceph_cap cap, void *arg) · 30 unmodified lines
1746	if (oissued) {	1762	if (oissued) {
1747	/* we aren't the only cap.. just remove us */	1763	/* we aren't the only cap.. just remove us */
1748	__ceph_remove_cap(cap, true);	1764	__ceph_remove_cap(cap, true);
1749	session->s_trim_caps--;	1765	(*remaining)--;
1750	} else {	1766	} else {
1751	struct dentry *dentry;	1767	struct dentry *dentry;
1752	/* try dropping referring dentries */	1768	/* try dropping referring dentries */
@@ -1758,7 +1774,7 @@ static int trim_caps_cb(struct inode inode, struct ceph_cap cap, void *arg) · 5 unmodified lines
1758	d_prune_aliases(inode);	1774	d_prune_aliases(inode);
1759	count = atomic_read(&inode->i_count);	1775	count = atomic_read(&inode->i_count);
1760	if (count == 1)	1776	if (count == 1)
1761	session->s_trim_caps--;	1777	(*remaining)--;
1762	dout("trim_caps_cb %p cap %p pruned, count now %d\n",	1778	dout("trim_caps_cb %p cap %p pruned, count now %d\n",
1763	inode, cap, count);	1779	inode, cap, count);
1764	} else {	1780	} else {
@@ -1784,12 +1800,12 @@ int ceph_trim_caps(struct ceph_mds_client *mdsc, · 19 unmodified lines
1784	dout("trim_caps mds%d start: %d / %d, trim %d\n",	1800	dout("trim_caps mds%d start: %d / %d, trim %d\n",
1785	session->s_mds, session->s_nr_caps, max_caps, trim_caps);	1801	session->s_mds, session->s_nr_caps, max_caps, trim_caps);
1786	if (trim_caps > 0) {	1802	if (trim_caps > 0) {
1787	session->s_trim_caps = trim_caps;	1803	int remaining = trim_caps;
1788	ceph_iterate_session_caps(session, trim_caps_cb, session);	1804
		1805	ceph_iterate_session_caps(session, trim_caps_cb, &remaining);
1789	dout("trim_caps mds%d done: %d / %d, trimmed %d\n",	1806	dout("trim_caps mds%d done: %d / %d, trimmed %d\n",
1790	session->s_mds, session->s_nr_caps, max_caps,	1807	session->s_mds, session->s_nr_caps, max_caps,
1791	trim_caps - session->s_trim_caps);	1808	trim_caps - remaining);
1792	session->s_trim_caps = 0;
1793	}	1809	}
1794		1810
1795	ceph_flush_cap_releases(mdsc, session);	1811	ceph_flush_cap_releases(mdsc, session);
@@ -3015,18 +3031,23 @@ bad: · 1219 unmodified lines
3015	pr_err("mdsc_handle_forward decode error err=%d\n", err);	3031	pr_err("mdsc_handle_forward decode error err=%d\n", err);
3016	}	3032	}
3017		3033
3018	static int __decode_and_drop_session_metadata(void *p, void end)	3034	static int __decode_session_metadata(void *p, void end,
		3035	bool *blacklisted)
3019	{	3036	{
3020	/* map<string,string> */	3037	/* map<string,string> */
3021	u32 n;	3038	u32 n;
		3039	bool err_str;
3022	ceph_decode_32_safe(p, end, n, bad);	3040	ceph_decode_32_safe(p, end, n, bad);
3023	while (n-- > 0) {	3041	while (n-- > 0) {
3024	u32 len;	3042	u32 len;
3025	ceph_decode_32_safe(p, end, len, bad);	3043	ceph_decode_32_safe(p, end, len, bad);
3026	ceph_decode_need(p, end, len, bad);	3044	ceph_decode_need(p, end, len, bad);
		3045	err_str = !strncmp(*p, "error_string", len);
3027	*p += len;	3046	*p += len;
3028	ceph_decode_32_safe(p, end, len, bad);	3047	ceph_decode_32_safe(p, end, len, bad);
3029	ceph_decode_need(p, end, len, bad);	3048	ceph_decode_need(p, end, len, bad);
		3049	if (err_str && strnstr(*p, "blacklisted", len))
		3050	*blacklisted = true;
3030	*p += len;	3051	*p += len;
3031	}	3052	}
3032	return 0;	3053	return 0;
@@ -3050,6 +3071,7 @@ static void handle_session(struct ceph_mds_session *session, · 17 unmodified lines
3050	u64 seq;	3071	u64 seq;
3051	unsigned long features = 0;	3072	unsigned long features = 0;
3052	int wake = 0;	3073	int wake = 0;
		3074	bool blacklisted = false;
3053		3075
3054	/* decode */	3076	/* decode */
3055	ceph_decode_need(&p, end, sizeof(*h), bad);	3077	ceph_decode_need(&p, end, sizeof(*h), bad);
@@ -3062,7 +3084,7 @@ static void handle_session(struct ceph_mds_session *session, · 6 unmodified lines
3062	if (msg_version >= 3) {	3084	if (msg_version >= 3) {
3063	u32 len;	3085	u32 len;
3064	/* version >= 2, metadata */	3086	/* version >= 2, metadata */
3065	if (__decode_and_drop_session_metadata(&p, end) < 0)	3087	if (__decode_session_metadata(&p, end, &blacklisted) < 0)
3066	goto bad;	3088	goto bad;
3067	/* version >= 3, feature bits */	3089	/* version >= 3, feature bits */
3068	ceph_decode_32_safe(&p, end, len, bad);	3090	ceph_decode_32_safe(&p, end, len, bad);
@@ -3149,6 +3171,8 @@ static void handle_session(struct ceph_mds_session *session, · 80 unmodified lines
3149	session->s_state = CEPH_MDS_SESSION_REJECTED;	3171	session->s_state = CEPH_MDS_SESSION_REJECTED;
3150	cleanup_session_requests(mdsc, session);	3172	cleanup_session_requests(mdsc, session);
3151	remove_session_caps(session);	3173	remove_session_caps(session);
		3174	if (blacklisted)
		3175	mdsc->fsc->blacklisted = true;
3152	wake = 2; /* for good measure */	3176	wake = 2; /* for good measure */
3153	break;	3177	break;
3154		3178
@@ -3998,7 +4022,27 @@ static void lock_unlock_sessions(struct ceph_mds_client *mdsc) · 843 unmodified lines
3998	mutex_unlock(&mdsc->mutex);	4022	mutex_unlock(&mdsc->mutex);
3999	}	4023	}
4000		4024
		4025	static void maybe_recover_session(struct ceph_mds_client *mdsc)
		4026	{
		4027	struct ceph_fs_client *fsc = mdsc->fsc;
		4028
		4029	if (!ceph_test_mount_opt(fsc, CLEANRECOVER))
		4030	return;
		4031
		4032	if (READ_ONCE(fsc->mount_state) != CEPH_MOUNT_MOUNTED)
		4033	return;
		4034
		4035	if (!READ_ONCE(fsc->blacklisted))
		4036	return;
		4037
		4038	if (fsc->last_auto_reconnect &&
		4039	time_before(jiffies, fsc->last_auto_reconnect + HZ * 60 * 30))
		4040	return;
4001		4041
		4042	pr_info("auto reconnect after blacklisted\n");
		4043	fsc->last_auto_reconnect = jiffies;
		4044	ceph_force_reconnect(fsc->sb);
		4045	}
4002		4046
4003	/*	4047	/*
4004	* delayed work -- periodically trim expired leases, renew caps with mds	4048	* delayed work -- periodically trim expired leases, renew caps with mds
@@ -4044,7 +4088,9 @@ static void delayed_work(struct work_struct *work) · 39 unmodified lines
4044	pr_info("mds%d hung\n", s->s_mds);	4088	pr_info("mds%d hung\n", s->s_mds);
4045	}	4089	}
4046	}	4090	}
4047	if (s->s_state < CEPH_MDS_SESSION_OPEN) {	4091	if (s->s_state == CEPH_MDS_SESSION_NEW \|\|
		4092	s->s_state == CEPH_MDS_SESSION_RESTARTING \|\|
		4093	s->s_state == CEPH_MDS_SESSION_REJECTED) {
4048	/* this mds is failed or recovering, just wait */	4094	/* this mds is failed or recovering, just wait */
4049	ceph_put_mds_session(s);	4095	ceph_put_mds_session(s);
4050	continue;	4096	continue;
@@ -4072,6 +4118,8 @@ static void delayed_work(struct work_struct *work) · 21 unmodified lines
4072		4118
4073	ceph_trim_snapid_map(mdsc);	4119	ceph_trim_snapid_map(mdsc);
4074		4120
		4121	maybe_recover_session(mdsc);
		4122
4075	schedule_delayed(mdsc);	4123	schedule_delayed(mdsc);
4076	}	4124	}
4077		4125
@@ -4355,7 +4403,12 @@ void ceph_mdsc_force_umount(struct ceph_mds_client *mdsc) · 277 unmodified lines
4355	session = __ceph_lookup_mds_session(mdsc, mds);	4403	session = __ceph_lookup_mds_session(mdsc, mds);
4356	if (!session)	4404	if (!session)
4357	continue;	4405	continue;
		4406
		4407	if (session->s_state == CEPH_MDS_SESSION_REJECTED)
		4408	__unregister_session(mdsc, session);
		4409	__wake_requests(mdsc, &session->s_waiting);
4358	mutex_unlock(&mdsc->mutex);	4410	mutex_unlock(&mdsc->mutex);
		4411
4359	mutex_lock(&session->s_mutex);	4412	mutex_lock(&session->s_mutex);
4360	__close_session(mdsc, session);	4413	__close_session(mdsc, session);
4361	if (session->s_state == CEPH_MDS_SESSION_CLOSING) {	4414	if (session->s_state == CEPH_MDS_SESSION_CLOSING) {
@@ -4364,6 +4417,7 @@ void ceph_mdsc_force_umount(struct ceph_mds_client *mdsc) · 2 unmodified lines
4364	}	4417	}
4365	mutex_unlock(&session->s_mutex);	4418	mutex_unlock(&session->s_mutex);
4366	ceph_put_mds_session(session);	4419	ceph_put_mds_session(session);
		4420
4367	mutex_lock(&mdsc->mutex);	4421	mutex_lock(&mdsc->mutex);
4368	kick_requests(mdsc, mds);	4422	kick_requests(mdsc, mds);
4369	}	4423	}

fs/ceph/mds_client.h+4−4

@@ -148,9 +148,9 @@ enum { · 147 unmodified lines
148	CEPH_MDS_SESSION_OPENING = 2,	148	CEPH_MDS_SESSION_OPENING = 2,
149	CEPH_MDS_SESSION_OPEN = 3,	149	CEPH_MDS_SESSION_OPEN = 3,
150	CEPH_MDS_SESSION_HUNG = 4,	150	CEPH_MDS_SESSION_HUNG = 4,
151	CEPH_MDS_SESSION_CLOSING = 5,	151	CEPH_MDS_SESSION_RESTARTING = 5,
152	CEPH_MDS_SESSION_RESTARTING = 6,	152	CEPH_MDS_SESSION_RECONNECTING = 6,
153	CEPH_MDS_SESSION_RECONNECTING = 7,	153	CEPH_MDS_SESSION_CLOSING = 7,
154	CEPH_MDS_SESSION_REJECTED = 8,	154	CEPH_MDS_SESSION_REJECTED = 8,
155	};	155	};
156		156
@@ -176,7 +176,7 @@ struct ceph_mds_session { · 19 unmodified lines
176	spinlock_t s_cap_lock;	176	spinlock_t s_cap_lock;
177	struct list_head s_caps; /* all caps issued by this session */	177	struct list_head s_caps; /* all caps issued by this session */
178	struct ceph_cap *s_cap_iterator;	178	struct ceph_cap *s_cap_iterator;
179	int s_nr_caps, s_trim_caps;	179	int s_nr_caps;
180	int s_num_cap_releases;	180	int s_num_cap_releases;
181	int s_cap_reconnect;	181	int s_cap_reconnect;
182	int s_readonly;	182	int s_readonly;

fs/ceph/super.c+47−5

 	Opt_snapdirname,
 	Opt_mds_namespace,
 	Opt_fscache_uniq,
+	Opt_recover_session,
 	Opt_last_string,
 	/* string args above */
 	Opt_dirstat,
 	/* int args above */
 	{Opt_snapdirname, "snapdirname=%s"},
 	{Opt_mds_namespace, "mds_namespace=%s"},
+	{Opt_recover_session, "recover_session=%s"},
 	{Opt_fscache_uniq, "fsc=%s"},
 	/* string args above */
 	{Opt_dirstat, "dirstat"},
 		if (!fsopt->mds_namespace)
 			return -ENOMEM;
 		break;
+	case Opt_recover_session:
+		if (!strncmp(argstr[0].from, "no",
+			     argstr[0].to - argstr[0].from)) {
+			fsopt->flags &= ~CEPH_MOUNT_OPT_CLEANRECOVER;
+		} else if (!strncmp(argstr[0].from, "clean",
+				    argstr[0].to - argstr[0].from)) {
+			fsopt->flags |= CEPH_MOUNT_OPT_CLEANRECOVER;
+		} else {
+			return -EINVAL;
+		}
+		break;
 	case Opt_fscache_uniq:
 		kfree(fsopt->fscache_uniq);
 		fsopt->fscache_uniq = kstrndup(argstr[0].from,
 	if (fsopt->mds_namespace)
 		seq_show_option(m, "mds_namespace", fsopt->mds_namespace);
+	if (fsopt->flags & CEPH_MOUNT_OPT_CLEANRECOVER)
+		seq_show_option(m, "recover_session", "clean");
 	if (fsopt->wsize != CEPH_MAX_WRITE_SIZE)
 		seq_printf(m, ",wsize=%d", fsopt->wsize);
 	if (fsopt->rsize != CEPH_MAX_READ_SIZE)
 	fsc->sb = NULL;
 	fsc->mount_state = CEPH_MOUNT_MOUNTING;
+	fsc->filp_gen = 1;
 	atomic_long_set(&fsc->writeback_count, 0);
 {
 	dout("destroy_fs_client %p\n", fsc);
+	ceph_mdsc_destroy(fsc);
 	destroy_workqueue(fsc->inode_wq);
 	destroy_workqueue(fsc->cap_wq);
 	fsc->mount_state = CEPH_MOUNT_SHUTDOWN;
 	ceph_osdc_abort_requests(&fsc->client->osdc, -EIO);
 	ceph_mdsc_force_umount(fsc->mdsc);
-	return;
+	fsc->filp_gen++; // invalidate open files
 }
 static int ceph_remount(struct super_block *sb, int *flags, char *data)
 	}
 	if (ceph_sb_to_client(sb) != fsc) {
-		ceph_mdsc_destroy(fsc);
 		destroy_fs_client(fsc);
 		fsc = ceph_sb_to_client(sb);
 		dout("get_sb got existing client %p\n", fsc);
 	goto out_final;
 out:
-	ceph_mdsc_destroy(fsc);
 	destroy_fs_client(fsc);
 out_final:
 	dout("ceph_mount fail %ld\n", PTR_ERR(res));
 	ceph_fscache_unregister_fs(fsc);
-	ceph_mdsc_destroy(fsc);
 	destroy_fs_client(fsc);
 	free_anon_bdev(dev);
 }
 };
 MODULE_ALIAS_FS("ceph");
+int ceph_force_reconnect(struct super_block *sb)
+{
+	struct ceph_fs_client *fsc = ceph_sb_to_client(sb);
+	int err = 0;
+	ceph_umount_begin(sb);
+	/* Make sure all page caches get invalidated.
+	 * see remove_session_caps_cb() */
+	flush_workqueue(fsc->inode_wq);
+	/* In case that we were blacklisted. This also reset
+	 * all mon/osd connections */
+	ceph_reset_client_addr(fsc->client);
+	ceph_osdc_clear_abort_err(&fsc->client->osdc);
+	fsc->blacklisted = false;
+	fsc->mount_state = CEPH_MOUNT_MOUNTED;
+	if (sb->s_root) {
+		err = __ceph_do_getattr(d_inode(sb->s_root), NULL,
+					CEPH_STAT_CAP_INODE, true);
+	}
+	return err;
+}
 static int __init init_ceph(void)
 {
 	int ret = init_caches();

fs/ceph/super.h+32−17

@@ -16,6 +16,7 @@ · 15 unmodified lines
16	#include <linux/slab.h>	16	#include <linux/slab.h>
17	#include <linux/posix_acl.h>	17	#include <linux/posix_acl.h>
18	#include <linux/refcount.h>	18	#include <linux/refcount.h>
		19	#include <linux/security.h>
19		20
20	#include <linux/ceph/libceph.h>	21	#include <linux/ceph/libceph.h>
21		22
@@ -31,6 +32,7 @@ · 9 unmodified lines
31	#define CEPH_BLOCK_SHIFT 22 /* 4 MB */	32	#define CEPH_BLOCK_SHIFT 22 /* 4 MB */
32	#define CEPH_BLOCK (1 << CEPH_BLOCK_SHIFT)	33	#define CEPH_BLOCK (1 << CEPH_BLOCK_SHIFT)
33		34
		35	#define CEPH_MOUNT_OPT_CLEANRECOVER (1<<1) /* auto reonnect (clean mode) after blacklisted */
34	#define CEPH_MOUNT_OPT_DIRSTAT (1<<4) /* `cat dirname` for stats */	36	#define CEPH_MOUNT_OPT_DIRSTAT (1<<4) /* `cat dirname` for stats */
35	#define CEPH_MOUNT_OPT_RBYTES (1<<5) /* dir st_bytes = rbytes */	37	#define CEPH_MOUNT_OPT_RBYTES (1<<5) /* dir st_bytes = rbytes */
36	#define CEPH_MOUNT_OPT_NOASYNCREADDIR (1<<7) /* no dcache readdir */	38	#define CEPH_MOUNT_OPT_NOASYNCREADDIR (1<<7) /* no dcache readdir */
@@ -101,6 +103,11 @@ struct ceph_fs_client { · 64 unmodified lines
101	struct ceph_client *client;	103	struct ceph_client *client;
102		104
103	unsigned long mount_state;	105	unsigned long mount_state;
		106
		107	unsigned long last_auto_reconnect;
		108	bool blacklisted;
		109
		110	u32 filp_gen;
104	loff_t max_file_size;	111	loff_t max_file_size;
105		112
106	struct ceph_mds_client *mdsc;	113	struct ceph_mds_client *mdsc;
@@ -395,6 +402,8 @@ struct ceph_inode_info { · 288 unmodified lines
395	struct fscache_cookie *fscache;	402	struct fscache_cookie *fscache;
396	u32 i_fscache_gen;	403	u32 i_fscache_gen;
397	#endif	404	#endif
		405	errseq_t i_meta_err;
		406
398	struct inode vfs_inode; /* at end */	407	struct inode vfs_inode; /* at end */
399	};	408	};
400		409
@@ -499,17 +508,16 @@ static inline struct inode ceph_find_inode(struct super_block sb, · 98 unmodified lines
499	#define CEPH_I_DIR_ORDERED (1 << 0) /* dentries in dir are ordered */	508	#define CEPH_I_DIR_ORDERED (1 << 0) /* dentries in dir are ordered */
500	#define CEPH_I_NODELAY (1 << 1) /* do not delay cap release */	509	#define CEPH_I_NODELAY (1 << 1) /* do not delay cap release */
501	#define CEPH_I_FLUSH (1 << 2) /* do not delay flush of dirty metadata */	510	#define CEPH_I_FLUSH (1 << 2) /* do not delay flush of dirty metadata */
502	#define CEPH_I_NOFLUSH (1 << 3) /* do not flush dirty caps */	511	#define CEPH_I_POOL_PERM (1 << 3) /* pool rd/wr bits are valid */
503	#define CEPH_I_POOL_PERM (1 << 4) /* pool rd/wr bits are valid */	512	#define CEPH_I_POOL_RD (1 << 4) /* can read from pool */
504	#define CEPH_I_POOL_RD (1 << 5) /* can read from pool */	513	#define CEPH_I_POOL_WR (1 << 5) /* can write to pool */
505	#define CEPH_I_POOL_WR (1 << 6) /* can write to pool */	514	#define CEPH_I_SEC_INITED (1 << 6) /* security initialized */
506	#define CEPH_I_SEC_INITED (1 << 7) /* security initialized */	515	#define CEPH_I_CAP_DROPPED (1 << 7) /* caps were forcibly dropped */
507	#define CEPH_I_CAP_DROPPED (1 << 8) /* caps were forcibly dropped */	516	#define CEPH_I_KICK_FLUSH (1 << 8) /* kick flushing caps */
508	#define CEPH_I_KICK_FLUSH (1 << 9) /* kick flushing caps */	517	#define CEPH_I_FLUSH_SNAPS (1 << 9) /* need flush snapss */
509	#define CEPH_I_FLUSH_SNAPS (1 << 10) /* need flush snapss */	518	#define CEPH_I_ERROR_WRITE (1 << 10) /* have seen write errors */
510	#define CEPH_I_ERROR_WRITE (1 << 11) /* have seen write errors */	519	#define CEPH_I_ERROR_FILELOCK (1 << 11) /* have seen file lock errors */
511	#define CEPH_I_ERROR_FILELOCK (1 << 12) /* have seen file lock errors */	520	#define CEPH_I_ODIRECT (1 << 12) /* inode in direct I/O mode */
512
513		521
514	/*	522	/*
515	* Masks of ceph inode work.	523	* Masks of ceph inode work.
@@ -703,6 +711,10 @@ struct ceph_file_info { · 187 unmodified lines
703		711
704	spinlock_t rw_contexts_lock;	712	spinlock_t rw_contexts_lock;
705	struct list_head rw_contexts;	713	struct list_head rw_contexts;
		714
		715	errseq_t meta_err;
		716	u32 filp_gen;
		717	atomic_t num_locks;
706	};	718	};
707		719
708	struct ceph_dir_file_info {	720	struct ceph_dir_file_info {
@@ -842,7 +854,8 @@ static inline int default_congestion_kb(void) · 133 unmodified lines
842	}	854	}
843		855
844		856
845		857	/* super.c */
		858	extern int ceph_force_reconnect(struct super_block *sb);
846	/* snap.c */	859	/* snap.c */
847	struct ceph_snap_realm ceph_lookup_snap_realm(struct ceph_mds_client mdsc,	860	struct ceph_snap_realm ceph_lookup_snap_realm(struct ceph_mds_client mdsc,
848	u64 ino);	861	u64 ino);
@@ -959,7 +972,10 @@ static inline bool ceph_security_xattr_wanted(struct inode *in) · 110 unmodified lines
959	#ifdef CONFIG_CEPH_FS_SECURITY_LABEL	972	#ifdef CONFIG_CEPH_FS_SECURITY_LABEL
960	extern int ceph_security_init_secctx(struct dentry *dentry, umode_t mode,	973	extern int ceph_security_init_secctx(struct dentry *dentry, umode_t mode,
961	struct ceph_acl_sec_ctx *ctx);	974	struct ceph_acl_sec_ctx *ctx);
962	extern void ceph_security_invalidate_secctx(struct inode *inode);	975	static inline void ceph_security_invalidate_secctx(struct inode *inode)
		976	{
		977	security_inode_invalidate_secctx(inode);
		978	}
963	#else	979	#else
964	static inline int ceph_security_init_secctx(struct dentry *dentry, umode_t mode,	980	static inline int ceph_security_init_secctx(struct dentry *dentry, umode_t mode,
965	struct ceph_acl_sec_ctx *ctx)	981	struct ceph_acl_sec_ctx *ctx)
@@ -1039,7 +1055,6 @@ extern void ceph_kick_flushing_caps(struct ceph_mds_client *mdsc, · 73 unmodified lines
1039	struct ceph_mds_session *session);	1055	struct ceph_mds_session *session);
1040	extern struct ceph_cap ceph_get_cap_for_mds(struct ceph_inode_info ci,	1056	extern struct ceph_cap ceph_get_cap_for_mds(struct ceph_inode_info ci,
1041	int mds);	1057	int mds);
1042	extern int ceph_get_cap_mds(struct inode *inode);
1043	extern void ceph_get_cap_refs(struct ceph_inode_info *ci, int caps);	1058	extern void ceph_get_cap_refs(struct ceph_inode_info *ci, int caps);
1044	extern void ceph_put_cap_refs(struct ceph_inode_info *ci, int had);	1059	extern void ceph_put_cap_refs(struct ceph_inode_info *ci, int had);
1045	extern void ceph_put_wrbuffer_cap_refs(struct ceph_inode_info *ci, int nr,	1060	extern void ceph_put_wrbuffer_cap_refs(struct ceph_inode_info *ci, int nr,
@@ -1058,9 +1073,9 @@ extern int ceph_encode_dentry_release(void *p, struct dentry dn, · 12 unmodified lines
1058	struct inode *dir,	1073	struct inode *dir,
1059	int mds, int drop, int unless);	1074	int mds, int drop, int unless);
1060		1075
1061	extern int ceph_get_caps(struct ceph_inode_info *ci, int need, int want,	1076	extern int ceph_get_caps(struct file *filp, int need, int want,
1062	loff_t endoff, int got, struct page *pinned_page);	1077	loff_t endoff, int got, struct page *pinned_page);
1063	extern int ceph_try_get_caps(struct ceph_inode_info *ci,	1078	extern int ceph_try_get_caps(struct inode *inode,
1064	int need, int want, bool nonblock, int *got);	1079	int need, int want, bool nonblock, int *got);
1065		1080
1066	/* for counting open files by mode */	1081	/* for counting open files by mode */
@@ -1071,7 +1086,7 @@ extern void ceph_put_fmode(struct ceph_inode_info *ci, int mode); · 4 unmodified lines
1071	extern const struct address_space_operations ceph_aops;	1086	extern const struct address_space_operations ceph_aops;
1072	extern int ceph_mmap(struct file file, struct vm_area_struct vma);	1087	extern int ceph_mmap(struct file file, struct vm_area_struct vma);
1073	extern int ceph_uninline_data(struct file filp, struct page locked_page);	1088	extern int ceph_uninline_data(struct file filp, struct page locked_page);
1074	extern int ceph_pool_perm_check(struct ceph_inode_info *ci, int need);	1089	extern int ceph_pool_perm_check(struct inode *inode, int need);
1075	extern void ceph_pool_perm_destroy(struct ceph_mds_client* mdsc);	1090	extern void ceph_pool_perm_destroy(struct ceph_mds_client* mdsc);
1076		1091
1077	/* file.c */	1092	/* file.c */

fs/ceph/xattr.c+6−70

@@ -20,7 +20,8 @@ static int __remove_xattr(struct ceph_inode_info *ci, · 19 unmodified lines
20		20
21	static bool ceph_is_valid_xattr(const char *name)	21	static bool ceph_is_valid_xattr(const char *name)
22	{	22	{
23	return !strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN) \|\|	23	return !strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) \|\|
		24	!strncmp(name, XATTR_CEPH_PREFIX, XATTR_CEPH_PREFIX_LEN) \|\|
24	!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) \|\|	25	!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN) \|\|
25	!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);	26	!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN);
26	}	27	}
@@ -892,7 +893,8 @@ ssize_t __ceph_getxattr(struct inode inode, const char name, void *value, · 865 unmodified lines
892	memcpy(value, xattr->val, xattr->val_len);	893	memcpy(value, xattr->val, xattr->val_len);
893		894
894	if (current->journal_info &&	895	if (current->journal_info &&
895	!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN))	896	!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) &&
		897	security_ismaclabel(name + XATTR_SECURITY_PREFIX_LEN))
896	ci->i_ceph_flags \|= CEPH_I_SEC_INITED;	898	ci->i_ceph_flags \|= CEPH_I_SEC_INITED;
897	out:	899	out:
898	spin_unlock(&ci->i_ceph_lock);	900	spin_unlock(&ci->i_ceph_lock);
@@ -903,11 +905,9 @@ ssize_t ceph_listxattr(struct dentry dentry, char names, size_t size) · 4 unmodified lines
903	{	905	{
904	struct inode *inode = d_inode(dentry);	906	struct inode *inode = d_inode(dentry);
905	struct ceph_inode_info *ci = ceph_inode(inode);	907	struct ceph_inode_info *ci = ceph_inode(inode);
906	struct ceph_vxattr *vxattrs = ceph_inode_vxattrs(inode);
907	bool len_only = (size == 0);	908	bool len_only = (size == 0);
908	u32 namelen;	909	u32 namelen;
909	int err;	910	int err;
910	int i;
911		911
912	spin_lock(&ci->i_ceph_lock);	912	spin_lock(&ci->i_ceph_lock);
913	dout("listxattr %p ver=%lld index_ver=%lld\n", inode,	913	dout("listxattr %p ver=%lld index_ver=%lld\n", inode,
@@ -936,33 +936,6 @@ ssize_t ceph_listxattr(struct dentry dentry, char names, size_t size) · 22 unmodified lines
936	names = __copy_xattr_names(ci, names);	936	names = __copy_xattr_names(ci, names);
937	size -= namelen;	937	size -= namelen;
938	}	938	}
939
940
941	/* virtual xattr names, too */
942	if (vxattrs) {
943	for (i = 0; vxattrs[i].name; i++) {
944	size_t this_len;
945
946	if (vxattrs[i].flags & VXATTR_FLAG_HIDDEN)
947	continue;
948	if (vxattrs[i].exists_cb && !vxattrs[i].exists_cb(ci))
949	continue;
950
951	this_len = strlen(vxattrs[i].name) + 1;
952	namelen += this_len;
953	if (len_only)
954	continue;
955
956	if (this_len > size) {
957	err = -ERANGE;
958	goto out;
959	}
960
961	memcpy(names, vxattrs[i].name, this_len);
962	names += this_len;
963	size -= this_len;
964	}
965	}
966	err = namelen;	939	err = namelen;
967	out:	940	out:
968	spin_unlock(&ci->i_ceph_lock);	941	spin_unlock(&ci->i_ceph_lock);
@@ -1293,42 +1266,8 @@ out: · 324 unmodified lines
1293	ceph_pagelist_release(pagelist);	1266	ceph_pagelist_release(pagelist);
1294	return err;	1267	return err;
1295	}	1268	}
1296		1269	#endif /* CONFIG_CEPH_FS_SECURITY_LABEL */
1297	void ceph_security_invalidate_secctx(struct inode *inode)	1270	#endif /* CONFIG_SECURITY */
1298	{
1299	security_inode_invalidate_secctx(inode);
1300	}
1301
1302	static int ceph_xattr_set_security_label(const struct xattr_handler *handler,
1303	struct dentry unused, struct inode inode,
1304	const char key, const void buf,
1305	size_t buflen, int flags)
1306	{
1307	if (security_ismaclabel(key)) {
1308	const char *name = xattr_full_name(handler, key);
1309	return __ceph_setxattr(inode, name, buf, buflen, flags);
1310	}
1311	return -EOPNOTSUPP;
1312	}
1313
1314	static int ceph_xattr_get_security_label(const struct xattr_handler *handler,
1315	struct dentry unused, struct inode inode,
1316	const char key, void buf, size_t buflen)
1317	{
1318	if (security_ismaclabel(key)) {
1319	const char *name = xattr_full_name(handler, key);
1320	return __ceph_getxattr(inode, name, buf, buflen);
1321	}
1322	return -EOPNOTSUPP;
1323	}
1324
1325	static const struct xattr_handler ceph_security_label_handler = {
1326	.prefix = XATTR_SECURITY_PREFIX,
1327	.get = ceph_xattr_get_security_label,
1328	.set = ceph_xattr_set_security_label,
1329	};
1330	#endif
1331	#endif
1332		1271
1333	void ceph_release_acl_sec_ctx(struct ceph_acl_sec_ctx *as_ctx)	1272	void ceph_release_acl_sec_ctx(struct ceph_acl_sec_ctx *as_ctx)
1334	{	1273	{
@@ -1351,9 +1290,6 @@ const struct xattr_handler *ceph_xattr_handlers[] = { · 16 unmodified lines
1351	#ifdef CONFIG_CEPH_FS_POSIX_ACL	1290	#ifdef CONFIG_CEPH_FS_POSIX_ACL
1352	&posix_acl_access_xattr_handler,	1291	&posix_acl_access_xattr_handler,
1353	&posix_acl_default_xattr_handler,	1292	&posix_acl_default_xattr_handler,
1354	#endif
1355	#ifdef CONFIG_CEPH_FS_SECURITY_LABEL
1356	&ceph_security_label_handler,
1357	#endif	1293	#endif
1358	&ceph_other_xattr_handler,	1294	&ceph_other_xattr_handler,
1359	NULL,	1295	NULL,

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

@@ -293,6 +293,7 @@ struct ceph_client ceph_create_client(struct ceph_options opt, void *private); · 292 unmodified lines
293	struct ceph_entity_addr ceph_client_addr(struct ceph_client client);	293	struct ceph_entity_addr ceph_client_addr(struct ceph_client client);
294	u64 ceph_client_gid(struct ceph_client *client);	294	u64 ceph_client_gid(struct ceph_client *client);
295	extern void ceph_destroy_client(struct ceph_client *client);	295	extern void ceph_destroy_client(struct ceph_client *client);
		296	extern void ceph_reset_client_addr(struct ceph_client *client);
296	extern int __ceph_open_session(struct ceph_client *client,	297	extern int __ceph_open_session(struct ceph_client *client,
297	unsigned long started);	298	unsigned long started);
298	extern int ceph_open_session(struct ceph_client *client);	299	extern int ceph_open_session(struct ceph_client *client);

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

@@ -337,6 +337,7 @@ extern void ceph_msgr_flush(void); · 336 unmodified lines
337	extern void ceph_messenger_init(struct ceph_messenger *msgr,	337	extern void ceph_messenger_init(struct ceph_messenger *msgr,
338	struct ceph_entity_addr *myaddr);	338	struct ceph_entity_addr *myaddr);
339	extern void ceph_messenger_fini(struct ceph_messenger *msgr);	339	extern void ceph_messenger_fini(struct ceph_messenger *msgr);
		340	extern void ceph_messenger_reset_nonce(struct ceph_messenger *msgr);
340		341
341	extern void ceph_con_init(struct ceph_connection con, void private,	342	extern void ceph_con_init(struct ceph_connection con, void private,
342	const struct ceph_connection_operations *ops,	343	const struct ceph_connection_operations *ops,

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

@@ -109,6 +109,7 @@ extern int ceph_monmap_contains(struct ceph_monmap *m, · 108 unmodified lines
109		109
110	extern int ceph_monc_init(struct ceph_mon_client monc, struct ceph_client cl);	110	extern int ceph_monc_init(struct ceph_mon_client monc, struct ceph_client cl);
111	extern void ceph_monc_stop(struct ceph_mon_client *monc);	111	extern void ceph_monc_stop(struct ceph_mon_client *monc);
		112	extern void ceph_monc_reopen_session(struct ceph_mon_client *monc);
112		113
113	enum {	114	enum {
114	CEPH_SUB_MONMAP = 0,	115	CEPH_SUB_MONMAP = 0,

include/linux/ceph/osd_client.h+2−0

 extern int ceph_osdc_init(struct ceph_osd_client *osdc,
 			  struct ceph_client *client);
 extern void ceph_osdc_stop(struct ceph_osd_client *osdc);
+extern void ceph_osdc_reopen_osds(struct ceph_osd_client *osdc);
 extern void ceph_osdc_handle_reply(struct ceph_osd_client *osdc,
 				   struct ceph_msg *msg);
 				 struct ceph_msg *msg);
 void ceph_osdc_update_epoch_barrier(struct ceph_osd_client *osdc, u32 eb);
 void ceph_osdc_abort_requests(struct ceph_osd_client *osdc, int err);
+void ceph_osdc_clear_abort_err(struct ceph_osd_client *osdc);
 #define osd_req_op_data(oreq, whch, typ, fld)				\
 ({									\

net/ceph/ceph_common.c+31−6

@@ -13,6 +13,7 @@ · 12 unmodified lines
13	#include <linux/nsproxy.h>	13	#include <linux/nsproxy.h>
14	#include <linux/parser.h>	14	#include <linux/parser.h>
15	#include <linux/sched.h>	15	#include <linux/sched.h>
		16	#include <linux/sched/mm.h>
16	#include <linux/seq_file.h>	17	#include <linux/seq_file.h>
17	#include <linux/slab.h>	18	#include <linux/slab.h>
18	#include <linux/statfs.h>	19	#include <linux/statfs.h>
@@ -185,18 +186,34 @@ int ceph_compare_options(struct ceph_options *new_opt, · 166 unmodified lines
185	}	186	}
186	EXPORT_SYMBOL(ceph_compare_options);	187	EXPORT_SYMBOL(ceph_compare_options);
187		188
		189	/*
		190	* kvmalloc() doesn't fall back to the vmalloc allocator unless flags are
		191	* compatible with (a superset of) GFP_KERNEL. This is because while the
		192	* actual pages are allocated with the specified flags, the page table pages
		193	* are always allocated with GFP_KERNEL. map_vm_area() doesn't even take
		194	* flags because GFP_KERNEL is hard-coded in {p4d,pud,pmd,pte}_alloc().
		195	*
		196	* ceph_kvmalloc() may be called with GFP_KERNEL, GFP_NOFS or GFP_NOIO.
		197	*/
188	void *ceph_kvmalloc(size_t size, gfp_t flags)	198	void *ceph_kvmalloc(size_t size, gfp_t flags)
189	{	199	{
190	if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER)) {	200	void *p;
191	void *ptr = kmalloc(size, flags \| __GFP_NOWARN);	201
192	if (ptr)	202	if ((flags & (__GFP_IO \| __GFP_FS)) == (__GFP_IO \| __GFP_FS)) {
193	return ptr;	203	p = kvmalloc(size, flags);
		204	} else if ((flags & (__GFP_IO \| __GFP_FS)) == __GFP_IO) {
		205	unsigned int nofs_flag = memalloc_nofs_save();
		206	p = kvmalloc(size, GFP_KERNEL);
		207	memalloc_nofs_restore(nofs_flag);
		208	} else {
		209	unsigned int noio_flag = memalloc_noio_save();
		210	p = kvmalloc(size, GFP_KERNEL);
		211	memalloc_noio_restore(noio_flag);
194	}	212	}
195		213
196	return __vmalloc(size, flags, PAGE_KERNEL);	214	return p;
197	}	215	}
198		216
199
200	static int parse_fsid(const char str, struct ceph_fsid fsid)	217	static int parse_fsid(const char str, struct ceph_fsid fsid)
201	{	218	{
202	int i = 0;	219	int i = 0;
@@ -694,6 +711,14 @@ void ceph_destroy_client(struct ceph_client *client) · 491 unmodified lines
694	}	711	}
695	EXPORT_SYMBOL(ceph_destroy_client);	712	EXPORT_SYMBOL(ceph_destroy_client);
696		713
		714	void ceph_reset_client_addr(struct ceph_client *client)
		715	{
		716	ceph_messenger_reset_nonce(&client->msgr);
		717	ceph_monc_reopen_session(&client->monc);
		718	ceph_osdc_reopen_osds(&client->osdc);
		719	}
		720	EXPORT_SYMBOL(ceph_reset_client_addr);
		721
697	/*	722	/*
698	* true if we have the mon map (and have thus joined the cluster)	723	* true if we have the mon map (and have thus joined the cluster)
699	*/	724	*/

net/ceph/messenger.c+6−0

 }
+void ceph_messenger_reset_nonce(struct ceph_messenger *msgr)
+{
+	u32 nonce = le32_to_cpu(msgr->inst.addr.nonce) + 1000000;
+	msgr->inst.addr.nonce = cpu_to_le32(nonce);
+	encode_my_addr(msgr);
+}
 /*
  * initialize a new messenger instance

net/ceph/mon_client.c+7−0

@@ -213,6 +213,13 @@ static void reopen_session(struct ceph_mon_client *monc) · 212 unmodified lines
213	__open_session(monc);	213	__open_session(monc);
214	}	214	}
215		215
		216	void ceph_monc_reopen_session(struct ceph_mon_client *monc)
		217	{
		218	mutex_lock(&monc->mutex);
		219	reopen_session(monc);
		220	mutex_unlock(&monc->mutex);
		221	}
		222
216	static void un_backoff(struct ceph_mon_client *monc)	223	static void un_backoff(struct ceph_mon_client *monc)
217	{	224	{
218	monc->hunt_mult /= 2; /* reduce by 50% */	225	monc->hunt_mult /= 2; /* reduce by 50% */

net/ceph/osd_client.c+53−12

 	struct ceph_pagelist *pagelist;
 	size_t payload_len = 0;
 	size_t size;
+	int ret;
 	op = _osd_req_op_init(osd_req, which, CEPH_OSD_OP_CALL, 0);
 	size = strlen(class);
 	BUG_ON(size > (size_t) U8_MAX);
 	op->cls.class_len = size;
-	ceph_pagelist_append(pagelist, class, size);
+	ret = ceph_pagelist_append(pagelist, class, size);
+	if (ret)
+		goto err_pagelist_free;
 	payload_len += size;
 	op->cls.method_name = method;
 	size = strlen(method);
 	BUG_ON(size > (size_t) U8_MAX);
 	op->cls.method_len = size;
-	ceph_pagelist_append(pagelist, method, size);
+	ret = ceph_pagelist_append(pagelist, method, size);
+	if (ret)
+		goto err_pagelist_free;
 	payload_len += size;
 	osd_req_op_cls_request_info_pagelist(osd_req, which, pagelist);
 	op->indata_len = payload_len;
 	return 0;
+err_pagelist_free:
+	ceph_pagelist_release(pagelist);
+	return ret;
 }
 EXPORT_SYMBOL(osd_req_op_cls_init);
 						      opcode, 0);
 	struct ceph_pagelist *pagelist;
 	size_t payload_len;
+	int ret;
 	BUG_ON(opcode != CEPH_OSD_OP_SETXATTR && opcode != CEPH_OSD_OP_CMPXATTR);
 	payload_len = strlen(name);
 	op->xattr.name_len = payload_len;
-	ceph_pagelist_append(pagelist, name, payload_len);
+	ret = ceph_pagelist_append(pagelist, name, payload_len);
+	if (ret)
+		goto err_pagelist_free;
 	op->xattr.value_len = size;
-	ceph_pagelist_append(pagelist, value, size);
+	ret = ceph_pagelist_append(pagelist, value, size);
+	if (ret)
+		goto err_pagelist_free;
 	payload_len += size;
 	op->xattr.cmp_op = cmp_op;
 	ceph_osd_data_pagelist_init(&op->xattr.osd_data, pagelist);
 	op->indata_len = payload_len;
 	return 0;
+err_pagelist_free:
+	ceph_pagelist_release(pagelist);
+	return ret;
 }
 EXPORT_SYMBOL(osd_req_op_xattr_init);
 static enum calc_target_result calc_target(struct ceph_osd_client *osdc,
 					   struct ceph_osd_request_target *t,
-					   struct ceph_connection *con,
 					   bool any_change)
 {
 	struct ceph_pg_pool_info *pi;
 	dout("%s req %p wrlocked %d\n", __func__, req, wrlocked);
 again:
-	ct_res = calc_target(osdc, &req->r_t, NULL, false);
+	ct_res = calc_target(osdc, &req->r_t, false);
 	if (ct_res == CALC_TARGET_POOL_DNE && !wrlocked)
 		goto promote;
 }
 EXPORT_SYMBOL(ceph_osdc_abort_requests);
+void ceph_osdc_clear_abort_err(struct ceph_osd_client *osdc)
+{
+	down_write(&osdc->lock);
+	osdc->abort_err = 0;
+	up_write(&osdc->lock);
+}
+EXPORT_SYMBOL(ceph_osdc_clear_abort_err);
 static void update_epoch_barrier(struct ceph_osd_client *osdc, u32 eb)
 {
 	if (likely(eb > osdc->epoch_barrier)) {
 		lreq->reg_req->r_ops[0].notify.cookie = lreq->linger_id;
 	}
-	calc_target(osdc, &lreq->t, NULL, false);
+	calc_target(osdc, &lreq->t, false);
 	osd = lookup_create_osd(osdc, lreq->t.osd, true);
 	link_linger(osd, lreq);
 	struct ceph_osd_client *osdc = lreq->osdc;
 	enum calc_target_result ct_res;
-	ct_res = calc_target(osdc, &lreq->t, NULL, true);
+	ct_res = calc_target(osdc, &lreq->t, true);
 	if (ct_res == CALC_TARGET_NEED_RESEND) {
 		struct ceph_osd *osd;
 		n = rb_next(n); /* unlink_request(), check_pool_dne() */
 		dout("%s req %p tid %llu\n", __func__, req, req->r_tid);
-		ct_res = calc_target(osdc, &req->r_t, &req->r_osd->o_con,
+		ct_res = calc_target(osdc, &req->r_t, false);
-				     false);
 		switch (ct_res) {
 		case CALC_TARGET_NO_ACTION:
 			force_resend_writes = cleared_full ||
 		n = rb_next(n);
 		if (req->r_t.epoch < osdc->osdmap->epoch) {
-			ct_res = calc_target(osdc, &req->r_t, NULL, false);
+			ct_res = calc_target(osdc, &req->r_t, false);
 			if (ct_res == CALC_TARGET_POOL_DNE) {
 				erase_request(need_resend, req);
 				check_pool_dne(req);
 }
 EXPORT_SYMBOL(ceph_osdc_call);
+/*
+ * reset all osd connections
+ */
+void ceph_osdc_reopen_osds(struct ceph_osd_client *osdc)
+{
+	struct rb_node *n;
+	down_write(&osdc->lock);
+	for (n = rb_first(&osdc->osds); n; ) {
+		struct ceph_osd *osd = rb_entry(n, struct ceph_osd, o_node);
+		n = rb_next(n);
+		if (!reopen_osd(osd))
+			kick_osd_requests(osd);
+	}
+	up_write(&osdc->lock);
+}
 /*
  * init, shutdown
  */

net/ceph/osdmap.c+43−26

 				 struct ceph_pg_pool_info, node);
 		__remove_pg_pool(&map->pg_pools, pi);
 	}
-	kfree(map->osd_state);
+	kvfree(map->osd_state);
-	kfree(map->osd_weight);
+	kvfree(map->osd_weight);
-	kfree(map->osd_addr);
+	kvfree(map->osd_addr);
-	kfree(map->osd_primary_affinity);
+	kvfree(map->osd_primary_affinity);
-	kfree(map->crush_workspace);
+	kvfree(map->crush_workspace);
 	kfree(map);
 }
  *
  * The new elements are properly initialized.
  */
-static int osdmap_set_max_osd(struct ceph_osdmap *map, int max)
+static int osdmap_set_max_osd(struct ceph_osdmap *map, u32 max)
 {
 	u32 *state;
 	u32 *weight;
 	struct ceph_entity_addr *addr;
+	u32 to_copy;
 	int i;
-	state = krealloc(map->osd_state, max*sizeof(*state), GFP_NOFS);
+	dout("%s old %u new %u\n", __func__, map->max_osd, max);
-	if (!state)
+	if (max == map->max_osd)
-		return -ENOMEM;
+		return 0;
-	map->osd_state = state;
-	weight = krealloc(map->osd_weight, max*sizeof(*weight), GFP_NOFS);
+	state = ceph_kvmalloc(array_size(max, sizeof(*state)), GFP_NOFS);
-	if (!weight)
+	weight = ceph_kvmalloc(array_size(max, sizeof(*weight)), GFP_NOFS);
+	addr = ceph_kvmalloc(array_size(max, sizeof(*addr)), GFP_NOFS);
+	if (!state || !weight || !addr) {
+		kvfree(state);
+		kvfree(weight);
+		kvfree(addr);
 		return -ENOMEM;
-	map->osd_weight = weight;
+	}
-	addr = krealloc(map->osd_addr, max*sizeof(*addr), GFP_NOFS);
+	to_copy = min(map->max_osd, max);
-	if (!addr)
+	if (map->osd_state) {
-		return -ENOMEM;
+		memcpy(state, map->osd_state, to_copy * sizeof(*state));
-	map->osd_addr = addr;
+		memcpy(weight, map->osd_weight, to_copy * sizeof(*weight));
+		memcpy(addr, map->osd_addr, to_copy * sizeof(*addr));
+		kvfree(map->osd_state);
+		kvfree(map->osd_weight);
+		kvfree(map->osd_addr);
+	}
+	map->osd_state = state;
+	map->osd_weight = weight;
+	map->osd_addr = addr;
 	for (i = map->max_osd; i < max; i++) {
 		map->osd_state[i] = 0;
 		map->osd_weight[i] = CEPH_OSD_OUT;
 	if (map->osd_primary_affinity) {
 		u32 *affinity;
-		affinity = krealloc(map->osd_primary_affinity,
+		affinity = ceph_kvmalloc(array_size(max, sizeof(*affinity)),
-				    max*sizeof(*affinity), GFP_NOFS);
+					 GFP_NOFS);
 		if (!affinity)
 			return -ENOMEM;
-		map->osd_primary_affinity = affinity;
+		memcpy(affinity, map->osd_primary_affinity,
+		       to_copy * sizeof(*affinity));
+		kvfree(map->osd_primary_affinity);
+		map->osd_primary_affinity = affinity;
 		for (i = map->max_osd; i < max; i++)
 			map->osd_primary_affinity[i] =
 			    CEPH_OSD_DEFAULT_PRIMARY_AFFINITY;
 	work_size = crush_work_size(crush, CEPH_PG_MAX_SIZE);
 	dout("%s work_size %zu bytes\n", __func__, work_size);
-	workspace = kmalloc(work_size, GFP_NOIO);
+	workspace = ceph_kvmalloc(work_size, GFP_NOIO);
 	if (!workspace) {
 		crush_destroy(crush);
 		return -ENOMEM;
 	if (map->crush)
 		crush_destroy(map->crush);
-	kfree(map->crush_workspace);
+	kvfree(map->crush_workspace);
 	map->crush = crush;
 	map->crush_workspace = workspace;
 	return 0;
 	if (!map->osd_primary_affinity) {
 		int i;
-		map->osd_primary_affinity = kmalloc_array(map->max_osd,
+		map->osd_primary_affinity = ceph_kvmalloc(
-							  sizeof(u32),
+		    array_size(map->max_osd, sizeof(*map->osd_primary_affinity)),
-							  GFP_NOFS);
+		    GFP_NOFS);
 		if (!map->osd_primary_affinity)
 			return -ENOMEM;
 	ceph_decode_32_safe(p, end, len, e_inval);
 	if (len == 0) {
-		kfree(map->osd_primary_affinity);
+		kvfree(map->osd_primary_affinity);
 		map->osd_primary_affinity = NULL;
 		return 0;
 	}

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code