Commit 815d3c16 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'pull-ceph-d_name-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs 

Pull ceph dentry->d_name fixes from Al Viro:
 "Stuff that had fallen through the cracks back in February; ceph folks
  tested that pile and said they prefer to have it go through my tree..."

* tag 'pull-ceph-d_name-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  ceph: fix a race with rename() in ceph_mdsc_build_path()
  prep for ceph_encode_encrypted_fname() fixes
  [ceph] parse_longname(): strrchr() expects NUL-terminated string
parents 2d9c1336 0d2da256

fs/ceph/caps.c

+7 −11
Original line number Diff line number Diff line
@@ -4957,24 +4957,20 @@ int ceph_encode_dentry_release(void **p, struct dentry *dentry, 
	cl = ceph_inode_to_client(dir);

	spin_lock(&dentry->d_lock);

	if (ret && di->lease_session && di->lease_session->s_mds == mds) {

		int len = dentry->d_name.len;

		doutc(cl, "%p mds%d seq %d\n",  dentry, mds,

		      (int)di->lease_seq);

		rel->dname_seq = cpu_to_le32(di->lease_seq);

		__ceph_mdsc_drop_dentry_lease(dentry);

		memcpy(*p, dentry->d_name.name, len);

		spin_unlock(&dentry->d_lock);

		if (IS_ENCRYPTED(dir) && fscrypt_has_encryption_key(dir)) {

			int ret2 = ceph_encode_encrypted_fname(dir, dentry, *p);



			if (ret2 < 0)

				return ret2;



			rel->dname_len = cpu_to_le32(ret2);

			*p += ret2;

		} else {

			rel->dname_len = cpu_to_le32(dentry->d_name.len);

			memcpy(*p, dentry->d_name.name, dentry->d_name.len);

			*p += dentry->d_name.len;

			len = ceph_encode_encrypted_dname(dir, *p, len);

			if (len < 0)

				return len;

		}

		rel->dname_len = cpu_to_le32(len);

		*p += len;

	} else {

		spin_unlock(&dentry->d_lock);

	}

fs/ceph/crypto.c

+27 −55
Original line number Diff line number Diff line
@@ -215,35 +215,31 @@ static struct inode *parse_longname(const struct inode *parent, 
	struct ceph_client *cl = ceph_inode_to_client(parent);

	struct inode *dir = NULL;

	struct ceph_vino vino = { .snap = CEPH_NOSNAP };

	char *inode_number;

	char *name_end;

	int orig_len = *name_len;

	char *name_end, *inode_number;

	int ret = -EIO;



	/* NUL-terminate */

	char *str __free(kfree) = kmemdup_nul(name, *name_len, GFP_KERNEL);

	if (!str)

		return ERR_PTR(-ENOMEM);

	/* Skip initial '_' */

	name++;

	name_end = strrchr(name, '_');

	str++;

	name_end = strrchr(str, '_');

	if (!name_end) {

		doutc(cl, "failed to parse long snapshot name: %s\n", name);

		doutc(cl, "failed to parse long snapshot name: %s\n", str);

		return ERR_PTR(-EIO);

	}

	*name_len = (name_end - name);

	*name_len = (name_end - str);

	if (*name_len <= 0) {

		pr_err_client(cl, "failed to parse long snapshot name\n");

		return ERR_PTR(-EIO);

	}



	/* Get the inode number */

	inode_number = kmemdup_nul(name_end + 1,

				   orig_len - *name_len - 2,

				   GFP_KERNEL);

	if (!inode_number)

		return ERR_PTR(-ENOMEM);

	inode_number = name_end + 1;

	ret = kstrtou64(inode_number, 10, &vino.ino);

	if (ret) {

		doutc(cl, "failed to parse inode number: %s\n", name);

		dir = ERR_PTR(ret);

		goto out;

		doutc(cl, "failed to parse inode number: %s\n", str);

		return ERR_PTR(ret);

	}



	/* And finally the inode */
@@ -254,42 +250,29 @@ static struct inode *parse_longname(const struct inode *parent, 
		if (IS_ERR(dir))

			doutc(cl, "can't find inode %s (%s)\n", inode_number, name);

	}



out:

	kfree(inode_number);

	return dir;

}



int ceph_encode_encrypted_dname(struct inode *parent, struct qstr *d_name,

				char *buf)

int ceph_encode_encrypted_dname(struct inode *parent, char *buf, int elen)

{

	struct ceph_client *cl = ceph_inode_to_client(parent);

	struct inode *dir = parent;

	struct qstr iname;

	char *p = buf;

	u32 len;

	int name_len;

	int elen;

	int name_len = elen;

	int ret;

	u8 *cryptbuf = NULL;



	iname.name = d_name->name;

	name_len = d_name->len;



	/* Handle the special case of snapshot names that start with '_' */

	if ((ceph_snap(dir) == CEPH_SNAPDIR) && (name_len > 0) &&

	    (iname.name[0] == '_')) {

		dir = parse_longname(parent, iname.name, &name_len);

	if (ceph_snap(dir) == CEPH_SNAPDIR && *p == '_') {

		dir = parse_longname(parent, p, &name_len);

		if (IS_ERR(dir))

			return PTR_ERR(dir);

		iname.name++; /* skip initial '_' */

		p++; /* skip initial '_' */

	}

	iname.len = name_len;



	if (!fscrypt_has_encryption_key(dir)) {

		memcpy(buf, d_name->name, d_name->len);

		elen = d_name->len;

	if (!fscrypt_has_encryption_key(dir))

		goto out;

	}



	/*

	 * Convert cleartext d_name to ciphertext. If result is longer than
@@ -297,7 +280,7 @@ int ceph_encode_encrypted_dname(struct inode *parent, struct qstr *d_name, 
	 *

	 * See: fscrypt_setup_filename

	 */

	if (!fscrypt_fname_encrypted_size(dir, iname.len, NAME_MAX, &len)) {

	if (!fscrypt_fname_encrypted_size(dir, name_len, NAME_MAX, &len)) {

		elen = -ENAMETOOLONG;

		goto out;

	}
@@ -310,7 +293,9 @@ int ceph_encode_encrypted_dname(struct inode *parent, struct qstr *d_name, 
		goto out;

	}



	ret = fscrypt_fname_encrypt(dir, &iname, cryptbuf, len);

	ret = fscrypt_fname_encrypt(dir,

				    &(struct qstr)QSTR_INIT(p, name_len),

				    cryptbuf, len);

	if (ret) {

		elen = ret;

		goto out;
@@ -331,18 +316,13 @@ int ceph_encode_encrypted_dname(struct inode *parent, struct qstr *d_name, 
	}



	/* base64 encode the encrypted name */

	elen = ceph_base64_encode(cryptbuf, len, buf);

	doutc(cl, "base64-encoded ciphertext name = %.*s\n", elen, buf);

	elen = ceph_base64_encode(cryptbuf, len, p);

	doutc(cl, "base64-encoded ciphertext name = %.*s\n", elen, p);



	/* To understand the 240 limit, see CEPH_NOHASH_NAME_MAX comments */

	WARN_ON(elen > 240);

	if ((elen > 0) && (dir != parent)) {

		char tmp_buf[NAME_MAX];



		elen = snprintf(tmp_buf, sizeof(tmp_buf), "_%.*s_%ld",

				elen, buf, dir->i_ino);

		memcpy(buf, tmp_buf, elen);

	}

	if (dir != parent) // leading _ is already there; append _<inum>

		elen += 1 + sprintf(p + elen, "_%ld", dir->i_ino);



out:

	kfree(cryptbuf);
@@ -355,14 +335,6 @@ int ceph_encode_encrypted_dname(struct inode *parent, struct qstr *d_name, 
	return elen;

}



int ceph_encode_encrypted_fname(struct inode *parent, struct dentry *dentry,

				char *buf)

{

	WARN_ON_ONCE(!fscrypt_has_encryption_key(parent));



	return ceph_encode_encrypted_dname(parent, &dentry->d_name, buf);

}



/**

 * ceph_fname_to_usr - convert a filename for userland presentation

 * @fname: ceph_fname to be converted

fs/ceph/crypto.h

+4 −14
Original line number Diff line number Diff line
@@ -102,10 +102,7 @@ int ceph_fscrypt_prepare_context(struct inode *dir, struct inode *inode, 
				 struct ceph_acl_sec_ctx *as);

void ceph_fscrypt_as_ctx_to_req(struct ceph_mds_request *req,

				struct ceph_acl_sec_ctx *as);

int ceph_encode_encrypted_dname(struct inode *parent, struct qstr *d_name,

				char *buf);

int ceph_encode_encrypted_fname(struct inode *parent, struct dentry *dentry,

				char *buf);

int ceph_encode_encrypted_dname(struct inode *parent, char *buf, int len);



static inline int ceph_fname_alloc_buffer(struct inode *parent,

					  struct fscrypt_str *fname)
@@ -194,17 +191,10 @@ static inline void ceph_fscrypt_as_ctx_to_req(struct ceph_mds_request *req, 
{

}



static inline int ceph_encode_encrypted_dname(struct inode *parent,

					      struct qstr *d_name, char *buf)

{

	memcpy(buf, d_name->name, d_name->len);

	return d_name->len;

}



static inline int ceph_encode_encrypted_fname(struct inode *parent,

					      struct dentry *dentry, char *buf)

static inline int ceph_encode_encrypted_dname(struct inode *parent, char *buf,

					      int len)

{

	return -EOPNOTSUPP;

	return len;

}



static inline int ceph_fname_alloc_buffer(struct inode *parent,

fs/ceph/dir.c

+3 −4
Original line number Diff line number Diff line
@@ -423,17 +423,16 @@ static int ceph_readdir(struct file *file, struct dir_context *ctx) 
			req->r_inode_drop = CEPH_CAP_FILE_EXCL;

		}

		if (dfi->last_name) {

			struct qstr d_name = { .name = dfi->last_name,

					       .len = strlen(dfi->last_name) };

			int len = strlen(dfi->last_name);



			req->r_path2 = kzalloc(NAME_MAX + 1, GFP_KERNEL);

			if (!req->r_path2) {

				ceph_mdsc_put_request(req);

				return -ENOMEM;

			}

			memcpy(req->r_path2, dfi->last_name, len);



			err = ceph_encode_encrypted_dname(inode, &d_name,

							  req->r_path2);

			err = ceph_encode_encrypted_dname(inode, req->r_path2, len);

			if (err < 0) {

				ceph_mdsc_put_request(req);

				return err;

fs/ceph/mds_client.c

+2 −2
Original line number Diff line number Diff line
@@ -2766,8 +2766,8 @@ char *ceph_mdsc_build_path(struct ceph_mds_client *mdsc, struct dentry *dentry, 
			}



			if (fscrypt_has_encryption_key(d_inode(parent))) {

				len = ceph_encode_encrypted_fname(d_inode(parent),

								  cur, buf);

				len = ceph_encode_encrypted_dname(d_inode(parent),

								  buf, len);

				if (len < 0) {

					dput(parent);

					dput(cur);