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 } 254