s390/hmcdrv: HMC drive CD/DVD access

This device driver allows accessing a HMC drive CD/DVD-ROM.
It can be used in a LPAR and z/VM environment.

Reviewed-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Reviewed-by: Heiko Carstens <heiko.carstens@de.ibm.com>
Signed-off-by: Ralf Hoppe <rhoppe@de.ibm.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>

1 files changed, 343 insertions, 0 deletions

diff --git a/drivers/s390/char/hmcdrv_ftp.c b/drivers/s390/char/hmcdrv_ftp.c
new file mode 100644
index 000000000000..4bd63322fc29
--- /dev/null
+++ b/drivers/s390/char/hmcdrv_ftp.c
@@ -0,0 +1,343 @@
+/*
+ *    HMC Drive FTP Services
+ *
+ *    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/slab.h>
+#include <linux/uaccess.h>
+#include <linux/export.h>
+
+#include <linux/ctype.h>
+#include <linux/crc16.h>
+
+#include "hmcdrv_ftp.h"
+#include "hmcdrv_cache.h"
+#include "sclp_ftp.h"
+#include "diag_ftp.h"
+
+/**
+ * struct hmcdrv_ftp_ops - HMC drive FTP operations
+ * @startup: startup function
+ * @shutdown: shutdown function
+ * @cmd: FTP transfer function
+ */
+struct hmcdrv_ftp_ops {
+        int (*startup)(void);
+        void (*shutdown)(void);
+        ssize_t (*transfer)(const struct hmcdrv_ftp_cmdspec *ftp,
+                            size_t *fsize);
+};
+
+static enum hmcdrv_ftp_cmdid hmcdrv_ftp_cmd_getid(const char *cmd, int len);
+static int hmcdrv_ftp_parse(char *cmd, struct hmcdrv_ftp_cmdspec *ftp);
+
+static struct hmcdrv_ftp_ops *hmcdrv_ftp_funcs; /* current operations */
+static DEFINE_MUTEX(hmcdrv_ftp_mutex); /* mutex for hmcdrv_ftp_funcs */
+static unsigned hmcdrv_ftp_refcnt; /* start/shutdown reference counter */
+
+/**
+ * hmcdrv_ftp_cmd_getid() - determine FTP command ID from a command string
+ * @cmd: FTP command string (NOT zero-terminated)
+ * @len: length of FTP command string in @cmd
+ */
+static enum hmcdrv_ftp_cmdid hmcdrv_ftp_cmd_getid(const char *cmd, int len)
+{
+        /* HMC FTP command descriptor */
+        struct hmcdrv_ftp_cmd_desc {
+                const char *str;           /* command string */
+                enum hmcdrv_ftp_cmdid cmd; /* associated command as enum */
+        };
+
+        /* Description of all HMC drive FTP commands
+         *
+         * Notes:
+         * 1. Array size should be a prime number.
+         * 2. Do not change the order of commands in table (because the
+         *    index is determined by CRC % ARRAY_SIZE).
+         * 3. Original command 'nlist' was renamed, else the CRC would
+         *    collide with 'append' (see point 2).
+         */
+        static const struct hmcdrv_ftp_cmd_desc ftpcmds[7] = {
+
+                {.str = "get", /* [0] get (CRC = 0x68eb) */
+                 .cmd = HMCDRV_FTP_GET},
+                {.str = "dir", /* [1] dir (CRC = 0x6a9e) */
+                 .cmd = HMCDRV_FTP_DIR},
+                {.str = "delete", /* [2] delete (CRC = 0x53ae) */
+                 .cmd = HMCDRV_FTP_DELETE},
+                {.str = "nls", /* [3] nls (CRC = 0xf87c) */
+                 .cmd = HMCDRV_FTP_NLIST},
+                {.str = "put", /* [4] put (CRC = 0xac56) */
+                 .cmd = HMCDRV_FTP_PUT},
+                {.str = "append", /* [5] append (CRC = 0xf56e) */
+                 .cmd = HMCDRV_FTP_APPEND},
+                {.str = NULL} /* [6] unused */
+        };
+
+        const struct hmcdrv_ftp_cmd_desc *pdesc;
+
+        u16 crc = 0xffffU;
+
+        if (len == 0)
+                return HMCDRV_FTP_NOOP; /* error indiactor */
+
+        crc = crc16(crc, cmd, len);
+        pdesc = ftpcmds + (crc % ARRAY_SIZE(ftpcmds));
+        pr_debug("FTP command '%s' has CRC 0x%04x, at table pos. %lu\n",
+                 cmd, crc, (crc % ARRAY_SIZE(ftpcmds)));
+
+        if (!pdesc->str || strncmp(pdesc->str, cmd, len))
+                return HMCDRV_FTP_NOOP;
+
+        pr_debug("FTP command '%s' found, with ID %d\n",
+                 pdesc->str, pdesc->cmd);
+
+        return pdesc->cmd;
+}
+
+/**
+ * hmcdrv_ftp_parse() - HMC drive FTP command parser
+ * @cmd: FTP command string "<cmd> <filename>"
+ * @ftp: Pointer to FTP command specification buffer (output)
+ *
+ * Return: 0 on success, else a (negative) error code
+ */
+static int hmcdrv_ftp_parse(char *cmd, struct hmcdrv_ftp_cmdspec *ftp)
+{
+        char *start;
+        int argc = 0;
+
+        ftp->id = HMCDRV_FTP_NOOP;
+        ftp->fname = NULL;
+
+        while (*cmd != '\0') {
+
+                while (isspace(*cmd))
+                        ++cmd;
+
+                if (*cmd == '\0')
+                        break;
+
+                start = cmd;
+
+                switch (argc) {
+                case 0: /* 1st argument (FTP command) */
+                        while ((*cmd != '\0') && !isspace(*cmd))
+                                ++cmd;
+                        ftp->id = hmcdrv_ftp_cmd_getid(start, cmd - start);
+                        break;
+                case 1: /* 2nd / last argument (rest of line) */
+                        while ((*cmd != '\0') && !iscntrl(*cmd))
+                                ++cmd;
+                        ftp->fname = start;
+                        /* fall through */
+                default:
+                        *cmd = '\0';
+                        break;
+                } /* switch */
+
+                ++argc;
+        } /* while */
+
+        if (!ftp->fname || (ftp->id == HMCDRV_FTP_NOOP))
+                return -EINVAL;
+
+        return 0;
+}
+
+/**
+ * hmcdrv_ftp_do() - perform a HMC drive FTP, with data from kernel-space
+ * @ftp: pointer to FTP command specification
+ *
+ * Return: number of bytes read/written or a negative error code
+ */
+ssize_t hmcdrv_ftp_do(const struct hmcdrv_ftp_cmdspec *ftp)
+{
+        ssize_t len;
+
+        mutex_lock(&hmcdrv_ftp_mutex);
+
+        if (hmcdrv_ftp_funcs && hmcdrv_ftp_refcnt) {
+                pr_debug("starting transfer, cmd %d for '%s' at %lld with %zd bytes\n",
+                         ftp->id, ftp->fname, (long long) ftp->ofs, ftp->len);
+                len = hmcdrv_cache_cmd(ftp, hmcdrv_ftp_funcs->transfer);
+        } else {
+                len = -ENXIO;
+        }
+
+        mutex_unlock(&hmcdrv_ftp_mutex);
+        return len;
+}
+EXPORT_SYMBOL(hmcdrv_ftp_do);
+
+/**
+ * hmcdrv_ftp_probe() - probe for the HMC drive FTP service
+ *
+ * Return: 0 if service is available, else an (negative) error code
+ */
+int hmcdrv_ftp_probe(void)
+{
+        int rc;
+
+        struct hmcdrv_ftp_cmdspec ftp = {
+                .id = HMCDRV_FTP_NOOP,
+                .ofs = 0,
+                .fname = "",
+                .len = PAGE_SIZE
+        };
+
+        ftp.buf = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
+
+        if (!ftp.buf)
+                return -ENOMEM;
+
+        rc = hmcdrv_ftp_startup();
+
+        if (rc)
+                return rc;
+
+        rc = hmcdrv_ftp_do(&ftp);
+        free_page((unsigned long) ftp.buf);
+        hmcdrv_ftp_shutdown();
+
+        switch (rc) {
+        case -ENOENT: /* no such file/media or currently busy, */
+        case -EBUSY:  /* but service seems to be available */
+                rc = 0;
+                break;
+        default: /* leave 'rc' as it is for [0, -EPERM, -E...] */
+                if (rc > 0)
+                        rc = 0; /* clear length (success) */
+                break;
+        } /* switch */
+
+        return rc;
+}
+EXPORT_SYMBOL(hmcdrv_ftp_probe);
+
+/**
+ * hmcdrv_ftp_cmd() - Perform a HMC drive FTP, with data from user-space
+ *
+ * @cmd: FTP command string "<cmd> <filename>"
+ * @offset: file position to read/write
+ * @buf: user-space buffer for read/written directory/file
+ * @len: size of @buf (read/dir) or number of bytes to write
+ *
+ * This function must not be called before hmcdrv_ftp_startup() was called.
+ *
+ * Return: number of bytes read/written or a negative error code
+ */
+ssize_t hmcdrv_ftp_cmd(char __kernel *cmd, loff_t offset,
+                       char __user *buf, size_t len)
+{
+        int order;
+
+        struct hmcdrv_ftp_cmdspec ftp = {.len = len, .ofs = offset};
+        ssize_t retlen = hmcdrv_ftp_parse(cmd, &ftp);
+
+        if (retlen)
+                return retlen;
+
+        order = get_order(ftp.len);
+        ftp.buf = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, order);
+
+        if (!ftp.buf)
+                return -ENOMEM;
+
+        switch (ftp.id) {
+        case HMCDRV_FTP_DIR:
+        case HMCDRV_FTP_NLIST:
+        case HMCDRV_FTP_GET:
+                retlen = hmcdrv_ftp_do(&ftp);
+
+                if ((retlen >= 0) &&
+                    copy_to_user(buf, ftp.buf, retlen))
+                        retlen = -EFAULT;
+                break;
+
+        case HMCDRV_FTP_PUT:
+        case HMCDRV_FTP_APPEND:
+                if (!copy_from_user(ftp.buf, buf, ftp.len))
+                        retlen = hmcdrv_ftp_do(&ftp);
+                else
+                        retlen = -EFAULT;
+                break;
+
+        case HMCDRV_FTP_DELETE:
+                retlen = hmcdrv_ftp_do(&ftp);
+                break;
+
+        default:
+                retlen = -EOPNOTSUPP;
+                break;
+        }
+
+        free_pages((unsigned long) ftp.buf, order);
+        return retlen;
+}
+
+/**
+ * hmcdrv_ftp_startup() - startup of HMC drive FTP functionality for a
+ * dedicated (owner) instance
+ *
+ * Return: 0 on success, else an (negative) error code
+ */
+int hmcdrv_ftp_startup(void)
+{
+        static struct hmcdrv_ftp_ops hmcdrv_ftp_zvm = {
+                .startup = diag_ftp_startup,
+                .shutdown = diag_ftp_shutdown,
+                .transfer = diag_ftp_cmd
+        };
+
+        static struct hmcdrv_ftp_ops hmcdrv_ftp_lpar = {
+                .startup = sclp_ftp_startup,
+                .shutdown = sclp_ftp_shutdown,
+                .transfer = sclp_ftp_cmd
+        };
+
+        int rc = 0;
+
+        mutex_lock(&hmcdrv_ftp_mutex); /* block transfers while start-up */
+
+        if (hmcdrv_ftp_refcnt == 0) {
+                if (MACHINE_IS_VM)
+                        hmcdrv_ftp_funcs = &hmcdrv_ftp_zvm;
+                else if (MACHINE_IS_LPAR || MACHINE_IS_KVM)
+                        hmcdrv_ftp_funcs = &hmcdrv_ftp_lpar;
+                else
+                        rc = -EOPNOTSUPP;
+
+                if (hmcdrv_ftp_funcs)
+                        rc = hmcdrv_ftp_funcs->startup();
+        }
+
+        if (!rc)
+                ++hmcdrv_ftp_refcnt;
+
+        mutex_unlock(&hmcdrv_ftp_mutex);
+        return rc;
+}
+EXPORT_SYMBOL(hmcdrv_ftp_startup);
+
+/**
+ * hmcdrv_ftp_shutdown() - shutdown of HMC drive FTP functionality for a
+ * dedicated (owner) instance
+ */
+void hmcdrv_ftp_shutdown(void)
+{
+        mutex_lock(&hmcdrv_ftp_mutex);
+        --hmcdrv_ftp_refcnt;
+
+        if ((hmcdrv_ftp_refcnt == 0) && hmcdrv_ftp_funcs)
+                hmcdrv_ftp_funcs->shutdown();
+
+        mutex_unlock(&hmcdrv_ftp_mutex);
+}
+EXPORT_SYMBOL(hmcdrv_ftp_shutdown);