Print this page
3373 gcc >= 4.5 concerns about offsetof()
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/mdb/common/modules/ii/ii.c
+++ new/usr/src/cmd/mdb/common/modules/ii/ii.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 *
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 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 25
26 26 #include <sys/types.h>
27 27 #include <sys/mdb_modapi.h>
28 28
|
↓ open down ↓ |
28 lines elided |
↑ open up ↑ |
29 29 #include <sys/nsctl/nsctl.h>
30 30 #include <sys/unistat/spcs_s.h>
31 31 #include <sys/unistat/spcs_s_k.h>
32 32
33 33
34 34 #include <sys/nsctl/dsw.h>
35 35 #include <sys/nsctl/dsw_dev.h>
36 36
37 37 #include <sys/nsctl/nsvers.h>
38 38
39 -#define offsetof(s, m) ((size_t)(&((s *)0)->m))
39 +#if defined(__GNUC__)
40 +#define offsetof(s, m) __builtin_offsetof(s, m)
41 +#else
42 +#define offsetof(s, m) ((size_t)(&(((s *)0)->m)))
43 +#endif
40 44
41 45
42 46 const mdb_bitmask_t bi_flags_bits[] = {
43 47 { "DSW_GOLDEN", DSW_GOLDEN, DSW_GOLDEN },
44 48 { "DSW_COPYINGP", DSW_COPYINGP, DSW_COPYINGP },
45 49 { "DSW_COPYINGM", DSW_COPYINGM, DSW_COPYINGM },
46 50 { "DSW_COPYINGS", DSW_COPYINGS, DSW_COPYINGS },
47 51 { "DSW_COPYINGX", DSW_COPYINGX, DSW_COPYINGX },
48 52 { "DSW_BMPOFFLINE", DSW_BMPOFFLINE, DSW_BMPOFFLINE },
49 53 { "DSW_SHDOFFLINE", DSW_SHDOFFLINE, DSW_SHDOFFLINE },
50 54 { "DSW_MSTOFFLINE", DSW_MSTOFFLINE, DSW_MSTOFFLINE },
51 55 { "DSW_OVROFFLINE", DSW_OVROFFLINE, DSW_OVROFFLINE },
52 56 { "DSW_TREEMAP", DSW_TREEMAP, DSW_TREEMAP },
53 57 { "DSW_OVERFLOW", DSW_OVERFLOW, DSW_OVERFLOW },
54 58 { "DSW_SHDEXPORT", DSW_SHDEXPORT, DSW_SHDEXPORT },
55 59 { "DSW_SHDIMPORT", DSW_SHDIMPORT, DSW_SHDIMPORT },
56 60 { "DSW_VOVERFLOW", DSW_VOVERFLOW, DSW_VOVERFLOW },
57 61 { "DSW_HANGING", DSW_HANGING, DSW_HANGING },
58 62 { "DSW_CFGOFFLINE", DSW_CFGOFFLINE, DSW_CFGOFFLINE },
59 63 { "DSW_OVRHDRDRTY", DSW_OVRHDRDRTY, DSW_OVRHDRDRTY },
60 64 { "DSW_RESIZED", DSW_RESIZED, DSW_RESIZED },
61 65 { "DSW_FRECLAIM", DSW_FRECLAIM, DSW_FRECLAIM },
62 66 { NULL, 0, 0 }
63 67 };
64 68
65 69 const mdb_bitmask_t bi_state_bits[] = {
66 70 { "DSW_IOCTL", DSW_IOCTL, DSW_IOCTL },
67 71 { "DSW_CLOSING", DSW_CLOSING, DSW_CLOSING },
68 72 { "DSW_MSTTARGET", DSW_MSTTARGET, DSW_MSTTARGET },
69 73 { "DSW_MULTIMST", DSW_MULTIMST, DSW_MULTIMST },
70 74 { NULL, 0, 0 }
71 75 };
72 76 static uintptr_t nextaddr;
73 77 /*
74 78 * Display a ii_fd_t
75 79 * Requires an address.
76 80 */
77 81 /*ARGSUSED*/
78 82 static int
79 83 ii_fd(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
80 84 {
81 85 ii_fd_t fd;
82 86
83 87 if (!(flags & DCMD_ADDRSPEC))
84 88 return (DCMD_USAGE);
85 89
86 90 if (mdb_vread(&fd, sizeof (fd), addr) != sizeof (fd)) {
87 91 mdb_warn("failed to read ii_fd_t at 0x%p", addr);
88 92 return (DCMD_ERR);
89 93 }
90 94
91 95 mdb_inc_indent(4);
92 96 mdb_printf("ii_info: 0x%p ii_bmp: %d ii_shd: %d ii_ovr: %d ii_optr: "
93 97 "0x%p\nii_oflags: 0x%x\n", fd.ii_info, fd.ii_bmp, fd.ii_shd,
94 98 fd.ii_ovr, fd.ii_optr, fd.ii_oflags);
95 99 mdb_dec_indent(4);
96 100
97 101 return (DCMD_OK);
98 102 }
99 103
100 104 /*
101 105 * displays a ii_info_dev structure.
102 106 */
103 107 /*ARGSUSED*/
104 108 static int
105 109 ii_info_dev(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
106 110 {
107 111 _ii_info_dev_t ipdev;
108 112
109 113 if (!(flags & DCMD_ADDRSPEC))
110 114 return (DCMD_USAGE);
111 115
112 116 if (mdb_vread(&ipdev, sizeof (ipdev), addr) != sizeof (ipdev)) {
113 117 mdb_warn("failed to read ii_info_dev_t at 0x%p", addr);
114 118 return (DCMD_ERR);
115 119 }
116 120
117 121 mdb_inc_indent(4);
118 122 mdb_printf("bi_fd: 0x%p bi_iodev: 0x%p bi_tok: 0x%p\n",
119 123 ipdev.bi_fd, ipdev.bi_iodev, ipdev.bi_tok);
120 124 mdb_printf("bi_ref: %d bi_rsrv: %d bi_orsrv: %d\n",
121 125 ipdev.bi_ref, ipdev.bi_rsrv, ipdev.bi_orsrv);
122 126
123 127 /*
124 128 * use nsc_fd to dump the fd details.... if present.
125 129 */
126 130 if (ipdev.bi_fd) {
127 131 mdb_printf("nsc_fd structure:\n");
128 132 mdb_inc_indent(4);
129 133 mdb_call_dcmd("nsc_fd", (uintptr_t)(ipdev.bi_fd),
130 134 flags, 0, NULL);
131 135 mdb_dec_indent(4);
132 136 }
133 137 mdb_dec_indent(4);
134 138 return (DCMD_OK);
135 139 }
136 140
137 141 /*
138 142 * Displays an _ii_overflow structure
139 143 */
140 144 /*ARGSUSED*/
141 145 static int
142 146 ii_overflow(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
143 147 {
144 148 _ii_overflow_t ii_overflow;
145 149
146 150 nextaddr = 0;
147 151 if (!(flags & DCMD_ADDRSPEC))
148 152 return (DCMD_USAGE);
149 153
150 154 if (mdb_vread(&ii_overflow, sizeof (ii_overflow), addr)
151 155 != sizeof (ii_overflow)) {
152 156 mdb_warn("failed to read ii_overflow_t at 0x%p", addr);
153 157 return (DCMD_ERR);
154 158 }
155 159
156 160 mdb_inc_indent(4);
157 161 mdb_printf("_ii_overflow at 0x%p\n", addr);
158 162 mdb_printf("_ii_doverflow_t\n");
159 163 mdb_inc_indent(4);
160 164 mdb_printf("ii_dvolname: %s\n", ii_overflow.ii_volname);
161 165 mdb_printf("ii_dhmagic: %x\n", ii_overflow.ii_hmagic);
162 166 mdb_printf("ii_dhversion: %x\n", ii_overflow.ii_hversion);
163 167 mdb_printf("ii_ddrefcnt: %x\n", ii_overflow.ii_drefcnt);
164 168 mdb_printf("ii_dflags: %x\n", ii_overflow.ii_flags);
165 169 mdb_printf("ii_dfreehead: %x\n", ii_overflow.ii_freehead);
166 170 mdb_printf("ii_dnchunks: %x\n", ii_overflow.ii_nchunks);
167 171 mdb_printf("ii_dunused: %x\n", ii_overflow.ii_unused);
168 172 mdb_printf("ii_dused: %x\n", ii_overflow.ii_used);
169 173 mdb_printf("ii_urefcnt: %x\n", ii_overflow.ii_urefcnt);
170 174 mdb_dec_indent(4);
171 175
172 176 mdb_printf("ii_mutex: %x\n", ii_overflow.ii_mutex);
173 177 mdb_printf("ii_kstat_mutex: %x\n", ii_overflow.ii_kstat_mutex);
174 178 mdb_printf("ii_crefcnt: %d\n", ii_overflow.ii_crefcnt);
175 179 mdb_printf("ii_detachcnt: %d\n", ii_overflow.ii_detachcnt);
176 180 mdb_printf("ii_next: %x\n", ii_overflow.ii_next);
177 181
178 182 mdb_printf("Overflow volume:\n");
179 183 if (ii_overflow.ii_dev)
180 184 ii_info_dev((uintptr_t)ii_overflow.ii_dev, flags, 0, NULL);
181 185
182 186 mdb_printf(" ii_ioname: %s\n", &ii_overflow.ii_ioname);
183 187 mdb_dec_indent(4);
184 188
185 189 nextaddr = (uintptr_t)ii_overflow.ii_next;
186 190 return (DCMD_OK);
187 191 }
188 192 /*ARGSUSED*/
189 193 static int
190 194 ii_info(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
191 195 {
192 196 _ii_info_t ii_info = {0};
193 197 char string[DSW_NAMELEN];
194 198
195 199 nextaddr = 0;
196 200 if (!(flags & DCMD_ADDRSPEC))
197 201 return (DCMD_USAGE);
198 202
199 203 if (mdb_vread(&ii_info, sizeof (ii_info), addr) != sizeof (ii_info)) {
200 204 mdb_warn("failed to read ii_info_t at 0x%p", addr);
201 205 return (DCMD_ERR);
202 206 }
203 207
204 208 mdb_printf(
205 209 "bi_next: 0x%p\n"
206 210 "bi_head: 0x%p\t"
207 211 "bi_sibling: 0x%p\n"
208 212 "bi_master: 0x%p\t"
209 213 "bi_nextmst: 0x%p\n",
210 214 ii_info.bi_next, ii_info.bi_head, ii_info.bi_sibling,
211 215 ii_info.bi_master, ii_info.bi_nextmst);
212 216
213 217 mdb_printf("bi_mutex: 0x%p\n", ii_info.bi_mutex);
214 218
215 219 /*
216 220 * Print out all the fds by using ii_info_dev
217 221 */
218 222 mdb_printf("Cache master:\n");
219 223 if (ii_info.bi_mstdev)
220 224 ii_info_dev((uintptr_t)ii_info.bi_mstdev, flags, 0, NULL);
221 225
222 226 mdb_printf("Raw master:\n");
223 227 if (ii_info.bi_mstrdev)
224 228 ii_info_dev((uintptr_t)ii_info.bi_mstrdev, flags, 0, NULL);
225 229
226 230 mdb_printf("Cache shadow:\n");
227 231 ii_info_dev((uintptr_t)(addr + offsetof(_ii_info_t, bi_shddev)),
228 232 flags, 0, NULL);
229 233
230 234 mdb_printf("Raw shadow:\n");
231 235 ii_info_dev((uintptr_t)(addr + offsetof(_ii_info_t, bi_shdrdev)),
232 236 flags, 0, NULL);
233 237
234 238 mdb_printf("Bitmap:\n");
235 239 ii_info_dev((uintptr_t)(addr + offsetof(_ii_info_t, bi_bmpdev)),
236 240 flags, 0, NULL);
237 241
238 242 mdb_printf("bi_keyname: %-*s\n", DSW_NAMELEN, ii_info.bi_keyname);
239 243 mdb_printf("bi_bitmap: 0x%p\n", ii_info.bi_bitmap);
240 244
241 245 if ((ii_info.bi_cluster == NULL) ||
242 246 (mdb_vread(&string, sizeof (string), (uintptr_t)ii_info.bi_cluster)
243 247 != sizeof (string)))
244 248 string[0] = 0;
245 249 mdb_printf("bi_cluster: %s\n", string);
246 250
247 251 if ((ii_info.bi_group == NULL) ||
248 252 (mdb_vread(&string, sizeof (string), (uintptr_t)ii_info.bi_group)
249 253 != sizeof (string)))
250 254 string[0] = 0;
251 255 mdb_printf("bi_group: %s\n", string);
252 256
253 257 mdb_printf("bi_busy: 0x%p\n", ii_info.bi_busy);
254 258
255 259 mdb_printf("bi_shdfba: %0x\t", ii_info.bi_shdfba);
256 260 mdb_printf("bi_shdbits: %0x\n", ii_info.bi_shdbits);
257 261 mdb_printf("bi_copyfba: %0x\t", ii_info.bi_copyfba);
258 262 mdb_printf("bi_copybits: %0x\n", ii_info.bi_copybits);
259 263
260 264 mdb_printf("bi_size: %0x\n", ii_info.bi_size);
261 265
262 266 mdb_printf("bi_flags: 0x%x <%b>\n",
263 267 ii_info.bi_flags, ii_info.bi_flags, bi_flags_bits);
264 268
265 269 mdb_printf("bi_state: 0x%x <%b>\n",
266 270 ii_info.bi_state, ii_info.bi_state, bi_state_bits);
267 271
268 272 mdb_printf("bi_disabled: %d\n", ii_info.bi_disabled);
269 273 mdb_printf("bi_ioctl: %d\n", ii_info.bi_ioctl);
270 274 mdb_printf("bi_release: %d\t", ii_info.bi_release);
271 275 mdb_printf("bi_rsrvcnt: %d\n", ii_info.bi_rsrvcnt);
272 276
273 277 mdb_printf("bi_copydonecv: %x\t", ii_info.bi_copydonecv);
274 278 mdb_printf("bi_reservecv: %x\n", ii_info.bi_reservecv);
275 279 mdb_printf("bi_releasecv: %x\t", ii_info.bi_releasecv);
276 280 mdb_printf("bi_closingcv: %x\n", ii_info.bi_closingcv);
277 281 mdb_printf("bi_ioctlcv: %x\t", ii_info.bi_ioctlcv);
278 282 mdb_printf("bi_busycv: %x\n", ii_info.bi_busycv);
279 283 mdb_call_dcmd("rwlock", (uintptr_t)(addr +
280 284 offsetof(_ii_info_t, bi_busyrw)), flags, 0, NULL);
281 285 mdb_printf("bi_bitmap_ops: 0x%p\n", ii_info.bi_bitmap_ops);
282 286
283 287 mdb_printf("bi_rsrvmutex: %x\t", ii_info.bi_rsrvmutex);
284 288 mdb_printf("bi_rlsemutex: %x\n", ii_info.bi_rlsemutex);
285 289 mdb_printf("bi_bmpmutex: %x\n", ii_info.bi_bmpmutex);
286 290
287 291 mdb_printf("bi_mstchks: %d\t", ii_info.bi_mstchks);
288 292 mdb_printf("bi_shdchks: %d\n", ii_info.bi_shdchks);
289 293 mdb_printf("bi_shdchkused: %d\t", ii_info.bi_shdchkused);
290 294 mdb_printf("bi_shdfchk: %d\n", ii_info.bi_shdfchk);
291 295
292 296 mdb_printf("bi_overflow\n");
293 297 if (ii_info.bi_overflow)
294 298 ii_overflow((uintptr_t)ii_info.bi_overflow, flags, 0, NULL);
295 299
296 300 mdb_printf("bi_iifd:\n");
297 301 if (ii_info.bi_iifd)
298 302 (void) ii_fd((uintptr_t)ii_info.bi_iifd, flags, 0, NULL);
299 303
300 304 mdb_printf("bi_throttle_unit: %d\t", ii_info.bi_throttle_unit);
301 305 mdb_printf("bi_throttle_delay: %d\n", ii_info.bi_throttle_delay);
302 306
303 307 mdb_printf("bi_linkrw:\n");
304 308 mdb_call_dcmd("rwlock", (uintptr_t)(addr +
305 309 offsetof(_ii_info_t, bi_linkrw)), flags, 0, NULL);
306 310
307 311 mdb_printf("bi_chksmutex: %x\n", ii_info.bi_chksmutex);
308 312 mdb_printf("bi_locked_pid: %x\n", ii_info.bi_locked_pid);
309 313 mdb_printf("bi_kstat: 0x%p\n", ii_info.bi_kstat);
310 314 /* ii_kstat_info_t bi_kstat_io; */
311 315
312 316 nextaddr = (uintptr_t)ii_info.bi_next;
313 317 return (DCMD_OK);
314 318 }
315 319
316 320 /*
317 321 * This should be a walker surely.
318 322 */
319 323 /*ARGSUSED*/
320 324 static int
321 325 ii_info_all(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
322 326 {
323 327 uintptr_t myaddr;
324 328 /*
325 329 * we use the global address.
326 330 */
327 331 if (flags & DCMD_ADDRSPEC)
328 332 return (DCMD_USAGE);
329 333
330 334 if (mdb_readsym(&myaddr, sizeof (myaddr), "_ii_info_top") !=
331 335 sizeof (myaddr)) {
332 336 return (DCMD_ERR);
333 337 }
334 338
335 339 mdb_printf("_ii_info_top contains 0x%lx\n", myaddr);
336 340
337 341 while (myaddr) {
338 342 ii_info(myaddr, DCMD_ADDRSPEC, 0, NULL);
339 343 myaddr = nextaddr;
340 344 }
341 345 return (DCMD_OK);
342 346 }
343 347
344 348 /*
345 349 * Display general ii module information.
346 350 */
347 351
348 352 #define ii_get_print(kvar, str, fmt, val) \
349 353 if (mdb_readvar(&(val), #kvar) == -1) { \
350 354 mdb_dec_indent(4); \
351 355 mdb_warn("unable to read '" #kvar "'"); \
352 356 return (DCMD_ERR); \
353 357 } \
354 358 mdb_printf("%-20s" fmt "\n", str ":", val)
355 359
356 360 /* ARGSUSED */
357 361 static int
358 362 ii(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv)
359 363 {
360 364 int maj, min, mic, baseline, i;
361 365
362 366 if (argc != 0)
363 367 return (DCMD_USAGE);
364 368
365 369 if (mdb_readvar(&maj, "dsw_major_rev") == -1) {
366 370 mdb_warn("unable to read 'dsw_major_rev'");
367 371 return (DCMD_ERR);
368 372 }
369 373
370 374 if (mdb_readvar(&min, "dsw_minor_rev") == -1) {
371 375 mdb_warn("unable to read 'dsw_minor_rev'");
372 376 return (DCMD_ERR);
373 377 }
374 378
375 379 if (mdb_readvar(&mic, "dsw_micro_rev") == -1) {
376 380 mdb_warn("unable to read 'dsw_micro_rev'");
377 381 return (DCMD_ERR);
378 382 }
379 383
380 384 if (mdb_readvar(&baseline, "dsw_baseline_rev") == -1) {
381 385 mdb_warn("unable to read 'dsw_baseline_rev'");
382 386 return (DCMD_ERR);
383 387 }
384 388
385 389 mdb_printf("Point-in-Time Copy module version: kernel %d.%d.%d.%d; "
386 390 "mdb %d.%d.%d.%d\n", maj, min, mic, baseline,
387 391 ISS_VERSION_MAJ, ISS_VERSION_MIN, ISS_VERSION_MIC, ISS_VERSION_NUM);
388 392
389 393 mdb_inc_indent(4);
390 394 ii_get_print(ii_debug, "debug", "%d", i);
391 395 ii_get_print(ii_bitmap, "bitmaps", "%d", i);
392 396 mdb_dec_indent(4);
393 397
394 398 return (DCMD_OK);
395 399 }
396 400
397 401
398 402 /*
399 403 * MDB module linkage information:
400 404 */
401 405
402 406 static const mdb_dcmd_t dcmds[] = {
403 407 { "ii", NULL, "display ii module info", ii },
404 408 { "ii_fd", NULL, "display ii_fd structure", ii_fd },
405 409 { "ii_info", NULL, "display ii_info structure", ii_info },
406 410 { "ii_info_all", NULL, "display all ii_info structures", ii_info_all },
407 411 { "ii_info_dev", NULL, "display ii_info_dev structure", ii_info_dev},
408 412 { "ii_overflow", NULL, "display ii_overflow structure", ii_overflow},
409 413 { NULL }
410 414 };
411 415
412 416
413 417 static const mdb_walker_t walkers[] = {
414 418 { NULL }
415 419 };
416 420
417 421
418 422 static const mdb_modinfo_t modinfo = {
419 423 MDB_API_VERSION, dcmds, walkers
420 424 };
421 425
422 426
423 427 const mdb_modinfo_t *
424 428 _mdb_init(void)
425 429 {
426 430 return (&modinfo);
427 431 }
|
↓ open down ↓ |
378 lines elided |
↑ open up ↑ |
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX