Commit 8b39a57e authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'work.set_fs-exec' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs 

Pull uaccess/coredump updates from Al Viro:
 "set_fs() removal in coredump-related area - mostly Christoph's
  stuff..."

* 'work.set_fs-exec' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs:
  binfmt_elf_fdpic: remove the set_fs(KERNEL_DS) in elf_fdpic_core_dump
  binfmt_elf: remove the set_fs(KERNEL_DS) in elf_core_dump
  binfmt_elf: remove the set_fs in fill_siginfo_note
  signal: refactor copy_siginfo_to_user32
  powerpc/spufs: simplify spufs core dumping
  powerpc/spufs: stop using access_ok
  powerpc/spufs: fix copy_to_user while atomic
parents 062ea674 38cdabb7

arch/powerpc/platforms/cell/spufs/coredump.c

+28 −59
Original line number Diff line number Diff line
@@ -21,22 +21,6 @@ 


#include "spufs.h"



static ssize_t do_coredump_read(int num, struct spu_context *ctx, void *buffer,

				size_t size, loff_t *off)

{

	u64 data;

	int ret;



	if (spufs_coredump_read[num].read)

		return spufs_coredump_read[num].read(ctx, buffer, size, off);



	data = spufs_coredump_read[num].get(ctx);

	ret = snprintf(buffer, size, "0x%.16llx", data);

	if (ret >= size)

		return size;

	return ++ret; /* count trailing NULL */

}



static int spufs_ctx_note_size(struct spu_context *ctx, int dfd)

{

	int i, sz, total = 0;
@@ -118,58 +102,43 @@ int spufs_coredump_extra_notes_size(void) 
static int spufs_arch_write_note(struct spu_context *ctx, int i,

				  struct coredump_params *cprm, int dfd)

{

	loff_t pos = 0;

	int sz, rc, total = 0;

	const int bufsz = PAGE_SIZE;

	char *name;

	char fullname[80], *buf;

	size_t sz = spufs_coredump_read[i].size;

	char fullname[80];

	struct elf_note en;

	size_t skip;



	buf = (void *)get_zeroed_page(GFP_KERNEL);

	if (!buf)

		return -ENOMEM;



	name = spufs_coredump_read[i].name;

	sz = spufs_coredump_read[i].size;

	size_t ret;



	sprintf(fullname, "SPU/%d/%s", dfd, name);

	sprintf(fullname, "SPU/%d/%s", dfd, spufs_coredump_read[i].name);

	en.n_namesz = strlen(fullname) + 1;

	en.n_descsz = sz;

	en.n_type = NT_SPU;



	if (!dump_emit(cprm, &en, sizeof(en)))

		goto Eio;



		return -EIO;

	if (!dump_emit(cprm, fullname, en.n_namesz))

		goto Eio;



		return -EIO;

	if (!dump_align(cprm, 4))

		goto Eio;



	do {

		rc = do_coredump_read(i, ctx, buf, bufsz, &pos);

		if (rc > 0) {

			if (!dump_emit(cprm, buf, rc))

				goto Eio;

			total += rc;

		}

	} while (rc == bufsz && total < sz);

		return -EIO;



	if (rc < 0)

		goto out;

	if (spufs_coredump_read[i].dump) {

		ret = spufs_coredump_read[i].dump(ctx, cprm);

		if (ret < 0)

			return ret;

	} else {

		char buf[32];



	skip = roundup(cprm->pos - total + sz, 4) - cprm->pos;

	if (!dump_skip(cprm, skip))

		goto Eio;

		ret = snprintf(buf, sizeof(buf), "0x%.16llx",

			       spufs_coredump_read[i].get(ctx));

		if (ret >= sizeof(buf))

			return sizeof(buf);



	rc = 0;

out:

	free_page((unsigned long)buf);

	return rc;

Eio:

	free_page((unsigned long)buf);

		/* count trailing the NULL: */

		if (!dump_emit(cprm, buf, ret + 1))

			return -EIO;

	}



	if (!dump_skip(cprm, roundup(cprm->pos - ret + sz, 4) - cprm->pos))

		return -EIO;

	return 0;

}



int spufs_coredump_extra_notes_write(struct coredump_params *cprm)

arch/powerpc/platforms/cell/spufs/file.c

+157 −173
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ 


#undef DEBUG



#include <linux/coredump.h>

#include <linux/fs.h>

#include <linux/ioctl.h>

#include <linux/export.h>
@@ -129,6 +130,14 @@ out: 
	return ret;

}



static ssize_t spufs_dump_emit(struct coredump_params *cprm, void *buf,

		size_t size)

{

	if (!dump_emit(cprm, buf, size))

		return -EIO;

	return size;

}



#define DEFINE_SPUFS_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt)	\

static int __fops ## _open(struct inode *inode, struct file *file)	\

{									\
@@ -172,12 +181,9 @@ spufs_mem_release(struct inode *inode, struct file *file) 
}



static ssize_t

__spufs_mem_read(struct spu_context *ctx, char __user *buffer,

			size_t size, loff_t *pos)

spufs_mem_dump(struct spu_context *ctx, struct coredump_params *cprm)

{

	char *local_store = ctx->ops->get_ls(ctx);

	return simple_read_from_buffer(buffer, size, pos, local_store,

					LS_SIZE);

	return spufs_dump_emit(cprm, ctx->ops->get_ls(ctx), LS_SIZE);

}



static ssize_t
@@ -190,7 +196,8 @@ spufs_mem_read(struct file *file, char __user *buffer, 
	ret = spu_acquire(ctx);

	if (ret)

		return ret;

	ret = __spufs_mem_read(ctx, buffer, size, pos);

	ret = simple_read_from_buffer(buffer, size, pos, ctx->ops->get_ls(ctx),

				      LS_SIZE);

	spu_release(ctx);



	return ret;
@@ -459,12 +466,10 @@ spufs_regs_open(struct inode *inode, struct file *file) 
}



static ssize_t

__spufs_regs_read(struct spu_context *ctx, char __user *buffer,

			size_t size, loff_t *pos)

spufs_regs_dump(struct spu_context *ctx, struct coredump_params *cprm)

{

	struct spu_lscsa *lscsa = ctx->csa.lscsa;

	return simple_read_from_buffer(buffer, size, pos,

				      lscsa->gprs, sizeof lscsa->gprs);

	return spufs_dump_emit(cprm, ctx->csa.lscsa->gprs,

			       sizeof(ctx->csa.lscsa->gprs));

}



static ssize_t
@@ -482,7 +487,8 @@ spufs_regs_read(struct file *file, char __user *buffer, 
	ret = spu_acquire_saved(ctx);

	if (ret)

		return ret;

	ret = __spufs_regs_read(ctx, buffer, size, pos);

	ret = simple_read_from_buffer(buffer, size, pos, ctx->csa.lscsa->gprs,

				      sizeof(ctx->csa.lscsa->gprs));

	spu_release_saved(ctx);

	return ret;

}
@@ -517,12 +523,10 @@ static const struct file_operations spufs_regs_fops = { 
};



static ssize_t

__spufs_fpcr_read(struct spu_context *ctx, char __user * buffer,

			size_t size, loff_t * pos)

spufs_fpcr_dump(struct spu_context *ctx, struct coredump_params *cprm)

{

	struct spu_lscsa *lscsa = ctx->csa.lscsa;

	return simple_read_from_buffer(buffer, size, pos,

				      &lscsa->fpcr, sizeof(lscsa->fpcr));

	return spufs_dump_emit(cprm, &ctx->csa.lscsa->fpcr,

			       sizeof(ctx->csa.lscsa->fpcr));

}



static ssize_t
@@ -535,7 +539,8 @@ spufs_fpcr_read(struct file *file, char __user * buffer, 
	ret = spu_acquire_saved(ctx);

	if (ret)

		return ret;

	ret = __spufs_fpcr_read(ctx, buffer, size, pos);

	ret = simple_read_from_buffer(buffer, size, pos, &ctx->csa.lscsa->fpcr,

				      sizeof(ctx->csa.lscsa->fpcr));

	spu_release_saved(ctx);

	return ret;

}
@@ -590,17 +595,12 @@ static ssize_t spufs_mbox_read(struct file *file, char __user *buf, 
			size_t len, loff_t *pos)

{

	struct spu_context *ctx = file->private_data;

	u32 mbox_data, __user *udata;

	u32 mbox_data, __user *udata = (void __user *)buf;

	ssize_t count;



	if (len < 4)

		return -EINVAL;



	if (!access_ok(buf, len))

		return -EFAULT;



	udata = (void __user *)buf;



	count = spu_acquire(ctx);

	if (count)

		return count;
@@ -616,7 +616,7 @@ static ssize_t spufs_mbox_read(struct file *file, char __user *buf, 
		 * but still need to return the data we have

		 * read successfully so far.

		 */

		ret = __put_user(mbox_data, udata);

		ret = put_user(mbox_data, udata);

		if (ret) {

			if (!count)

				count = -EFAULT;
@@ -698,17 +698,12 @@ static ssize_t spufs_ibox_read(struct file *file, char __user *buf, 
			size_t len, loff_t *pos)

{

	struct spu_context *ctx = file->private_data;

	u32 ibox_data, __user *udata;

	u32 ibox_data, __user *udata = (void __user *)buf;

	ssize_t count;



	if (len < 4)

		return -EINVAL;



	if (!access_ok(buf, len))

		return -EFAULT;



	udata = (void __user *)buf;



	count = spu_acquire(ctx);

	if (count)

		goto out;
@@ -727,7 +722,7 @@ static ssize_t spufs_ibox_read(struct file *file, char __user *buf, 
	}



	/* if we can't write at all, return -EFAULT */

	count = __put_user(ibox_data, udata);

	count = put_user(ibox_data, udata);

	if (count)

		goto out_unlock;
@@ -741,7 +736,7 @@ static ssize_t spufs_ibox_read(struct file *file, char __user *buf, 
		 * but still need to return the data we have

		 * read successfully so far.

		 */

		ret = __put_user(ibox_data, udata);

		ret = put_user(ibox_data, udata);

		if (ret)

			break;

	}
@@ -836,17 +831,13 @@ static ssize_t spufs_wbox_write(struct file *file, const char __user *buf, 
			size_t len, loff_t *pos)

{

	struct spu_context *ctx = file->private_data;

	u32 wbox_data, __user *udata;

	u32 wbox_data, __user *udata = (void __user *)buf;

	ssize_t count;



	if (len < 4)

		return -EINVAL;



	udata = (void __user *)buf;

	if (!access_ok(buf, len))

		return -EFAULT;



	if (__get_user(wbox_data, udata))

	if (get_user(wbox_data, udata))

		return -EFAULT;



	count = spu_acquire(ctx);
@@ -873,7 +864,7 @@ static ssize_t spufs_wbox_write(struct file *file, const char __user *buf, 
	/* write as much as possible */

	for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) {

		int ret;

		ret = __get_user(wbox_data, udata);

		ret = get_user(wbox_data, udata);

		if (ret)

			break;
@@ -967,28 +958,26 @@ spufs_signal1_release(struct inode *inode, struct file *file) 
	return 0;

}



static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf,

			size_t len, loff_t *pos)

static ssize_t spufs_signal1_dump(struct spu_context *ctx,

		struct coredump_params *cprm)

{

	int ret = 0;

	u32 data;



	if (len < 4)

		return -EINVAL;



	if (ctx->csa.spu_chnlcnt_RW[3]) {

		data = ctx->csa.spu_chnldata_RW[3];

		ret = 4;

	if (!ctx->csa.spu_chnlcnt_RW[3])

		return 0;

	return spufs_dump_emit(cprm, &ctx->csa.spu_chnldata_RW[3],

			       sizeof(ctx->csa.spu_chnldata_RW[3]));

}



	if (!ret)

		goto out;



	if (copy_to_user(buf, &data, 4))

static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf,

			size_t len)

{

	if (len < sizeof(ctx->csa.spu_chnldata_RW[3]))

		return -EINVAL;

	if (!ctx->csa.spu_chnlcnt_RW[3])

		return 0;

	if (copy_to_user(buf, &ctx->csa.spu_chnldata_RW[3],

			 sizeof(ctx->csa.spu_chnldata_RW[3])))

		return -EFAULT;



out:

	return ret;

	return sizeof(ctx->csa.spu_chnldata_RW[3]);

}



static ssize_t spufs_signal1_read(struct file *file, char __user *buf,
@@ -1000,7 +989,7 @@ static ssize_t spufs_signal1_read(struct file *file, char __user *buf, 
	ret = spu_acquire_saved(ctx);

	if (ret)

		return ret;

	ret = __spufs_signal1_read(ctx, buf, len, pos);

	ret = __spufs_signal1_read(ctx, buf, len);

	spu_release_saved(ctx);



	return ret;
@@ -1104,28 +1093,26 @@ spufs_signal2_release(struct inode *inode, struct file *file) 
	return 0;

}



static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf,

			size_t len, loff_t *pos)

static ssize_t spufs_signal2_dump(struct spu_context *ctx,

		struct coredump_params *cprm)

{

	int ret = 0;

	u32 data;



	if (len < 4)

		return -EINVAL;



	if (ctx->csa.spu_chnlcnt_RW[4]) {

		data =  ctx->csa.spu_chnldata_RW[4];

		ret = 4;

	if (!ctx->csa.spu_chnlcnt_RW[4])

		return 0;

	return spufs_dump_emit(cprm, &ctx->csa.spu_chnldata_RW[4],

			       sizeof(ctx->csa.spu_chnldata_RW[4]));

}



	if (!ret)

		goto out;



	if (copy_to_user(buf, &data, 4))

static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf,

			size_t len)

{

	if (len < sizeof(ctx->csa.spu_chnldata_RW[4]))

		return -EINVAL;

	if (!ctx->csa.spu_chnlcnt_RW[4])

		return 0;

	if (copy_to_user(buf, &ctx->csa.spu_chnldata_RW[4],

			 sizeof(ctx->csa.spu_chnldata_RW[4])))

		return -EFAULT;



out:

	return ret;

	return sizeof(ctx->csa.spu_chnldata_RW[4]);

}



static ssize_t spufs_signal2_read(struct file *file, char __user *buf,
@@ -1137,7 +1124,7 @@ static ssize_t spufs_signal2_read(struct file *file, char __user *buf, 
	ret = spu_acquire_saved(ctx);

	if (ret)

		return ret;

	ret = __spufs_signal2_read(ctx, buf, len, pos);

	ret = __spufs_signal2_read(ctx, buf, len);

	spu_release_saved(ctx);



	return ret;
@@ -1961,38 +1948,36 @@ static const struct file_operations spufs_caps_fops = { 
	.release	= single_release,

};



static ssize_t __spufs_mbox_info_read(struct spu_context *ctx,

			char __user *buf, size_t len, loff_t *pos)

static ssize_t spufs_mbox_info_dump(struct spu_context *ctx,

		struct coredump_params *cprm)

{

	u32 data;



	/* EOF if there's no entry in the mbox */

	if (!(ctx->csa.prob.mb_stat_R & 0x0000ff))

		return 0;



	data = ctx->csa.prob.pu_mb_R;



	return simple_read_from_buffer(buf, len, pos, &data, sizeof data);

	return spufs_dump_emit(cprm, &ctx->csa.prob.pu_mb_R,

			       sizeof(ctx->csa.prob.pu_mb_R));

}



static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf,

				   size_t len, loff_t *pos)

{

	int ret;

	struct spu_context *ctx = file->private_data;



	if (!access_ok(buf, len))

		return -EFAULT;

	u32 stat, data;

	int ret;



	ret = spu_acquire_saved(ctx);

	if (ret)

		return ret;

	spin_lock(&ctx->csa.register_lock);

	ret = __spufs_mbox_info_read(ctx, buf, len, pos);

	stat = ctx->csa.prob.mb_stat_R;

	data = ctx->csa.prob.pu_mb_R;

	spin_unlock(&ctx->csa.register_lock);

	spu_release_saved(ctx);



	return ret;

	/* EOF if there's no entry in the mbox */

	if (!(stat & 0x0000ff))

		return 0;



	return simple_read_from_buffer(buf, len, pos, &data, sizeof(data));

}



static const struct file_operations spufs_mbox_info_fops = {
@@ -2001,38 +1986,36 @@ static const struct file_operations spufs_mbox_info_fops = { 
	.llseek  = generic_file_llseek,

};



static ssize_t __spufs_ibox_info_read(struct spu_context *ctx,

				char __user *buf, size_t len, loff_t *pos)

static ssize_t spufs_ibox_info_dump(struct spu_context *ctx,

		struct coredump_params *cprm)

{

	u32 data;



	/* EOF if there's no entry in the ibox */

	if (!(ctx->csa.prob.mb_stat_R & 0xff0000))

		return 0;



	data = ctx->csa.priv2.puint_mb_R;



	return simple_read_from_buffer(buf, len, pos, &data, sizeof data);

	return spufs_dump_emit(cprm, &ctx->csa.priv2.puint_mb_R,

			       sizeof(ctx->csa.priv2.puint_mb_R));

}



static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf,

				   size_t len, loff_t *pos)

{

	struct spu_context *ctx = file->private_data;

	u32 stat, data;

	int ret;



	if (!access_ok(buf, len))

		return -EFAULT;



	ret = spu_acquire_saved(ctx);

	if (ret)

		return ret;

	spin_lock(&ctx->csa.register_lock);

	ret = __spufs_ibox_info_read(ctx, buf, len, pos);

	stat = ctx->csa.prob.mb_stat_R;

	data = ctx->csa.priv2.puint_mb_R;

	spin_unlock(&ctx->csa.register_lock);

	spu_release_saved(ctx);



	return ret;

	/* EOF if there's no entry in the ibox */

	if (!(stat & 0xff0000))

		return 0;



	return simple_read_from_buffer(buf, len, pos, &data, sizeof(data));

}



static const struct file_operations spufs_ibox_info_fops = {
@@ -2041,41 +2024,36 @@ static const struct file_operations spufs_ibox_info_fops = { 
	.llseek  = generic_file_llseek,

};



static ssize_t __spufs_wbox_info_read(struct spu_context *ctx,

			char __user *buf, size_t len, loff_t *pos)

static size_t spufs_wbox_info_cnt(struct spu_context *ctx)

{

	int i, cnt;

	u32 data[4];

	u32 wbox_stat;



	wbox_stat = ctx->csa.prob.mb_stat_R;

	cnt = 4 - ((wbox_stat & 0x00ff00) >> 8);

	for (i = 0; i < cnt; i++) {

		data[i] = ctx->csa.spu_mailbox_data[i];

	return (4 - ((ctx->csa.prob.mb_stat_R & 0x00ff00) >> 8)) * sizeof(u32);

}



	return simple_read_from_buffer(buf, len, pos, &data,

				cnt * sizeof(u32));

static ssize_t spufs_wbox_info_dump(struct spu_context *ctx,

		struct coredump_params *cprm)

{

	return spufs_dump_emit(cprm, &ctx->csa.spu_mailbox_data,

			spufs_wbox_info_cnt(ctx));

}



static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf,

				   size_t len, loff_t *pos)

{

	struct spu_context *ctx = file->private_data;

	int ret;



	if (!access_ok(buf, len))

		return -EFAULT;

	u32 data[ARRAY_SIZE(ctx->csa.spu_mailbox_data)];

	int ret, count;



	ret = spu_acquire_saved(ctx);

	if (ret)

		return ret;

	spin_lock(&ctx->csa.register_lock);

	ret = __spufs_wbox_info_read(ctx, buf, len, pos);

	count = spufs_wbox_info_cnt(ctx);

	memcpy(&data, &ctx->csa.spu_mailbox_data, sizeof(data));

	spin_unlock(&ctx->csa.register_lock);

	spu_release_saved(ctx);



	return ret;

	return simple_read_from_buffer(buf, len, pos, &data,

				count * sizeof(u32));

}



static const struct file_operations spufs_wbox_info_fops = {
@@ -2084,50 +2062,53 @@ static const struct file_operations spufs_wbox_info_fops = { 
	.llseek  = generic_file_llseek,

};



static ssize_t __spufs_dma_info_read(struct spu_context *ctx,

			char __user *buf, size_t len, loff_t *pos)

static void spufs_get_dma_info(struct spu_context *ctx,

		struct spu_dma_info *info)

{

	struct spu_dma_info info;

	struct mfc_cq_sr *qp, *spuqp;

	int i;



	info.dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW;

	info.dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0];

	info.dma_info_status = ctx->csa.spu_chnldata_RW[24];

	info.dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25];

	info.dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27];

	info->dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW;

	info->dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0];

	info->dma_info_status = ctx->csa.spu_chnldata_RW[24];

	info->dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25];

	info->dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27];

	for (i = 0; i < 16; i++) {

		qp = &info.dma_info_command_data[i];

		spuqp = &ctx->csa.priv2.spuq[i];

		struct mfc_cq_sr *qp = &info->dma_info_command_data[i];

		struct mfc_cq_sr *spuqp = &ctx->csa.priv2.spuq[i];



		qp->mfc_cq_data0_RW = spuqp->mfc_cq_data0_RW;

		qp->mfc_cq_data1_RW = spuqp->mfc_cq_data1_RW;

		qp->mfc_cq_data2_RW = spuqp->mfc_cq_data2_RW;

		qp->mfc_cq_data3_RW = spuqp->mfc_cq_data3_RW;

	}

}



	return simple_read_from_buffer(buf, len, pos, &info,

				sizeof info);

static ssize_t spufs_dma_info_dump(struct spu_context *ctx,

		struct coredump_params *cprm)

{

	struct spu_dma_info info;



	spufs_get_dma_info(ctx, &info);

	return spufs_dump_emit(cprm, &info, sizeof(info));

}



static ssize_t spufs_dma_info_read(struct file *file, char __user *buf,

			      size_t len, loff_t *pos)

{

	struct spu_context *ctx = file->private_data;

	struct spu_dma_info info;

	int ret;



	if (!access_ok(buf, len))

		return -EFAULT;



	ret = spu_acquire_saved(ctx);

	if (ret)

		return ret;

	spin_lock(&ctx->csa.register_lock);

	ret = __spufs_dma_info_read(ctx, buf, len, pos);

	spufs_get_dma_info(ctx, &info);

	spin_unlock(&ctx->csa.register_lock);

	spu_release_saved(ctx);



	return ret;

	return simple_read_from_buffer(buf, len, pos, &info,

				sizeof(info));

}



static const struct file_operations spufs_dma_info_fops = {
@@ -2136,52 +2117,55 @@ static const struct file_operations spufs_dma_info_fops = { 
	.llseek = no_llseek,

};



static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx,

			char __user *buf, size_t len, loff_t *pos)

static void spufs_get_proxydma_info(struct spu_context *ctx,

		struct spu_proxydma_info *info)

{

	struct spu_proxydma_info info;

	struct mfc_cq_sr *qp, *puqp;

	int ret = sizeof info;

	int i;



	if (len < ret)

		return -EINVAL;



	if (!access_ok(buf, len))

		return -EFAULT;

	info->proxydma_info_type = ctx->csa.prob.dma_querytype_RW;

	info->proxydma_info_mask = ctx->csa.prob.dma_querymask_RW;

	info->proxydma_info_status = ctx->csa.prob.dma_tagstatus_R;



	info.proxydma_info_type = ctx->csa.prob.dma_querytype_RW;

	info.proxydma_info_mask = ctx->csa.prob.dma_querymask_RW;

	info.proxydma_info_status = ctx->csa.prob.dma_tagstatus_R;

	for (i = 0; i < 8; i++) {

		qp = &info.proxydma_info_command_data[i];

		puqp = &ctx->csa.priv2.puq[i];

		struct mfc_cq_sr *qp = &info->proxydma_info_command_data[i];

		struct mfc_cq_sr *puqp = &ctx->csa.priv2.puq[i];



		qp->mfc_cq_data0_RW = puqp->mfc_cq_data0_RW;

		qp->mfc_cq_data1_RW = puqp->mfc_cq_data1_RW;

		qp->mfc_cq_data2_RW = puqp->mfc_cq_data2_RW;

		qp->mfc_cq_data3_RW = puqp->mfc_cq_data3_RW;

	}

}



	return simple_read_from_buffer(buf, len, pos, &info,

				sizeof info);

static ssize_t spufs_proxydma_info_dump(struct spu_context *ctx,

		struct coredump_params *cprm)

{

	struct spu_proxydma_info info;



	spufs_get_proxydma_info(ctx, &info);

	return spufs_dump_emit(cprm, &info, sizeof(info));

}



static ssize_t spufs_proxydma_info_read(struct file *file, char __user *buf,

				   size_t len, loff_t *pos)

{

	struct spu_context *ctx = file->private_data;

	struct spu_proxydma_info info;

	int ret;



	if (len < sizeof(info))

		return -EINVAL;



	ret = spu_acquire_saved(ctx);

	if (ret)

		return ret;

	spin_lock(&ctx->csa.register_lock);

	ret = __spufs_proxydma_info_read(ctx, buf, len, pos);

	spufs_get_proxydma_info(ctx, &info);

	spin_unlock(&ctx->csa.register_lock);

	spu_release_saved(ctx);



	return ret;

	return simple_read_from_buffer(buf, len, pos, &info,

				sizeof(info));

}



static const struct file_operations spufs_proxydma_info_fops = {
@@ -2625,23 +2609,23 @@ const struct spufs_tree_descr spufs_dir_debug_contents[] = { 
};



const struct spufs_coredump_reader spufs_coredump_read[] = {

	{ "regs", __spufs_regs_read, NULL, sizeof(struct spu_reg128[128])},

	{ "fpcr", __spufs_fpcr_read, NULL, sizeof(struct spu_reg128) },

	{ "regs", spufs_regs_dump, NULL, sizeof(struct spu_reg128[128])},

	{ "fpcr", spufs_fpcr_dump, NULL, sizeof(struct spu_reg128) },

	{ "lslr", NULL, spufs_lslr_get, 19 },

	{ "decr", NULL, spufs_decr_get, 19 },

	{ "decr_status", NULL, spufs_decr_status_get, 19 },

	{ "mem", __spufs_mem_read, NULL, LS_SIZE, },

	{ "signal1", __spufs_signal1_read, NULL, sizeof(u32) },

	{ "mem", spufs_mem_dump, NULL, LS_SIZE, },

	{ "signal1", spufs_signal1_dump, NULL, sizeof(u32) },

	{ "signal1_type", NULL, spufs_signal1_type_get, 19 },

	{ "signal2", __spufs_signal2_read, NULL, sizeof(u32) },

	{ "signal2", spufs_signal2_dump, NULL, sizeof(u32) },

	{ "signal2_type", NULL, spufs_signal2_type_get, 19 },

	{ "event_mask", NULL, spufs_event_mask_get, 19 },

	{ "event_status", NULL, spufs_event_status_get, 19 },

	{ "mbox_info", __spufs_mbox_info_read, NULL, sizeof(u32) },

	{ "ibox_info", __spufs_ibox_info_read, NULL, sizeof(u32) },

	{ "wbox_info", __spufs_wbox_info_read, NULL, 4 * sizeof(u32)},

	{ "dma_info", __spufs_dma_info_read, NULL, sizeof(struct spu_dma_info)},

	{ "proxydma_info", __spufs_proxydma_info_read,

	{ "mbox_info", spufs_mbox_info_dump, NULL, sizeof(u32) },

	{ "ibox_info", spufs_ibox_info_dump, NULL, sizeof(u32) },

	{ "wbox_info", spufs_wbox_info_dump, NULL, 4 * sizeof(u32)},

	{ "dma_info", spufs_dma_info_dump, NULL, sizeof(struct spu_dma_info)},

	{ "proxydma_info", spufs_proxydma_info_dump,

			   NULL, sizeof(struct spu_proxydma_info)},

	{ "object-id", NULL, spufs_object_id_get, 19 },

	{ "npc", NULL, spufs_npc_get, 19 },

arch/powerpc/platforms/cell/spufs/spufs.h

+1 −2
Original line number Diff line number Diff line
@@ -337,8 +337,7 @@ void spufs_dma_callback(struct spu *spu, int type); 
extern struct spu_coredump_calls spufs_coredump_calls;

struct spufs_coredump_reader {

	char *name;

	ssize_t (*read)(struct spu_context *ctx,

			char __user *buffer, size_t size, loff_t *pos);

	ssize_t (*dump)(struct spu_context *ctx, struct coredump_params *cprm);

	u64 (*get)(struct spu_context *ctx);

	size_t size;

};

arch/x86/ia32/ia32_signal.c

+1 −1
Original line number Diff line number Diff line
@@ -350,7 +350,7 @@ int ia32_setup_rt_frame(int sig, struct ksignal *ksig, 
	unsafe_put_user(*(__u64 *)set, (__u64 *)&frame->uc.uc_sigmask, Efault);

	user_access_end();



	if (__copy_siginfo_to_user32(&frame->info, &ksig->info, false))

	if (__copy_siginfo_to_user32(&frame->info, &ksig->info))

		return -EFAULT;



	/* Set up registers for signal handler */

arch/x86/include/asm/compat.h

+6 −2
Original line number Diff line number Diff line
@@ -214,7 +214,11 @@ static inline bool in_compat_syscall(void) 
#endif



struct compat_siginfo;

int __copy_siginfo_to_user32(struct compat_siginfo __user *to,

		const kernel_siginfo_t *from, bool x32_ABI);



#ifdef CONFIG_X86_X32_ABI

int copy_siginfo_to_user32(struct compat_siginfo __user *to,

		const kernel_siginfo_t *from);

#define copy_siginfo_to_user32 copy_siginfo_to_user32

#endif /* CONFIG_X86_X32_ABI */



#endif /* _ASM_X86_COMPAT_H */

CRA Git | Maintained and supported by SUSTech CRA and CCSE