Print this page
2601 kctl_isadep.c should support four serial consoles
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/mdb/intel/kmdb/kctl/kctl_isadep.c
+++ new/usr/src/cmd/mdb/intel/kmdb/kctl/kctl_isadep.c
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
|
↓ open down ↓ |
12 lines elided |
↑ open up ↑ |
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21
22 22 /*
23 + * Copyright (c) 2012 Gary Mills
24 + *
23 25 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
24 26 * Use is subject to license terms.
25 27 */
26 28
27 -#pragma ident "%Z%%M% %I% %E% SMI"
28 -
29 29 #include <kmdb/kmdb_auxv.h>
30 30 #include <kmdb/kctl/kctl.h>
31 31
32 32 #include <sys/bootconf.h>
33 33 #include <sys/kobj.h>
34 34 #include <sys/kobj_impl.h>
35 35 #include <sys/cpuvar.h>
36 36 #include <sys/kdi_impl.h>
37 37 #include <sys/x86_archext.h>
38 38 #include <sys/controlregs.h>
39 39 #include <sys/archsystm.h>
40 40
41 41 static int
42 42 kctl_boot_prop_read(char *pname, char *prop_buf, int buf_len)
43 43 {
44 44 struct bootops *ops = kctl.kctl_boot_ops;
45 45 int len;
46 46
47 47 len = BOP_GETPROPLEN(ops, pname);
48 48 if (len > 0 && len <= buf_len) {
49 49 (void) BOP_GETPROP(ops, pname, (void *)prop_buf);
50 50 return (1);
51 51 }
52 52
53 53 return (0);
54 54 }
55 55
56 56 static int
57 57 kctl_ddi_prop_read(char *pname, char *prop_buf, int buf_len)
58 58 {
59 59 dev_info_t *dip = ddi_root_node();
60 60 char *val;
61 61 int ret = 0;
62 62
63 63 if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip,
64 64 DDI_PROP_DONTPASS, pname, &val) != DDI_SUCCESS)
65 65 return (0);
66 66
67 67 if (strlen(val) < buf_len) {
68 68 (void) strcpy(prop_buf, val);
69 69 ret = 1;
70 70 }
|
↓ open down ↓ |
32 lines elided |
↑ open up ↑ |
71 71
72 72 ddi_prop_free(val);
73 73 return (ret);
74 74 }
75 75
76 76 /*
77 77 * We don't have any property-walking routines, so we have to specifically
78 78 * query and thus have guilty knowledge of the properties that the
79 79 * debugger wants to see.
80 80 *
81 - * Here actually we only support four console properties:
82 - * input-device, output-device, ttya-mode, ttyb-mode.
81 + * Here actually we only support six console properties:
82 + * input-device, output-device, tty[a-d]-mode.
83 83 */
84 -#define KCTL_PROPNV_NENT 4
84 +#define KCTL_PROPNV_NIODEV 2
85 +#define KCTL_PROPNV_NTTYMD 4
86 +#define KCTL_PROPNV_NENT (KCTL_PROPNV_NIODEV + KCTL_PROPNV_NTTYMD)
85 87
86 88 static kmdb_auxv_nv_t *
87 89 kctl_pcache_create(int *nprops)
88 90 {
89 91 int (*preader)(char *, char *, int);
90 92 kmdb_auxv_nv_t *pnv;
91 93 size_t psz = sizeof (kmdb_auxv_nv_t) * KCTL_PROPNV_NENT;
94 + char *inputdev, *outputdev;
95 + int i;
96 + char ttymode[] = "ttyX-mode";
92 97
93 98 if (kctl.kctl_boot_loaded) {
94 99 preader = kctl_boot_prop_read;
95 100 } else {
96 101 preader = kctl_ddi_prop_read;
97 102 }
98 103
99 104 pnv = kobj_alloc(psz, KM_WAIT);
105 + inputdev = (&pnv[0])->kanv_val;
106 + outputdev = (&pnv[1])->kanv_val;
100 107
108 + /* Set the property names. */
101 109 (void) strcpy((&pnv[0])->kanv_name, "input-device");
102 110 (void) strcpy((&pnv[1])->kanv_name, "output-device");
103 - (void) strcpy((&pnv[2])->kanv_name, "ttya-mode");
104 - (void) strcpy((&pnv[3])->kanv_name, "ttyb-mode");
111 + for (i = 0; i < KCTL_PROPNV_NTTYMD; i++) {
112 + ttymode[3] = 'a' + i;
113 + (void) strcpy((&pnv[i + KCTL_PROPNV_NIODEV])->kanv_name,
114 + ttymode);
115 + }
105 116
106 117 /*
107 118 * console is defined by "console" property, with
108 119 * fallback on the old "input-device" property.
109 120 */
110 - (void) strcpy((&pnv[0])->kanv_val, "text"); /* default to screen */
111 - if (!preader("console", (&pnv[0])->kanv_val,
112 - sizeof ((&pnv[0])->kanv_val)))
113 - (void) preader("input-device", (&pnv[0])->kanv_val,
121 + (void) strcpy(inputdev, "text"); /* default to screen */
122 + if (!preader("console", inputdev, sizeof ((&pnv[0])->kanv_val)))
123 + (void) preader("input-device", inputdev,
114 124 sizeof ((&pnv[0])->kanv_val));
115 125
116 - if (strcmp((&pnv[0])->kanv_val, "ttya") == 0 ||
117 - strcmp((&pnv[0])->kanv_val, "ttyb") == 0) {
118 - (void) strcpy((&pnv[1])->kanv_val, (&pnv[0])->kanv_val);
126 + if (strncmp(inputdev, "tty", 3) == 0 &&
127 + inputdev[4] == '\0' &&
128 + inputdev[3] >= 'a' &&
129 + inputdev[3] < 'a' + KCTL_PROPNV_NTTYMD) {
130 + (void) strcpy(outputdev, inputdev);
119 131 } else {
120 - (void) strcpy((&pnv[0])->kanv_val, "keyboard");
121 - (void) strcpy((&pnv[1])->kanv_val, "screen");
132 + (void) strcpy(inputdev, "keyboard");
133 + (void) strcpy(outputdev, "screen");
122 134 }
123 135
124 - if (!preader((&pnv[2])->kanv_name, (&pnv[2])->kanv_val,
125 - sizeof ((&pnv[2])->kanv_val)))
126 - (void) strcpy((&pnv[2])->kanv_val, "9600,8,n,1,-");
136 + /* Set tty modes or defaults. */
137 + for (i = KCTL_PROPNV_NIODEV; i < KCTL_PROPNV_NENT; i++) {
138 + if (!preader((&pnv[i])->kanv_name, (&pnv[i])->kanv_val,
139 + sizeof ((&pnv[0])->kanv_val)))
140 + (void) strcpy((&pnv[i])->kanv_val, "9600,8,n,1,-");
141 + }
127 142
128 - if (!preader((&pnv[3])->kanv_name, (&pnv[3])->kanv_val,
129 - sizeof ((&pnv[3])->kanv_val)))
130 - (void) strcpy((&pnv[3])->kanv_val, "9600,8,n,1,-");
131 -
132 143 *nprops = KCTL_PROPNV_NENT;
133 144 return (pnv);
134 145 }
135 146
136 147 static void
137 148 kctl_pcache_destroy(kmdb_auxv_nv_t *pnv)
138 149 {
139 150 kobj_free(pnv, sizeof (kmdb_auxv_nv_t) * KCTL_PROPNV_NENT);
140 151 }
141 152
142 153 void
143 154 kctl_auxv_init_isadep(kmdb_auxv_t *kav, void *romp)
144 155 {
145 156 kav->kav_pcache = kctl_pcache_create(&kav->kav_nprops);
146 157 kav->kav_romp = romp;
147 158 }
148 159
149 160 void
150 161 kctl_auxv_fini_isadep(kmdb_auxv_t *kav)
151 162 {
152 163 if (kav->kav_pcache != NULL)
153 164 kctl_pcache_destroy(kav->kav_pcache);
154 165 }
155 166
156 167 int
157 168 kctl_preactivate_isadep(void)
158 169 {
159 170 return (0);
160 171 }
161 172
162 173 /*ARGSUSED*/
163 174 void
164 175 kctl_activate_isadep(kdi_debugvec_t *dvec)
165 176 {
166 177 dvec->dv_kctl_vmready = hat_kdi_init;
167 178
168 179 if (!kctl.kctl_boot_loaded)
169 180 hat_kdi_init();
170 181 }
171 182
172 183 void
173 184 kctl_depreactivate_isadep(void)
174 185 {
175 186 }
176 187
177 188 /*
178 189 * Many common kernel functions assume that %gs can be deferenced, and
179 190 * fail horribly if it cannot. Ask the kernel to set up a temporary
180 191 * mapping to a fake cpu_t so that we can call such functions during
181 192 * initialization.
182 193 */
183 194 void *
184 195 kctl_boot_tmpinit(void)
185 196 {
186 197 return (boot_kdi_tmpinit());
187 198 }
188 199
189 200 void
190 201 kctl_boot_tmpfini(void *old)
191 202 {
192 203 boot_kdi_tmpfini(old);
193 204 }
|
↓ open down ↓ |
52 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX