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 | strscpy(p: hmcdrv_cache_file.fname, q: 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(size: cachesize); |
220 | hmcdrv_cache_file.content = |
221 | (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, |
222 | order: 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(addr: (unsigned long) hmcdrv_cache_file.content, |
245 | order: 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 | |