xref: /titanic_41/usr/src/lib/efcode/engine/mcookie.c (revision f1a9a1f881e55d2d4a8ba89b25efea86686dc261)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 #pragma ident	"%Z%%M%	%I%	%E% SMI"
27 
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <stdarg.h>
32 
33 #include <fcode/private.h>
34 #include <fcode/log.h>
35 
36 #include <fcdriver/fcdriver.h>
37 
38 #define	MAX_MAPS	256
39 
40 #define	MAP_IS_VALID		0x01
41 
42 struct map_table {
43 	int map_flags;
44 	uint64_t map_add;
45 	size_t map_size;
46 	uint64_t adj_virt;
47 	size_t adj_length;
48 } map_table[MAX_MAPS];
49 
50 /*
51  * Originally, this code translated kernel supplied virtual addresses into
52  * "memory cookies", which was a 32-bit number with ascii-M in the upper 8
53  * bits, a 4-bit index and a 20-bit offset.  However, this caused two
54  * problems:  1) the 20-bit offset was too small for some devices, esp. some
55  * with frame-buffers;  2) if the fcode used the cookie to program the
56  * hardware, there was no easy way for the software to detect that a
57  * translation needed to be done.
58  *
59  * For that reason, "memory cookies" are now just the kernel-supplied
60  * virtual address, and we now check each memory access to see if it's
61  * attempting to access kernel-supplied memory.  The only important thing
62  * now is that "is_mcookie" returns 1 (or true) if the tested mcookie
63  * is a kernel virtual address.
64  *
65  * There is a potential bug if the kernel virtual address happens to
66  * conflict with a user virtual address.  However, the current implementation
67  * of Solaris avoids this conflict.
68  */
69 
70 fstack_t
mapping_to_mcookie(uint64_t req_add,size_t req_size,uint64_t adj_virt,size_t adj_length)71 mapping_to_mcookie(uint64_t req_add, size_t req_size, uint64_t adj_virt,
72     size_t adj_length)
73 {
74 	int i;
75 	struct map_table *mp;
76 
77 	for (i = 0, mp = map_table; i < MAX_MAPS; i++, mp++)
78 		if ((mp->map_flags & MAP_IS_VALID) == 0)
79 			break;
80 	if (i == MAX_MAPS) {
81 		log_message(MSG_WARN, "Warning: too many mappings\n");
82 		return (0);
83 	}
84 	debug_msg(DEBUG_REG_ACCESS, "Allocating mapping: %d add: 0x%llx"
85 	    " size: 0x%x\n", i, req_add, req_size);
86 	mp->map_flags |= MAP_IS_VALID;
87 	mp->map_add = req_add;
88 	mp->map_size = req_size;
89 	mp->adj_virt = adj_virt;
90 	mp->adj_length = adj_length;
91 	if (mp->adj_length != 0)
92 		return (adj_virt);
93 	else
94 		return (req_add);
95 }
96 
97 void
delete_mapping(fstack_t mcookie)98 delete_mapping(fstack_t mcookie)
99 {
100 	int i;
101 	struct map_table *mp;
102 
103 	for (i = 0, mp = map_table; i < MAX_MAPS; i++, mp++) {
104 		if ((mp->map_flags & MAP_IS_VALID) &&
105 		    mcookie >= mp->map_add &&
106 		    mcookie < mp->map_add + mp->map_size) {
107 			debug_msg(DEBUG_REG_ACCESS, "Deallocating mapping: %d"
108 			    " add: 0x%llx size: 0x%x\n", i, mp->map_add,
109 			    mp->map_size);
110 			mp->map_flags &= ~MAP_IS_VALID;
111 			mp->map_add = 0;
112 			mp->map_size = 0;
113 			mp->adj_virt = 0;
114 			mp->adj_length = 0;
115 			return;
116 		}
117 	}
118 	log_message(MSG_WARN, "Warning: delete_mapping: invalid"
119 		" mcookie: %llx\n", (uint64_t)mcookie);
120 }
121 
122 int
is_mcookie(fstack_t mcookie)123 is_mcookie(fstack_t mcookie)
124 {
125 	struct map_table *mp;
126 	int i;
127 
128 	for (i = 0, mp = map_table; i < MAX_MAPS; i++, mp++)
129 		if ((mp->map_flags & MAP_IS_VALID) &&
130 		    mcookie >= mp->map_add &&
131 		    mcookie < mp->map_add + mp->map_size)
132 			return (1);
133 	return (0);
134 }
135 
136 uint64_t
mcookie_to_addr(fstack_t mcookie)137 mcookie_to_addr(fstack_t mcookie)
138 {
139 	return (mcookie);
140 }
141 
142 fstack_t
mcookie_to_rlen(fstack_t mcookie)143 mcookie_to_rlen(fstack_t mcookie)
144 {
145 	int i;
146 	struct map_table *mp;
147 
148 	for (i = 0, mp = map_table; i < MAX_MAPS; i++, mp++) {
149 		if ((mp->map_flags & MAP_IS_VALID) &&
150 		    mcookie >= mp->map_add &&
151 		    mcookie < mp->map_add + mp->map_size) {
152 			return (mp->map_size);
153 		}
154 	}
155 	log_message(MSG_WARN, "Warning: mcookie_to_rlen: invalid"
156 	    " mcookie: %llx\n", (uint64_t)mcookie);
157 
158 	return (0);
159 }
160 
161 fstack_t
mcookie_to_rvirt(fstack_t mcookie)162 mcookie_to_rvirt(fstack_t mcookie)
163 {
164 	int i;
165 	struct map_table *mp;
166 
167 	for (i = 0, mp = map_table; i < MAX_MAPS; i++, mp++) {
168 		if ((mp->map_flags & MAP_IS_VALID) &&
169 		    mcookie >= mp->map_add &&
170 		    mcookie < mp->map_add + mp->map_size) {
171 			return (mp->map_add);
172 		}
173 	}
174 	log_message(MSG_WARN, "Warning: mcookie_to_rvirt: invalid"
175 	    " mcookie: %llx\n", (uint64_t)mcookie);
176 
177 	return (0);
178 }
179 
180 static void
dot_maps(fcode_env_t * env)181 dot_maps(fcode_env_t *env)
182 {
183 	int i;
184 
185 	log_message(MSG_DEBUG, "idx     base-addr        size\n");
186 	for (i = 0; i < MAX_MAPS; i++) {
187 		if (map_table[i].map_flags & MAP_IS_VALID)
188 			log_message(MSG_DEBUG, "%3d %016llx %8x\n", i,
189 			    map_table[i].map_add, map_table[i].map_size);
190 	}
191 }
192 
193 static void
map_qmark(fcode_env_t * env)194 map_qmark(fcode_env_t *env)
195 {
196 	fstack_t d = POP(DS);
197 
198 	if (!is_mcookie(d))
199 		log_message(MSG_INFO, "%llx: not mcookie\n", (uint64_t)d);
200 	else
201 		log_message(MSG_INFO, "%llx -> %llx\n", (uint64_t)d,
202 		    mcookie_to_addr(d));
203 }
204 
205 static void
add_map(fcode_env_t * env)206 add_map(fcode_env_t *env)
207 {
208 	fstack_t size, addr;
209 
210 	size = POP(DS);
211 	addr = POP(DS);
212 	addr = mapping_to_mcookie(addr, size, NULL, NULL);
213 	PUSH(DS, addr);
214 }
215 
216 static void
del_map(fcode_env_t * env)217 del_map(fcode_env_t *env)
218 {
219 	fstack_t addr;
220 
221 	addr = POP(DS);
222 	delete_mapping(addr);
223 }
224 
225 
226 #pragma init(_init)
227 
228 static void
_init(void)229 _init(void)
230 {
231 	fcode_env_t *env = initial_env;
232 
233 	ASSERT(env);
234 	NOTICE;
235 
236 	FORTH(0,	".maps",		dot_maps);
237 	FORTH(0,	"map?",			map_qmark);
238 	FORTH(0,	"add-map",		add_map);
239 	FORTH(0,	"del-map",		del_map);
240 }
241