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