[deliverable/linux.git] / drivers / s390 / char / diag_ftp.c

/*
 *    DIAGNOSE X'2C4' instruction based HMC FTP services, useable on z/VM
 *
 *    Copyright IBM Corp. 2013
 *    Author(s): Ralf Hoppe (rhoppe@de.ibm.com)
 *
 */

#define KMSG_COMPONENT "hmcdrv"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/irq.h>
#include <linux/wait.h>
#include <linux/string.h>
#include <asm/ctl_reg.h>
#include <asm/diag.h>

#include "hmcdrv_ftp.h"
#include "diag_ftp.h"

/* DIAGNOSE X'2C4' return codes in Ry */
#define DIAG_FTP_RET_OK	0 /* HMC FTP started successfully */
#define DIAG_FTP_RET_EBUSY	4 /* HMC FTP service currently busy */
#define DIAG_FTP_RET_EIO	8 /* HMC FTP service I/O error */
/* and an artificial extension */
#define DIAG_FTP_RET_EPERM	2 /* HMC FTP service privilege error */

/* FTP service status codes (after INTR at guest real location 133) */
#define DIAG_FTP_STAT_OK	0U /* request completed successfully */
#define DIAG_FTP_STAT_PGCC	4U /* program check condition */
#define DIAG_FTP_STAT_PGIOE	8U /* paging I/O error */
#define DIAG_FTP_STAT_TIMEOUT	12U /* timeout */
#define DIAG_FTP_STAT_EBASE	16U /* base of error codes from SCLP */
#define DIAG_FTP_STAT_LDFAIL	(DIAG_FTP_STAT_EBASE + 1U) /* failed */
#define DIAG_FTP_STAT_LDNPERM	(DIAG_FTP_STAT_EBASE + 2U) /* not allowed */
#define DIAG_FTP_STAT_LDRUNS	(DIAG_FTP_STAT_EBASE + 3U) /* runs */
#define DIAG_FTP_STAT_LDNRUNS	(DIAG_FTP_STAT_EBASE + 4U) /* not runs */

/**
 * struct diag_ftp_ldfpl - load file FTP parameter list (LDFPL)
 * @bufaddr: real buffer address (at 4k boundary)
 * @buflen: length of buffer
 * @offset: dir/file offset
 * @intparm: interruption parameter (unused)
 * @transferred: bytes transferred
 * @fsize: file size, filled on GET
 * @failaddr: failing address
 * @spare: padding
 * @fident: file name - ASCII
 */
struct diag_ftp_ldfpl {
	u64 bufaddr;
	u64 buflen;
	u64 offset;
	u64 intparm;
	u64 transferred;
	u64 fsize;
	u64 failaddr;
	u64 spare;
	u8 fident[HMCDRV_FTP_FIDENT_MAX];
} __packed;

static DECLARE_COMPLETION(diag_ftp_rx_complete);
static int diag_ftp_subcode;

/**
 * diag_ftp_handler() - FTP services IRQ handler
 * @extirq: external interrupt (sub-) code
 * @param32: 32-bit interruption parameter from &struct diag_ftp_ldfpl
 * @param64: unused (for 64-bit interrupt parameters)
 */
static void diag_ftp_handler(struct ext_code extirq,
			     unsigned int param32,
			     unsigned long param64)
{
	if ((extirq.subcode >> 8) != 8)
		return; /* not a FTP services sub-code */

	inc_irq_stat(IRQEXT_FTP);
	diag_ftp_subcode = extirq.subcode & 0xffU;
	complete(&diag_ftp_rx_complete);
}

/**
 * diag_ftp_2c4() - DIAGNOSE X'2C4' service call
 * @fpl: pointer to prepared LDFPL
 * @cmd: FTP command to be executed
 *
 * Performs a DIAGNOSE X'2C4' call with (input/output) FTP parameter list
 * @fpl and FTP function code @cmd. In case of an error the function does
 * nothing and returns an (negative) error code.
 *
 * Notes:
 * 1. This function only initiates a transfer, so the caller must wait
 *    for completion (asynchronous execution).
 * 2. The FTP parameter list @fpl must be aligned to a double-word boundary.
 * 3. fpl->bufaddr must be a real address, 4k aligned
 */
static int diag_ftp_2c4(struct diag_ftp_ldfpl *fpl,
			enum hmcdrv_ftp_cmdid cmd)
{
	int rc;

	diag_stat_inc(DIAG_STAT_X2C4);
	asm volatile(
		"	diag	%[addr],%[cmd],0x2c4\n"
		"0:	j	2f\n"
		"1:	la	%[rc],%[err]\n"
		"2:\n"
		EX_TABLE(0b, 1b)
		: [rc] "=d" (rc), "+m" (*fpl)
		: [cmd] "0" (cmd), [addr] "d" (virt_to_phys(fpl)),
		  [err] "i" (DIAG_FTP_RET_EPERM)
		: "cc");

	switch (rc) {
	case DIAG_FTP_RET_OK:
		return 0;
	case DIAG_FTP_RET_EBUSY:
		return -EBUSY;
	case DIAG_FTP_RET_EPERM:
		return -EPERM;
	case DIAG_FTP_RET_EIO:
	default:
		return -EIO;
	}
}

/**
 * diag_ftp_cmd() - executes a DIAG X'2C4' FTP command, targeting a HMC
 * @ftp: pointer to FTP command specification
 * @fsize: return of file size (or NULL if undesirable)
 *
 * Attention: Notice that this function is not reentrant - so the caller
 * must ensure locking.
 *
 * Return: number of bytes read/written or a (negative) error code
 */
ssize_t diag_ftp_cmd(const struct hmcdrv_ftp_cmdspec *ftp, size_t *fsize)
{
	struct diag_ftp_ldfpl *ldfpl;
	ssize_t len;
#ifdef DEBUG
	unsigned long start_jiffies;

	pr_debug("starting DIAG X'2C4' on '%s', requesting %zd bytes\n",
		 ftp->fname, ftp->len);
	start_jiffies = jiffies;
#endif
	init_completion(&diag_ftp_rx_complete);

	ldfpl = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
	if (!ldfpl) {
		len = -ENOMEM;
		goto out;
	}

	len = strlcpy(ldfpl->fident, ftp->fname, sizeof(ldfpl->fident));
	if (len >= HMCDRV_FTP_FIDENT_MAX) {
		len = -EINVAL;
		goto out_free;
	}

	ldfpl->transferred = 0;
	ldfpl->fsize = 0;
	ldfpl->offset = ftp->ofs;
	ldfpl->buflen = ftp->len;
	ldfpl->bufaddr = virt_to_phys(ftp->buf);

	len = diag_ftp_2c4(ldfpl, ftp->id);
	if (len)
		goto out_free;

	/*
	 * There is no way to cancel the running diag X'2C4', the code
	 * needs to wait unconditionally until the transfer is complete.
	 */
	wait_for_completion(&diag_ftp_rx_complete);

#ifdef DEBUG
	pr_debug("completed DIAG X'2C4' after %lu ms\n",
		 (jiffies - start_jiffies) * 1000 / HZ);
	pr_debug("status of DIAG X'2C4' is %u, with %lld/%lld bytes\n",
		 diag_ftp_subcode, ldfpl->transferred, ldfpl->fsize);
#endif

	switch (diag_ftp_subcode) {
	case DIAG_FTP_STAT_OK: /* success */
		len = ldfpl->transferred;
		if (fsize)
			*fsize = ldfpl->fsize;
		break;
	case DIAG_FTP_STAT_LDNPERM:
		len = -EPERM;
		break;
	case DIAG_FTP_STAT_LDRUNS:
		len = -EBUSY;
		break;
	case DIAG_FTP_STAT_LDFAIL:
		len = -ENOENT; /* no such file or media */
		break;
	default:
		len = -EIO;
		break;
	}

out_free:
	free_page((unsigned long) ldfpl);
out:
	return len;
}

/**
 * diag_ftp_startup() - startup of FTP services, when running on z/VM
 *
 * Return: 0 on success, else an (negative) error code
 */
int diag_ftp_startup(void)
{
	int rc;

	rc = register_external_irq(EXT_IRQ_CP_SERVICE, diag_ftp_handler);
	if (rc)
		return rc;

	irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
	return 0;
}

/**
 * diag_ftp_shutdown() - shutdown of FTP services, when running on z/VM
 */
void diag_ftp_shutdown(void)
{
	irq_subclass_unregister(IRQ_SUBCLASS_SERVICE_SIGNAL);
	unregister_external_irq(EXT_IRQ_CP_SERVICE, diag_ftp_handler);
}
Commit	Line	Data
8f933b10 RH	1	/*
	2	* DIAGNOSE X'2C4' instruction based HMC FTP services, useable on z/VM
	3	*
	4	* Copyright IBM Corp. 2013
	5	* Author(s): Ralf Hoppe (rhoppe@de.ibm.com)
	6	*
	7	*/
	8
	9	#define KMSG_COMPONENT "hmcdrv"
	10	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	11
	12	#include <linux/kernel.h>
	13	#include <linux/mm.h>
	14	#include <linux/irq.h>
	15	#include <linux/wait.h>
	16	#include <linux/string.h>
	17	#include <asm/ctl_reg.h>
1ec2772e	18	#include <asm/diag.h>
8f933b10 RH	19
	20	#include "hmcdrv_ftp.h"
	21	#include "diag_ftp.h"
	22
	23	/* DIAGNOSE X'2C4' return codes in Ry */
	24	#define DIAG_FTP_RET_OK 0 /* HMC FTP started successfully */
	25	#define DIAG_FTP_RET_EBUSY 4 /* HMC FTP service currently busy */
	26	#define DIAG_FTP_RET_EIO 8 /* HMC FTP service I/O error */
	27	/* and an artificial extension */
	28	#define DIAG_FTP_RET_EPERM 2 /* HMC FTP service privilege error */
	29
	30	/* FTP service status codes (after INTR at guest real location 133) */
	31	#define DIAG_FTP_STAT_OK 0U /* request completed successfully */
	32	#define DIAG_FTP_STAT_PGCC 4U /* program check condition */
	33	#define DIAG_FTP_STAT_PGIOE 8U /* paging I/O error */
	34	#define DIAG_FTP_STAT_TIMEOUT 12U /* timeout */
	35	#define DIAG_FTP_STAT_EBASE 16U /* base of error codes from SCLP */
	36	#define DIAG_FTP_STAT_LDFAIL (DIAG_FTP_STAT_EBASE + 1U) /* failed */
	37	#define DIAG_FTP_STAT_LDNPERM (DIAG_FTP_STAT_EBASE + 2U) /* not allowed */
	38	#define DIAG_FTP_STAT_LDRUNS (DIAG_FTP_STAT_EBASE + 3U) /* runs */
	39	#define DIAG_FTP_STAT_LDNRUNS (DIAG_FTP_STAT_EBASE + 4U) /* not runs */
	40
	41	/**
	42	* struct diag_ftp_ldfpl - load file FTP parameter list (LDFPL)
	43	* @bufaddr: real buffer address (at 4k boundary)
	44	* @buflen: length of buffer
	45	* @offset: dir/file offset
	46	* @intparm: interruption parameter (unused)
	47	* @transferred: bytes transferred
	48	* @fsize: file size, filled on GET
	49	* @failaddr: failing address
	50	* @spare: padding
	51	* @fident: file name - ASCII
	52	*/
	53	struct diag_ftp_ldfpl {
	54	u64 bufaddr;
	55	u64 buflen;
	56	u64 offset;
	57	u64 intparm;
	58	u64 transferred;
	59	u64 fsize;
	60	u64 failaddr;
	61	u64 spare;
	62	u8 fident[HMCDRV_FTP_FIDENT_MAX];
	63	} __packed;
	64
	65	static DECLARE_COMPLETION(diag_ftp_rx_complete);
	66	static int diag_ftp_subcode;
	67
	68	/**
	69	* diag_ftp_handler() - FTP services IRQ handler
	70	* @extirq: external interrupt (sub-) code
	71	* @param32: 32-bit interruption parameter from &struct diag_ftp_ldfpl
	72	* @param64: unused (for 64-bit interrupt parameters)
	73	*/
	74	static void diag_ftp_handler(struct ext_code extirq,
	75	unsigned int param32,
	76	unsigned long param64)
	77	{
	78	if ((extirq.subcode >> 8) != 8)
	79	return; /* not a FTP services sub-code */
	80
	81	inc_irq_stat(IRQEXT_FTP);
	82	diag_ftp_subcode = extirq.subcode & 0xffU;
83	complete(&diag_ftp_rx_complete);
84	}
85
86	/**
87	* diag_ftp_2c4() - DIAGNOSE X'2C4' service call
88	* @fpl: pointer to prepared LDFPL
89	* @cmd: FTP command to be executed
90	*
91	* Performs a DIAGNOSE X'2C4' call with (input/output) FTP parameter list
92	* @fpl and FTP function code @cmd. In case of an error the function does
93	* nothing and returns an (negative) error code.
94	*
95	* Notes:
96	* 1. This function only initiates a transfer, so the caller must wait
97	* for completion (asynchronous execution).
98	* 2. The FTP parameter list @fpl must be aligned to a double-word boundary.
99	* 3. fpl->bufaddr must be a real address, 4k aligned
100	*/
101	static int diag_ftp_2c4(struct diag_ftp_ldfpl *fpl,
102	enum hmcdrv_ftp_cmdid cmd)
103	{
104	int rc;
105
1ec2772e	106	diag_stat_inc(DIAG_STAT_X2C4);
8f933b10 RH	107	asm volatile(
	108	" diag %[addr],%[cmd],0x2c4\n"
	109	"0: j 2f\n"
	110	"1: la %[rc],%[err]\n"
	111	"2:\n"
	112	EX_TABLE(0b, 1b)
	113	: [rc] "=d" (rc), "+m" (*fpl)
	114	: [cmd] "0" (cmd), [addr] "d" (virt_to_phys(fpl)),
	115	[err] "i" (DIAG_FTP_RET_EPERM)
	116	: "cc");
	117
	118	switch (rc) {
	119	case DIAG_FTP_RET_OK:
	120	return 0;
	121	case DIAG_FTP_RET_EBUSY:
	122	return -EBUSY;
	123	case DIAG_FTP_RET_EPERM:
	124	return -EPERM;
	125	case DIAG_FTP_RET_EIO:
	126	default:
	127	return -EIO;
	128	}
	129	}
	130
	131	/**
	132	* diag_ftp_cmd() - executes a DIAG X'2C4' FTP command, targeting a HMC
	133	* @ftp: pointer to FTP command specification
	134	* @fsize: return of file size (or NULL if undesirable)
	135	*
	136	* Attention: Notice that this function is not reentrant - so the caller
	137	* must ensure locking.
	138	*
	139	* Return: number of bytes read/written or a (negative) error code
	140	*/
	141	ssize_t diag_ftp_cmd(const struct hmcdrv_ftp_cmdspec ftp, size_t fsize)
	142	{
	143	struct diag_ftp_ldfpl *ldfpl;
	144	ssize_t len;
	145	#ifdef DEBUG
	146	unsigned long start_jiffies;
	147
	148	pr_debug("starting DIAG X'2C4' on '%s', requesting %zd bytes\n",
	149	ftp->fname, ftp->len);
	150	start_jiffies = jiffies;
	151	#endif
	152	init_completion(&diag_ftp_rx_complete);
	153
	154	ldfpl = (void *) get_zeroed_page(GFP_KERNEL \| GFP_DMA);
	155	if (!ldfpl) {
	156	len = -ENOMEM;
	157	goto out;
	158	}
	159
	160	len = strlcpy(ldfpl->fident, ftp->fname, sizeof(ldfpl->fident));
	161	if (len >= HMCDRV_FTP_FIDENT_MAX) {
	162	len = -EINVAL;
	163	goto out_free;
	164	}
	165
	166	ldfpl->transferred = 0;
	167	ldfpl->fsize = 0;
	168	ldfpl->offset = ftp->ofs;
	169	ldfpl->buflen = ftp->len;
	170	ldfpl->bufaddr = virt_to_phys(ftp->buf);
171
172	len = diag_ftp_2c4(ldfpl, ftp->id);
173	if (len)
174	goto out_free;
175
176	/*
177	* There is no way to cancel the running diag X'2C4', the code
178	* needs to wait unconditionally until the transfer is complete.
179	*/
180	wait_for_completion(&diag_ftp_rx_complete);
181
182	#ifdef DEBUG
183	pr_debug("completed DIAG X'2C4' after %lu ms\n",
184	(jiffies - start_jiffies) * 1000 / HZ);
185	pr_debug("status of DIAG X'2C4' is %u, with %lld/%lld bytes\n",
186	diag_ftp_subcode, ldfpl->transferred, ldfpl->fsize);
187	#endif
188
189	switch (diag_ftp_subcode) {
190	case DIAG_FTP_STAT_OK: /* success */
191	len = ldfpl->transferred;
192	if (fsize)
193	*fsize = ldfpl->fsize;
194	break;
195	case DIAG_FTP_STAT_LDNPERM:
196	len = -EPERM;
197	break;
198	case DIAG_FTP_STAT_LDRUNS:
199	len = -EBUSY;
200	break;
201	case DIAG_FTP_STAT_LDFAIL:
202	len = -ENOENT; /* no such file or media */
203	break;
204	default:
205	len = -EIO;
206	break;
207	}
208
209	out_free:
210	free_page((unsigned long) ldfpl);
211	out:
212	return len;
213	}
214
215	/**
216	* diag_ftp_startup() - startup of FTP services, when running on z/VM
217	*
218	* Return: 0 on success, else an (negative) error code
219	*/
220	int diag_ftp_startup(void)
221	{
222	int rc;
223
224	rc = register_external_irq(EXT_IRQ_CP_SERVICE, diag_ftp_handler);
225	if (rc)
226	return rc;
227
e619cd3d	228	irq_subclass_register(IRQ_SUBCLASS_SERVICE_SIGNAL);
8f933b10 RH	229	return 0;
	230	}
	231
	232	/**
	233	* diag_ftp_shutdown() - shutdown of FTP services, when running on z/VM
	234	*/
	235	void diag_ftp_shutdown(void)
	236	{
e619cd3d	237	irq_subclass_unregister(IRQ_SUBCLASS_SERVICE_SIGNAL);
8f933b10 RH	238	unregister_external_irq(EXT_IRQ_CP_SERVICE, diag_ftp_handler);
8f933b10 RH	239	}