drivers/s390/char/hmcdrv_cache.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *    SE/HMC Drive (Read) Cache Functions
   4  *
   5  *    Copyright IBM Corp. 2013
   6  *    Author(s): Ralf Hoppe (rhoppe@de.ibm.com)
   7  *
   8  */
   9
  10 #define KMSG_COMPONENT "hmcdrv"
  11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  12
  13 #include <linux/kernel.h>
  14 #include <linux/mm.h>
  15 #include <linux/jiffies.h>
  16
  17 #include "hmcdrv_ftp.h"
  18 #include "hmcdrv_cache.h"
  19
  20 #define HMCDRV_CACHE_TIMEOUT            30 /* aging timeout in seconds */
  21
  22 /**
  23  * struct hmcdrv_cache_entry - file cache (only used on read/dir)
  24  * @id: FTP command ID
  25  * @content: kernel-space buffer, 4k aligned
  26  * @len: size of @content cache (0 if caching disabled)
  27  * @ofs: start of content within file (-1 if no cached content)
  28  * @fname: file name
  29  * @fsize: file size
  30  * @timeout: cache timeout in jiffies
  31  *
  32  * Notice that the first three members (id, fname, fsize) are cached on all
  33  * read/dir requests. But content is cached only under some preconditions.
  34  * Uncached content is signalled by a negative value of @ofs.
  35  */
  36 struct hmcdrv_cache_entry {
  37         enum hmcdrv_ftp_cmdid id;
  38         char fname[HMCDRV_FTP_FIDENT_MAX];
  39         size_t fsize;
  40         loff_t ofs;
  41         unsigned long timeout;
  42         void *content;
  43         size_t len;
  44 };
  45
  46 static int hmcdrv_cache_order; /* cache allocated page order */
  47
  48 static struct hmcdrv_cache_entry hmcdrv_cache_file = {
  49         .fsize = SIZE_MAX,
  50         .ofs = -1,
  51         .len = 0,
  52         .fname = {'\0'}
  53 };
  54
  55 /**
  56  * hmcdrv_cache_get() - looks for file data/content in read cache
  57  * @ftp: pointer to FTP command specification
  58  *
  59  * Return: number of bytes read from cache or a negative number if nothing
  60  * in content cache (for the file/cmd specified in @ftp)
  61  */
  62 static ssize_t hmcdrv_cache_get(const struct hmcdrv_ftp_cmdspec *ftp)
  63 {
  64         loff_t pos; /* position in cache (signed) */
  65         ssize_t len;
  66
  67         if ((ftp->id != hmcdrv_cache_file.id) ||
  68             strcmp(hmcdrv_cache_file.fname, ftp->fname))
  69                 return -1;
  70
  71         if (ftp->ofs >= hmcdrv_cache_file.fsize) /* EOF ? */
  72                 return 0;
  73
  74         if ((hmcdrv_cache_file.ofs < 0) || /* has content? */
  75             time_after(jiffies, hmcdrv_cache_file.timeout))
  76                 return -1;
  77
  78         /* there seems to be cached content - calculate the maximum number
  79          * of bytes that can be returned (regarding file size and offset)
  80          */
  81         len = hmcdrv_cache_file.fsize - ftp->ofs;
  82
  83         if (len > ftp->len)
  84                 len = ftp->len;
  85
  86         /* check if the requested chunk falls into our cache (which starts
  87          * at offset 'hmcdrv_cache_file.ofs' in the file of interest)
  88          */
  89         pos = ftp->ofs - hmcdrv_cache_file.ofs;
  90
  91         if ((pos >= 0) &&
  92             ((pos + len) <= hmcdrv_cache_file.len)) {
  93
  94                 memcpy(ftp->buf,
  95                        hmcdrv_cache_file.content + pos,
  96                        len);
  97                 pr_debug("using cached content of '%s', returning %zd/%zd bytes\n",
  98                          hmcdrv_cache_file.fname, len,
  99                          hmcdrv_cache_file.fsize);
 100
 101                 return len;
 102         }
 103
 104         return -1;
 105 }
 106
 107 /**
 108  * hmcdrv_cache_do() - do a HMC drive CD/DVD transfer with cache update
 109  * @ftp: pointer to FTP command specification
 110  * @func: FTP transfer function to be used
 111  *
 112  * Return: number of bytes read/written or a (negative) error code
 113  */
 114 static ssize_t hmcdrv_cache_do(const struct hmcdrv_ftp_cmdspec *ftp,
 115                                hmcdrv_cache_ftpfunc func)
 116 {
 117         ssize_t len;
 118
 119         /* only cache content if the read/dir cache really exists
 120          * (hmcdrv_cache_file.len > 0), is large enough to handle the
 121          * request (hmcdrv_cache_file.len >= ftp->len) and there is a need
 122          * to do so (ftp->len > 0)
 123          */
 124         if ((ftp->len > 0) && (hmcdrv_cache_file.len >= ftp->len)) {
 125
 126                 /* because the cache is not located at ftp->buf, we have to
 127                  * assemble a new HMC drive FTP cmd specification (pointing
 128                  * to our cache, and using the increased size)
 129                  */
 130                 struct hmcdrv_ftp_cmdspec cftp = *ftp; /* make a copy */
 131                 cftp.buf = hmcdrv_cache_file.content;  /* and update */
 132                 cftp.len = hmcdrv_cache_file.len;      /* buffer data */
 133
 134                 len = func(&cftp, &hmcdrv_cache_file.fsize); /* now do */
 135
 136                 if (len > 0) {
 137                         pr_debug("caching %zd bytes content for '%s'\n",
 138                                  len, ftp->fname);
 139
 140                         if (len > ftp->len)
 141                                 len = ftp->len;
 142
 143                         hmcdrv_cache_file.ofs = ftp->ofs;
 144                         hmcdrv_cache_file.timeout = jiffies +
 145                                 HMCDRV_CACHE_TIMEOUT * HZ;
 146                         memcpy(ftp->buf, hmcdrv_cache_file.content, len);
 147                 }
 148         } else {
 149                 len = func(ftp, &hmcdrv_cache_file.fsize);
 150                 hmcdrv_cache_file.ofs = -1; /* invalidate content */
 151         }
 152
 153         if (len > 0) {
 154                 /* cache some file info (FTP command, file name and file
 155                  * size) unconditionally
 156                  */
 157                 strlcpy(hmcdrv_cache_file.fname, ftp->fname,
 158                         HMCDRV_FTP_FIDENT_MAX);
 159                 hmcdrv_cache_file.id = ftp->id;
 160                 pr_debug("caching cmd %d, file size %zu for '%s'\n",
 161                          ftp->id, hmcdrv_cache_file.fsize, ftp->fname);
 162         }
 163
 164         return len;
 165 }
 166
 167 /**
 168  * hmcdrv_cache_cmd() - perform a cached HMC drive CD/DVD transfer
 169  * @ftp: pointer to FTP command specification
 170  * @func: FTP transfer function to be used
 171  *
 172  * Attention: Notice that this function is not reentrant - so the caller
 173  * must ensure exclusive execution.
 174  *
 175  * Return: number of bytes read/written or a (negative) error code
 176  */
 177 ssize_t hmcdrv_cache_cmd(const struct hmcdrv_ftp_cmdspec *ftp,
 178                          hmcdrv_cache_ftpfunc func)
 179 {
 180         ssize_t len;
 181
 182         if ((ftp->id == HMCDRV_FTP_DIR) || /* read cache */
 183             (ftp->id == HMCDRV_FTP_NLIST) ||
 184             (ftp->id == HMCDRV_FTP_GET)) {
 185
 186                 len = hmcdrv_cache_get(ftp);
 187
 188                 if (len >= 0) /* got it from cache ? */
 189                         return len; /* yes */
 190
 191                 len = hmcdrv_cache_do(ftp, func);
 192
 193                 if (len >= 0)
 194                         return len;
 195
 196         } else {
 197                 len = func(ftp, NULL); /* simply do original command */
 198         }
 199
 200         /* invalidate the (read) cache in case there was a write operation
 201          * or an error on read/dir
 202          */
 203         hmcdrv_cache_file.id = HMCDRV_FTP_NOOP;
 204         hmcdrv_cache_file.fsize = LLONG_MAX;
 205         hmcdrv_cache_file.ofs = -1;
 206
 207         return len;
 208 }
 209
 210 /**
 211  * hmcdrv_cache_startup() - startup of HMC drive cache
 212  * @cachesize: cache size
 213  *
 214  * Return: 0 on success, else a (negative) error code
 215  */
 216 int hmcdrv_cache_startup(size_t cachesize)
 217 {
 218         if (cachesize > 0) { /* perform caching ? */
 219                 hmcdrv_cache_order = get_order(cachesize);
 220                 hmcdrv_cache_file.content =
 221                         (void *) __get_free_pages(GFP_KERNEL | GFP_DMA,
 222                                                   hmcdrv_cache_order);
 223
 224                 if (!hmcdrv_cache_file.content) {
 225                         pr_err("Allocating the requested cache size of %zu bytes failed\n",
 226                                cachesize);
 227                         return -ENOMEM;
 228                 }
 229
 230                 pr_debug("content cache enabled, size is %zu bytes\n",
 231                          cachesize);
 232         }
 233
 234         hmcdrv_cache_file.len = cachesize;
 235         return 0;
 236 }
 237
 238 /**
 239  * hmcdrv_cache_shutdown() - shutdown of HMC drive cache
 240  */
 241 void hmcdrv_cache_shutdown(void)
 242 {
 243         if (hmcdrv_cache_file.content) {
 244                 free_pages((unsigned long) hmcdrv_cache_file.content,
 245                            hmcdrv_cache_order);
 246                 hmcdrv_cache_file.content = NULL;
 247         }
 248
 249         hmcdrv_cache_file.id = HMCDRV_FTP_NOOP;
 250         hmcdrv_cache_file.fsize = LLONG_MAX;
 251         hmcdrv_cache_file.ofs = -1;
 252         hmcdrv_cache_file.len = 0; /* no cache */
 253 }