Quelle  hmcdrv_ftp.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 *    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 <asm/machine.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
 * @transfer: 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 const 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;
   fallthrough;
  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)
  goto out;

 rc = hmcdrv_ftp_do(&ftp);
 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 */
out:
 free_page((unsigned long) ftp.buf);
 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 const struct hmcdrv_ftp_ops hmcdrv_ftp_zvm = {
  .startup = diag_ftp_startup,
  .shutdown = diag_ftp_shutdown,
  .transfer = diag_ftp_cmd
 };

 static const 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);