1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (C) Nelson Integration, LLC 2016
4 * Author: Eric Nelson<eric@nelint.com>
5 *
6 */
7 #include <config.h>
8 #include <common.h>
9 #include <malloc.h>
10 #include <part.h>
11 #include <linux/ctype.h>
12 #include <linux/list.h>
13
14 struct block_cache_node {
15 struct list_head lh;
16 int iftype;
17 int devnum;
18 lbaint_t start;
19 lbaint_t blkcnt;
20 unsigned long blksz;
21 char *cache;
22 };
23
24 static LIST_HEAD(block_cache);
25
26 static struct block_cache_stats _stats = {
27 .max_blocks_per_entry = 8,
28 .max_entries = 32
29 };
30
cache_find(int iftype,int devnum,lbaint_t start,lbaint_t blkcnt,unsigned long blksz)31 static struct block_cache_node *cache_find(int iftype, int devnum,
32 lbaint_t start, lbaint_t blkcnt,
33 unsigned long blksz)
34 {
35 struct block_cache_node *node;
36
37 list_for_each_entry(node, &block_cache, lh)
38 if ((node->iftype == iftype) &&
39 (node->devnum == devnum) &&
40 (node->blksz == blksz) &&
41 (node->start <= start) &&
42 (node->start + node->blkcnt >= start + blkcnt)) {
43 if (block_cache.next != &node->lh) {
44 /* maintain MRU ordering */
45 list_del(&node->lh);
46 list_add(&node->lh, &block_cache);
47 }
48 return node;
49 }
50 return 0;
51 }
52
blkcache_read(int iftype,int devnum,lbaint_t start,lbaint_t blkcnt,unsigned long blksz,void * buffer)53 int blkcache_read(int iftype, int devnum,
54 lbaint_t start, lbaint_t blkcnt,
55 unsigned long blksz, void *buffer)
56 {
57 struct block_cache_node *node = cache_find(iftype, devnum, start,
58 blkcnt, blksz);
59 if (node) {
60 const char *src = node->cache + (start - node->start) * blksz;
61 memcpy(buffer, src, blksz * blkcnt);
62 debug("hit: start " LBAF ", count " LBAFU "\n",
63 start, blkcnt);
64 ++_stats.hits;
65 return 1;
66 }
67
68 debug("miss: start " LBAF ", count " LBAFU "\n",
69 start, blkcnt);
70 ++_stats.misses;
71 return 0;
72 }
73
blkcache_fill(int iftype,int devnum,lbaint_t start,lbaint_t blkcnt,unsigned long blksz,void const * buffer)74 void blkcache_fill(int iftype, int devnum,
75 lbaint_t start, lbaint_t blkcnt,
76 unsigned long blksz, void const *buffer)
77 {
78 lbaint_t bytes;
79 struct block_cache_node *node;
80
81 /* don't cache big stuff */
82 if (blkcnt > _stats.max_blocks_per_entry)
83 return;
84
85 if (_stats.max_entries == 0)
86 return;
87
88 bytes = blksz * blkcnt;
89 if (_stats.max_entries <= _stats.entries) {
90 /* pop LRU */
91 node = (struct block_cache_node *)block_cache.prev;
92 list_del(&node->lh);
93 _stats.entries--;
94 debug("drop: start " LBAF ", count " LBAFU "\n",
95 node->start, node->blkcnt);
96 if (node->blkcnt * node->blksz < bytes) {
97 free(node->cache);
98 node->cache = 0;
99 }
100 } else {
101 node = malloc(sizeof(*node));
102 if (!node)
103 return;
104 node->cache = 0;
105 }
106
107 if (!node->cache) {
108 node->cache = malloc(bytes);
109 if (!node->cache) {
110 free(node);
111 return;
112 }
113 }
114
115 debug("fill: start " LBAF ", count " LBAFU "\n",
116 start, blkcnt);
117
118 node->iftype = iftype;
119 node->devnum = devnum;
120 node->start = start;
121 node->blkcnt = blkcnt;
122 node->blksz = blksz;
123 memcpy(node->cache, buffer, bytes);
124 list_add(&node->lh, &block_cache);
125 _stats.entries++;
126 }
127
blkcache_invalidate(int iftype,int devnum)128 void blkcache_invalidate(int iftype, int devnum)
129 {
130 struct list_head *entry, *n;
131 struct block_cache_node *node;
132
133 list_for_each_safe(entry, n, &block_cache) {
134 node = (struct block_cache_node *)entry;
135 if ((node->iftype == iftype) &&
136 (node->devnum == devnum)) {
137 list_del(entry);
138 free(node->cache);
139 free(node);
140 --_stats.entries;
141 }
142 }
143 }
144
blkcache_configure(unsigned blocks,unsigned entries)145 void blkcache_configure(unsigned blocks, unsigned entries)
146 {
147 struct block_cache_node *node;
148 if ((blocks != _stats.max_blocks_per_entry) ||
149 (entries != _stats.max_entries)) {
150 /* invalidate cache */
151 while (!list_empty(&block_cache)) {
152 node = (struct block_cache_node *)block_cache.next;
153 list_del(&node->lh);
154 free(node->cache);
155 free(node);
156 }
157 _stats.entries = 0;
158 }
159
160 _stats.max_blocks_per_entry = blocks;
161 _stats.max_entries = entries;
162
163 _stats.hits = 0;
164 _stats.misses = 0;
165 }
166
blkcache_stats(struct block_cache_stats * stats)167 void blkcache_stats(struct block_cache_stats *stats)
168 {
169 memcpy(stats, &_stats, sizeof(*stats));
170 _stats.hits = 0;
171 _stats.misses = 0;
172 }
173