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