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 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/ksynch.h>
28 #include <sys/cmn_err.h>
29 #include <sys/errno.h>
30 #include <sys/kmem.h>
31 #include <sys/ddi.h>
32
33 #include <sys/nsc_thread.h>
34 #include "sd_bcache.h"
35 #include "sd_ft.h"
36 #include "sd_misc.h"
37 #include "sd_pcu.h"
38 #include "sd_io.h"
39 #include "sd_bio.h"
40 #include "sd_trace.h"
41 #include "sd_tdaemon.h"
42 #include <sys/nsctl/nsctl.h>
43
44 #include <sys/unistat/spcs_s.h>
45 #include <sys/unistat/spcs_s_k.h>
46 #include <sys/unistat/spcs_errors.h>
47 #include <sys/nsctl/safestore.h>
48
49 extern int sdbc_use_dmchain;
50
51 int _sd_cblock_shift = 0;
52
53 int _SD_SELF_HOST = _SD_NO_HOST;
54 int _SD_MIRROR_HOST = _SD_NO_HOST;
55 int _SD_NUM_REM;
56 int _sd_nodes_configured;
57 int _sdbc_gateway_wblocks;
58
59 int _SD_NETS = 0;
60
61 /*
62 * Normally we unregister memory at deconfig time. By setting this non-zero
63 * it will be delayed until unload time.
64 */
65 int _sdbc_memtype_deconfigure_delayed = 0;
66
67 nsc_mem_t *sdbc_iobuf_mem, *sdbc_hash_mem;
68 nsc_mem_t *sdbc_local_mem, *sdbc_stats_mem, *sdbc_cache_mem;
69 nsc_mem_t *sdbc_info_mem;
70
71 _sd_cache_param_t _sd_cache_config;
72
73 kmutex_t _sdbc_config_lock;
74 volatile int _sd_cache_dem_cnt;
75
76 #if !defined(m88k) || defined(lint)
77 volatile int _sd_cache_initialized;
78 #endif
79
80 static blind_t sdbc_power;
81
82 static
83 nsc_def_t _sdbc_power_def[] = {
84 { "Power_Lost", (uintptr_t)_sdbc_power_lost, 0 },
85 { "Power_OK", (uintptr_t)_sdbc_power_ok, 0 },
86 { "Power_Down", (uintptr_t)_sdbc_power_down, 0 },
87 { NULL, (uintptr_t)NULL, 0 }
88 };
89
90 /*
91 * Forward declare all statics that are used before defined to enforce
92 * parameter checking
93 * Some (if not all) of these could be removed if the code were reordered
94 */
95
96 int _sd_fill_pattern(caddr_t addr, uint_t pat, uint_t size);
97 static void _sdbc_nodeid_deconfigure(void);
98 static void _sdbc_nodeid_configure(void);
99 static void _sdbc_thread_deconfigure(void);
100 static int _sdbc_thread_configure(void);
101 void sst_deinit();
102
103 ss_common_config_t safestore_config;
104 safestore_ops_t *sdbc_safestore;
105
106 /*
107 * _sdbc_memtype_configure - register with the sd layer the types of memory
108 * we want to use. If any of the critical memory types can't be registered
109 * we return non-zero otherwise 0.
110 */
111 static int
112 _sdbc_memtype_configure(void)
113 {
114
115 if ((sdbc_info_mem = nsc_register_mem("sdbc:info",
116 NSC_MEM_GLOBAL, KM_NOSLEEP)) == NULL) {
117 return (EINVAL);
118 }
119
120 sdbc_local_mem = nsc_register_mem("sdbc:local", NSC_MEM_LOCAL, 0);
121 sdbc_stats_mem = nsc_register_mem("sdbc:stats", NSC_MEM_LOCAL, 0);
122 sdbc_iobuf_mem = nsc_register_mem("sdbc:iobuf", NSC_MEM_LOCAL, 0);
123
124 sdbc_cache_mem = nsc_register_mem("sdbc:cache", NSC_MEM_LOCAL, 0);
125
126 sdbc_hash_mem = nsc_register_mem("sdbc:hash", NSC_MEM_LOCAL, 0);
127
128 return (0);
129 }
130
131 /*
132 * _sdbc_memtype_deconfigure - undo the effects of _sdbc_memtype_configure.
133 */
134 void
135 _sdbc_memtype_deconfigure(void)
136 {
137
138 if (sdbc_hash_mem)
139 nsc_unregister_mem(sdbc_hash_mem);
140 if (sdbc_iobuf_mem)
141 nsc_unregister_mem(sdbc_iobuf_mem);
142 if (sdbc_cache_mem)
143 nsc_unregister_mem(sdbc_cache_mem);
144 if (sdbc_stats_mem)
145 nsc_unregister_mem(sdbc_stats_mem);
146 if (sdbc_local_mem)
147 nsc_unregister_mem(sdbc_local_mem);
148 if (sdbc_info_mem)
149 nsc_unregister_mem(sdbc_info_mem);
150
151 sdbc_info_mem = NULL;
152 sdbc_local_mem = sdbc_stats_mem = sdbc_cache_mem = NULL;
153 sdbc_iobuf_mem = sdbc_hash_mem = NULL;
154
155 }
156
157
158 /*
159 * figure out what kind of safe storage we need
160 */
161 uint_t
162 sdbc_determine_safestore()
163 {
164 return (SS_M_RAM | SS_T_NONE);
165 }
166
167 static void
168 sd_setup_ssconfig()
169 {
170 safestore_config.ssc_client_psize = BLK_SIZE(1);
171
172 if (_sd_cache_config.write_cache)
173 safestore_config.ssc_wsize =
174 _sd_cache_config.write_cache * MEGABYTE;
175 else
176 safestore_config.ssc_wsize =
177 (_sd_cache_config.cache_mem[_SD_NO_NET] * MEGABYTE)/2;
178 safestore_config.ssc_maxfiles = sdbc_max_devs;
179 safestore_config.ssc_pattern = _sd_cache_config.fill_pattern;
180 safestore_config.ssc_flag = _sd_cache_config.gen_pattern ?
181 SS_GENPATTERN : 0;
182 }
183
184 /*
185 * _sdbc_configure - process the ioctl that describes the configuration
186 * for the cache. This is the main driver routine for cache configuration
187 * Return 0 on success, otherwise nonzero.
188 *
189 */
190 int
191 _sdbc_configure(_sd_cache_param_t *uptr,
192 _sdbc_config_t *mgmt, spcs_s_info_t spcs_kstatus)
193 {
194 int cache_bytes;
195 nsc_io_t *io;
196 char itmp[16];
197 char itmp2[16];
198 int i;
199 uint_t ss_type;
200 int rc;
201
202 ASSERT(MUTEX_HELD(&_sdbc_config_lock));
203
204 _sd_print(1, "sdbc(_sdbc_configure) _SD_MAGIC 0x%x\n", _SD_MAGIC);
205
206 _sd_ioset = 0;
207 if (_sd_cache_initialized) {
208 spcs_s_add(spcs_kstatus, SDBC_EALREADY);
209 rc = EALREADY;
210 goto out;
211 }
212
213 ASSERT((uptr != NULL) || (mgmt != NULL));
214
215 if (uptr) {
216 if (copyin(uptr, &_sd_cache_config,
217 sizeof (_sd_cache_param_t))) {
218 rc = EFAULT;
219 goto out;
220 }
221 } else {
222 bzero(&_sd_cache_config, sizeof (_sd_cache_config));
223
224 /* copy in mgmt config info */
225
226 _sd_cache_config.magic = mgmt->magic;
227 _sd_cache_config.threads = mgmt->threads;
228
229 for (i = 0; i < CACHE_MEM_PAD; i++) {
230 _sd_cache_config.cache_mem[i] = mgmt->cache_mem[i];
231 }
232
233 /* fake the rest as a single node config */
234
235 _sd_cache_config.nodes_conf[0] = nsc_node_id();
236 _sd_cache_config.num_nodes = 1;
237 }
238
239 /*
240 * Check that the requested cache size doesn't break the code.
241 * This test can be refined once the cache size is stored in variables
242 * larger than an int.
243 */
244 for (i = 0; i < MAX_CACHE_NET; i++) {
245 if (_sd_cache_config.cache_mem[i] < 0) {
246 cmn_err(CE_WARN, "!_sdbc_configure: "
247 "negative cache size (%d) for net %d",
248 _sd_cache_config.cache_mem[i], i);
249 spcs_s_add(spcs_kstatus, SDBC_ENONETMEM);
250 rc = SDBC_ENONETMEM;
251 goto out;
252 }
253 if (_sd_cache_config.cache_mem[i] > MAX_CACHE_SIZE) {
254 _sd_cache_config.cache_mem[i] = MAX_CACHE_SIZE;
255 cmn_err(CE_WARN, "!_sdbc_configure: "
256 "cache size limited to %d megabytes for net %d",
257 MAX_CACHE_SIZE, i);
258 }
259 }
260
261 if (_sd_cache_config.blk_size == 0)
262 _sd_cache_config.blk_size = 8192;
263
264 if (_sd_cache_config.procs == 0)
265 _sd_cache_config.procs = 16;
266
267 #if !defined(_SD_8K_BLKSIZE)
268 if (_sd_cache_config.blk_size != 4096) {
269 #else
270 if (_sd_cache_config.blk_size != 8192) {
271 #endif
272 (void) spcs_s_inttostring(_sd_cache_config.blk_size, itmp,
273 sizeof (itmp), 0);
274 spcs_s_add(spcs_kstatus, SDBC_ESIZE, itmp);
275 rc = SDBC_EENABLEFAIL;
276 goto out;
277 }
278 if (((_sd_cblock_shift =
279 get_high_bit(_sd_cache_config.blk_size)) == -1) ||
280 (_sd_cache_config.blk_size != (1 << _sd_cblock_shift))) {
281 (void) spcs_s_inttostring(_sd_cache_config.blk_size, itmp,
282 sizeof (itmp), 0);
283 spcs_s_add(spcs_kstatus, SDBC_ESIZE, itmp);
284 rc = SDBC_EENABLEFAIL;
285 goto out;
286 }
287
288 if (_sd_cache_config.magic != _SD_MAGIC) {
289 rc = SDBC_EMAGIC;
290 goto out;
291 }
292
293 sdbc_use_dmchain = (_sd_cache_config.reserved1 & CFG_USE_DMCHAIN);
294 sdbc_static_cache = (_sd_cache_config.reserved1 & CFG_STATIC_CACHE);
295
296 _sdbc_nodeid_configure();
297
298 if (_SD_SELF_HOST > nsc_max_nodeid ||
299 _SD_MIRROR_HOST > nsc_max_nodeid) {
300 (void) spcs_s_inttostring((_SD_SELF_HOST > nsc_max_nodeid ?
301 _SD_SELF_HOST : _SD_MIRROR_HOST), itmp, sizeof (itmp), 0);
302 (void) spcs_s_inttostring(
303 nsc_max_nodeid, itmp2, sizeof (itmp2), 0);
304 spcs_s_add(spcs_kstatus, SDBC_EINVHOSTID, itmp, itmp2);
305 rc = SDBC_EENABLEFAIL;
306 goto out;
307 }
308
309
310 if (_SD_SELF_HOST == _SD_MIRROR_HOST) {
311 (void) spcs_s_inttostring(
312 _SD_SELF_HOST, itmp, sizeof (itmp), 0);
313 (void) spcs_s_inttostring(
314 _SD_MIRROR_HOST, itmp2, sizeof (itmp2), 0);
315 spcs_s_add(spcs_kstatus, SDBC_ENOTSAME, itmp, itmp2);
316 rc = SDBC_EENABLEFAIL;
317 goto out;
318 }
319
320 /* initialize the safestore modules */
321 sst_init();
322
323 /* figure out which kind of safestore we need to use */
324 ss_type = sdbc_determine_safestore();
325
326 tryss:
327 /* open and configure the safestore module */
328 if ((sdbc_safestore = sst_open(ss_type, 0)) == NULL) {
329 cmn_err(CE_WARN, "!cannot open safestore module for type %x",
330 ss_type);
331 rc = SDBC_EENABLEFAIL;
332 goto out;
333 } else {
334 sd_setup_ssconfig();
335 if (SSOP_CONFIGURE(sdbc_safestore, &safestore_config,
336 spcs_kstatus)) {
337 cmn_err(CE_WARN,
338 "!cannot configure safestore module for type %x",
339 ss_type);
340 (void) sst_close(sdbc_safestore);
341
342 /* try ram if possible, otherwise return */
343 if ((ss_type & (SS_M_RAM | SS_T_NONE)) ==
344 (SS_M_RAM | SS_T_NONE)) {
345 rc = SDBC_EENABLEFAIL;
346 goto out;
347 }
348
349 ss_type = (SS_M_RAM | SS_T_NONE);
350 goto tryss;
351 }
352 }
353
354 if (SAFESTORE_LOCAL(sdbc_safestore))
355 _SD_MIRROR_HOST = _SD_NO_HOST;
356
357 ASSERT(safestore_config.ssc_ss_psize <= UINT16_MAX); /* LINTED */
358 _sd_net_config.sn_psize = safestore_config.ssc_ss_psize;
359
360
361 _sd_net_config.sn_csize =
362 _sd_cache_config.cache_mem[_SD_NO_NET] * MEGABYTE;
363 _sd_net_config.sn_cpages =
364 _sd_net_config.sn_csize / BLK_SIZE(1);
365
366 _sd_net_config.sn_configured = 1;
367 cache_bytes = _sd_net_config.sn_cpages * BLK_SIZE(1);
368
369 if (_sdbc_memtype_configure()) {
370 rc = EINVAL;
371 goto out;
372 }
373
374 if ((rc = _sdbc_iobuf_configure(_sd_cache_config.iobuf))) {
375 if (rc == -1) {
376 rc = SDBC_ENOIOBMEM;
377 goto out;
378 }
379 if (rc == -2) {
380 rc = SDBC_ENOIOBCB;
381 goto out;
382 }
383
384 }
385
386 if (_sdbc_handles_configure()) {
387 rc = SDBC_ENOHANDLEMEM;
388 goto out;
389 }
390
391 _sd_cache_dem_cnt = 0;
392
393
394 /*
395 * nvmem support:
396 * if the cache did not shutdown properly we mark it as dirty.
397 * this must be done before _sdbc_cache_configure() so it can
398 * refresh sd_info_mem and sd_file_mem from nvmem if necsssary,
399 * and before _sdbc_ft_configure() so the ft thread will do a recovery.
400 *
401 */
402 if (SAFESTORE_RECOVERY(sdbc_safestore)) {
403 _sdbc_set_warm_start();
404 _sdbc_ft_hold_io = 1;
405 cmn_err(CE_WARN,
406 "!sdbc(_sdbc_configure) cache marked dirty after"
407 " incomplete shutdown");
408 }
409
410 if ((rc = _sdbc_cache_configure(cache_bytes / BLK_SIZE(1),
411 spcs_kstatus))) {
412 goto out;
413 }
414
415
416 /* ST_ALERT trace buffer */
417 if (_sdbc_tr_configure(-1 /* SDT_INV_CD */) != 0) {
418 rc = EINVAL;
419 goto out;
420 }
421
422 if (_sdbc_thread_configure()) {
423 rc = SDBC_EFLUSHTHRD;
424 goto out;
425 }
426
427 if (_sdbc_flush_configure()) {
428 rc = EINVAL;
429 goto out;
430 }
431
432 if (rc = _sdbc_dealloc_configure_dm()) {
433 goto out;
434 }
435
436 if (_sd_cache_config.test_demons)
437 if (_sdbc_tdaemon_configure(_sd_cache_config.test_demons)) {
438 rc = EINVAL;
439 goto out;
440 }
441
442
443 _sd_cache_initialized = 1;
444
445 sdbc_power = nsc_register_power("sdbc", _sdbc_power_def);
446
447 if (_sdbc_ft_configure() != 0) {
448 rc = EINVAL;
449 goto out;
450 }
451
452 /*
453 * try to control the race between the ft thread
454 * and threads that will open the devices that the ft thread
455 * may be recovering. this synchronizing with the ft thread
456 * prevents sd_cadmin from returning until ft has opened
457 * the recovery devices, so if other apps wait for sd_cadmin
458 * to complete the race is prevented.
459 */
460 mutex_enter(&_sdbc_ft_hold_io_lk);
461 while (_sdbc_ft_hold_io) {
462 cv_wait(&_sdbc_ft_hold_io_cv, &_sdbc_ft_hold_io_lk);
463 }
464
465 io = nsc_register_io("sdbc", NSC_SDBC_ID|NSC_FILTER,
466 _sd_sdbc_def);
467
468 if (io) sdbc_io = io;
469
470 mutex_exit(&_sdbc_ft_hold_io_lk);
471
472 #ifdef DEBUG
473 cmn_err(CE_NOTE, "!sd_config: Cache has been configured");
474 #endif
475
476 rc = 0;
477
478 out:
479 return (rc);
480 }
481
482 /*
483 * _sdbc_deconfigure - Put the cache back to the unconfigured state. Release
484 * any memory we allocated as part of the configuration process (but not the
485 * load/init process). Put globals back to unconfigured state and shut down
486 * any processes/threads we have running.
487 *
488 * Since the cache has loaded we know that global lock/sv's are present and
489 * we can use them to produce an orderly deconfiguration.
490 *
491 * NOTE: this routine and its callee should always be capable of reversing
492 * the effects of _sdbc_configure no matter what partially configured
493 * state might be present.
494 *
495 */
496 int
497 _sdbc_deconfigure(spcs_s_info_t spcs_kstatus)
498 {
499 int i;
500 _sd_cd_info_t *cdi;
501 int rc;
502 int pinneddata = 0;
503 uint_t saved_hint;
504
505 ASSERT(MUTEX_HELD(&_sdbc_config_lock));
506
507 #ifdef DEBUG
508 cmn_err(CE_NOTE, "!SD cache being deconfigured.");
509 #endif
510
511 /* check if there is pinned data and our mirror is down */
512 if (_sd_cache_files && _sd_is_mirror_down()) {
513 for (i = 0; i < sdbc_max_devs; i++) {
514 cdi = &(_sd_cache_files[i]);
515 if (cdi->cd_info == NULL)
516 continue;
517 /*
518 * if (!(cdi->cd_info->sh_failed))
519 * continue;
520 */
521 if (!(_SD_CD_ALL_WRITES(i)))
522 continue;
523 spcs_s_add(spcs_kstatus, SDBC_EPINNED,
524 cdi->cd_info->sh_filename);
525 rc = SDBC_EDISABLEFAIL;
526 goto out;
527 }
528 }
529
530 /* remember hint setting for restoration in case shutdown fails */
531 (void) _sd_get_node_hint(&saved_hint);
532
533 (void) _sd_set_node_hint(NSC_FORCED_WRTHRU);
534
535
536 /* TODO - there is a possible race between deconfig and power hits... */
537
538 if (sdbc_power)
539 (void) nsc_unregister_power(sdbc_power);
540
541
542 if (sdbc_io) {
543 rc = nsc_unregister_io(sdbc_io, NSC_PCATCH);
544 if (rc == 0)
545 sdbc_io = NULL;
546 else {
547 if (rc == EUSERS)
548 spcs_s_add(spcs_kstatus, SDBC_EABUFS);
549
550 spcs_s_add(spcs_kstatus, SDBC_EUNREG);
551
552 /* Re-register-power if it was register before. */
553 if (sdbc_power) {
554 sdbc_power = nsc_register_power("sdbc",
555 _sdbc_power_def);
556 }
557
558 /* Remove NSC_FORCED_WRTHRU if we set it */
559 (void) _sd_clear_node_hint(
560 (~saved_hint) & _SD_HINT_MASK);
561
562 rc = SDBC_EDISABLEFAIL;
563 goto out;
564 }
565 }
566
567 sdbc_power = NULL;
568
569 #if defined(_SD_FAULT_RES)
570 _sd_remote_disable(0); /* notify mirror to forced_wrthru */
571 #endif
572 /*
573 * close devices, deconfigure processes, wait for exits
574 */
575 _sdbc_tdaemon_deconfigure();
576
577 if (_sd_cache_files) {
578 for (i = 0; i < sdbc_max_devs; i++) {
579 if (FILE_OPENED(i) && ((rc = _sd_close(i)) > 0)) {
580 cmn_err(CE_WARN, "!sdbc(_sd_deconfigure)"
581 " %d not closed (%d)\n", i, rc);
582 }
583 }
584 }
585
586 /*
587 * look for pinned data
588 * TODO sort this out for multinode systems.
589 * cannot shutdown with pinned data on multinode.
590 * the state of pinned data should be determined in
591 * the close operation.
592 */
593 if (_sd_cache_files) {
594 for (i = 0; i < sdbc_max_devs; i++) {
595 cdi = &(_sd_cache_files[i]);
596 if (cdi->cd_info == NULL)
597 continue;
598 /*
599 * if (!(cdi->cd_info->sh_failed))
600 * continue;
601 */
602 if (!(_SD_CD_ALL_WRITES(i)))
603 continue;
604 cmn_err(CE_WARN,
605 "!sdbc(_sd_deconfigure) Pinned Data on cd %d(%s)",
606 i, cdi->cd_info->sh_filename);
607 pinneddata++;
608 }
609 }
610
611 _sd_cache_initialized = 0;
612
613 _sdbc_ft_deconfigure();
614
615 _sdbc_flush_deconfigure();
616 _sdbc_thread_deconfigure();
617
618 mutex_enter(&_sd_cache_lock);
619
620 while (_sd_cache_dem_cnt > 0) {
621 mutex_exit(&_sd_cache_lock);
622 (void) nsc_delay_sig(HZ/2);
623 mutex_enter(&_sd_cache_lock);
624 }
625 mutex_exit(&_sd_cache_lock);
626
627 /*
628 * remove all dynamically allocated cache data memory
629 * there should be no i/o at this point
630 */
631 _sdbc_dealloc_deconfigure_dm();
632 /*
633 * At this point no thread of control should be active in the cache
634 * but us (unless they are blocked on the config lock).
635 */
636
637
638 #if defined(_SD_FAULT_RES)
639 _sd_remote_disable(1); /* notify mirror I/O shutdown complete */
640 #endif
641
642 #define KEEP_TRACES 0 /* set to 1 keep traces after deconfig */
643 #if !KEEP_TRACES
644 /*
645 * This needs to happen before we unregister the memory.
646 */
647 _sdbc_tr_deconfigure();
648 #endif
649
650
651 /* delete/free hash table, cache blocks, etc */
652 _sdbc_cache_deconfigure();
653
654 _sdbc_handles_deconfigure();
655
656 _sdbc_iobuf_deconfigure();
657
658 #if !KEEP_TRACES
659 if (!_sdbc_memtype_deconfigure_delayed)
660 _sdbc_memtype_deconfigure();
661 #else
662 _sdbc_memtype_deconfigure_delayed = 1;
663 #endif
664
665 /*
666 * Call ss deconfig(),
667 * check for valid pointer in case _sdbc_configure()
668 * failed before safestrore system was initialized.
669 */
670 if (sdbc_safestore)
671 SSOP_DECONFIGURE(sdbc_safestore, pinneddata);
672
673 /* tear down safestore system */
674 sst_deinit();
675
676 _sdbc_nodeid_deconfigure();
677
678 bzero(&_sd_cache_config, sizeof (_sd_cache_param_t));
679
680 _SD_SELF_HOST = _SD_MIRROR_HOST = _SD_NO_HOST;
681 _SD_NETS = 0;
682 _sd_cblock_shift = 0;
683 _sd_node_hint = 0;
684
685 #ifdef DEBUG
686 cmn_err(CE_NOTE, "!SD cache deconfigured.");
687 #endif
688
689 rc = 0;
690
691 out:
692 return (rc);
693 }
694
695
696
697 static int
698 find_low_bit(int mask, int start)
699 {
700 for (; start < 32; start++)
701 if ((mask & (1 << start)))
702 break;
703
704 return (start);
705 }
706
707 int
708 get_high_bit(int size)
709 {
710 int lowbit;
711 int newblk = size;
712 int highbit = -1;
713 int next_high = 0;
714
715 while ((lowbit = find_low_bit(newblk, 0)) != 32) {
716 if (highbit >= 0) next_high = 1;
717 highbit = lowbit;
718 newblk &= ~(1 << highbit);
719 }
720
721 if (highbit <= 0) {
722 cmn_err(CE_WARN,
723 "!sdbc(get_high_bit) invalid block size %x\n", size);
724 return (-1);
725 }
726
727 if (next_high) highbit++;
728
729 return (highbit);
730 }
731
732
733 int
734 _sd_fill_pattern(caddr_t addr, uint_t pat, uint_t size)
735 {
736 caddr_t fmt_page;
737 int i, page_size;
738
739 page_size = (int)ptob(1);
740
741 if ((fmt_page = (caddr_t)nsc_kmem_alloc(ptob(1),
742 KM_SLEEP, sdbc_local_mem)) == NULL) {
743 cmn_err(CE_WARN, "!sdbc(_sd_fill pattern) no more memory");
744 return (-1);
745 }
746 for (i = 0; i < page_size; i += 4)
747 *(int *)(void *)(fmt_page + i) = pat;
748
749 while (size >= page_size) {
750 bcopy(fmt_page, addr, ptob(1));
751 addr += page_size;
752 size -= page_size;
753 }
754 nsc_kmem_free(fmt_page, page_size);
755 return (0);
756 }
757
758
759 /*
760 * _sdbc_nodeid_deconfigure - merely a place holder until
761 * such time as there is something to be undone w.r.t.
762 * _sdbc_nodeid_configure.
763 *
764 */
765 static void
766 _sdbc_nodeid_deconfigure(void)
767 {
768 /* My but we're quick */
769 }
770
771 /*
772 * _sdbc_nodeid_configure - configure the nodeid's we need to connect
773 * to any other nodes in the network.
774 *
775 */
776 void
777 _sdbc_nodeid_configure(void)
778 {
779
780 if (_sd_cache_config.num_nodes == 0) {
781 _sd_nodes_configured = 1;
782 } else {
783 _sd_nodes_configured = _sd_cache_config.num_nodes;
784 }
785
786 _SD_SELF_HOST = nsc_node_id();
787 _SD_MIRROR_HOST = _sd_cache_config.mirror_host;
788 }
789
790 #define STACK_SIZE (32*1024)
791 #define num_spin 0
792 nstset_t *_sd_ioset;
793
794 /*
795 * _sdbc_thread_deconfigure - cache is being deconfigure, stop any
796 * thread activity.
797 *
798 */
799 static void
800 _sdbc_thread_deconfigure(void)
801 {
802 ASSERT(MUTEX_HELD(&_sdbc_config_lock));
803 nst_destroy(_sd_ioset);
804 _sd_ioset = NULL;
805 }
806
807 /*
808 * _sdbc_thread_configure - cache is being configured, initialize the
809 * threads we need for flushing dirty cds.
810 *
811 */
812 static int
813 _sdbc_thread_configure(void)
814 {
815 ASSERT(MUTEX_HELD(&_sdbc_config_lock));
816
817 if (!_sd_ioset)
818 _sd_ioset = nst_init("sd_thr", _sd_cache_config.threads);
819
820 if (!_sd_ioset)
821 return (EINVAL);
822
823 return (0);
824 }
825
826 int
827 _sdbc_get_config(_sdbc_config_t *config_info)
828 {
829 int i;
830
831 config_info->enabled = _sd_cache_initialized;
832 config_info->magic = _SD_MAGIC;
833 for (i = 0; i < CACHE_MEM_PAD; i++) {
834 config_info->cache_mem[i] = _sd_cache_config.cache_mem[i];
835 }
836 config_info->threads = _sd_cache_config.threads;
837
838 return (0);
839 }