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/kmem.h>
30 #include <sys/stat.h>
31 #include <sys/errno.h>
32
33 #include "../solaris/nsc_thread.h"
34 #ifdef DS_DDICT
35 #include "../contract.h"
36 #endif
37 #include <sys/nsctl/nsctl.h>
38
39 #include <sys/kmem.h>
40 #include <sys/cmn_err.h>
41 #include <sys/ddi.h>
42
43 #include "rdc_io.h"
44 #include "rdc_bitmap.h"
45 #include "rdc_clnt.h"
46 #include "rdc_diskq.h"
47
48 #include <sys/unistat/spcs_s.h>
49 #include <sys/unistat/spcs_s_k.h>
50 #include <sys/unistat/spcs_errors.h>
51
52 #ifndef UINT8_MAX
53 #define UINT8_MAX 255
54 #endif
55
56 #ifndef UINT_MAX
57 #define UINT_MAX 0xffffffff
58 #endif
59
60 /*
61 * RDC bitmap functions.
62 */
63
64 /*
65 * RDC cluster integration notes.
66 *
67 * 1. Configuration
68 *
69 * 1.1. Change 'rdc_bitmap_mode' in /usr/kernel/drv/rdc.conf to '1'.
70 *
71 * 2. Operation
72 *
73 * 2.1. SunCluster ensures that only one physical host has any rdc
74 * controlled device imported at any one time. Hence rdc will
75 * only be active on a single node for any set at a time.
76 *
77 * 2.2. So operation from the kernel perspective looks just like
78 * operation on a single, standalone, node.
79 *
80 */
81
82 struct rdc_bitmap_ops *rdc_bitmap_ops; /* the bitmap ops switch */
83 static int rdc_wrflag; /* write flag for io */
84 int rdc_bitmap_delay = 0;
85 extern nsc_io_t *_rdc_io_hc;
86
87 int rdc_suspend_diskq(rdc_k_info_t *krdc);
88
89 /*
90 * rdc_ns_io
91 * Perform read or write on an underlying ns device
92 *
93 * fd - nsc file descriptor
94 * flag - nsc io direction and characteristics flag
95 * fba_pos - offset from beginning of device in FBAs
96 * io_addr - pointer to data buffer
97 * io_len - length of io in bytes
98 */
99
100 int
101 rdc_ns_io(nsc_fd_t *fd, int flag, nsc_off_t fba_pos, uchar_t *io_addr,
102 nsc_size_t io_len)
103 {
104 nsc_buf_t *tmp;
105 nsc_vec_t *vecp;
106 uchar_t *vaddr;
107 size_t copy_len;
108 int vlen;
109 int rc;
110 nsc_size_t fba_req, fba_len;
111 nsc_size_t maxfbas = 0;
112 nsc_size_t tocopy;
113 unsigned char *toaddr;
114
115 rc = nsc_maxfbas(fd, 0, &maxfbas);
116 if (!RDC_SUCCESS(rc)) {
117 #ifdef DEBUG
118 cmn_err(CE_WARN, "!rdc_ns_io: maxfbas failed (%d)", rc);
119 #endif
120 maxfbas = 256;
121 }
122 toaddr = io_addr;
123 fba_req = FBA_LEN(io_len);
124 loop:
125 tmp = NULL;
126 fba_len = min(fba_req, maxfbas);
127 tocopy = min(io_len, FBA_SIZE(fba_len));
128 ASSERT(tocopy < INT32_MAX);
129
130 rc = nsc_alloc_buf(fd, fba_pos, fba_len, flag, &tmp);
131 if (!RDC_SUCCESS(rc)) {
132 if (tmp) {
133 (void) nsc_free_buf(tmp);
134 }
135 return (EIO);
136 }
137
138 if ((flag & NSC_WRITE) != 0 && (flag & NSC_READ) == 0 &&
139 FBA_OFF(io_len) != 0) {
140 /*
141 * Not overwriting all of the last FBA, so read in the
142 * old contents now before we overwrite it with the new
143 * data.
144 */
145 rc = nsc_read(tmp, fba_pos+FBA_NUM(io_len), 1, 0);
146 if (!RDC_SUCCESS(rc)) {
147 (void) nsc_free_buf(tmp);
148 return (EIO);
149 }
150 }
151
152 vecp = tmp->sb_vec;
153 vlen = vecp->sv_len;
154 vaddr = vecp->sv_addr;
155
156 while (tocopy > 0) {
157 if (vecp->sv_addr == 0 || vecp->sv_len == 0) {
158 #ifdef DEBUG
159 cmn_err(CE_WARN, "!rdc_ns_io: ran off end of handle");
160 #endif
161 break;
162 }
163
164 copy_len = (size_t)min(vlen, (int)tocopy);
165
166 if (flag & NSC_WRITE)
167 bcopy(toaddr, vaddr, copy_len);
168 else
169 bcopy(vaddr, toaddr, copy_len);
170
171 toaddr += copy_len;
172 io_addr += copy_len; /* adjust position in callers buffer */
173 io_len -= copy_len; /* adjust total byte length remaining */
174 tocopy -= copy_len; /* adjust chunk byte length remaining */
175 vaddr += copy_len; /* adjust location in sv_vec_t */
176 vlen -= copy_len; /* adjust length left in sv_vec_t */
177
178 if (vlen <= 0) {
179 vecp++;
180 vaddr = vecp->sv_addr;
181 vlen = vecp->sv_len;
182 }
183 }
184
185 if (flag & NSC_WRITE) {
186 rc = nsc_write(tmp, tmp->sb_pos, tmp->sb_len, 0);
187 if (!RDC_SUCCESS(rc)) {
188 (void) nsc_free_buf(tmp);
189 return (rc);
190 }
191 }
192
193 (void) nsc_free_buf(tmp);
194
195 fba_pos += fba_len;
196 fba_req -= fba_len;
197 if (fba_req > 0)
198 goto loop;
199
200 return (0);
201 }
202
203 /*
204 * Must be called with krdc->bmapmutex held.
205 */
206 static void
207 rdc_fill_header(rdc_u_info_t *urdc, rdc_header_t *header)
208 {
209 rdc_k_info_t *krdc = &rdc_k_info[urdc->index];
210 #ifdef DEBUG
211 ASSERT(MUTEX_HELD(&krdc->bmapmutex));
212 #endif
213
214 header->magic = RDC_HDR_MAGIC;
215 (void) strncpy(header->primary.file, urdc->primary.file, NSC_MAXPATH);
216 (void) strncpy(header->primary.bitmap, urdc->primary.bitmap,
217 NSC_MAXPATH);
218 (void) strncpy(header->secondary.file, urdc->secondary.file,
219 NSC_MAXPATH);
220 (void) strncpy(header->secondary.bitmap, urdc->secondary.bitmap,
221 NSC_MAXPATH);
222 header->flags = urdc->flags | urdc->sync_flags | urdc->bmap_flags;
223 header->autosync = urdc->autosync;
224 header->maxqfbas = urdc->maxqfbas;
225 header->maxqitems = urdc->maxqitems;
226 header->asyncthr = urdc->asyncthr;
227 header->syshostid = urdc->syshostid;
228 header->refcntsize = rdc_refcntsize(krdc);
229 #ifdef DEBUG_REFCNT
230 cmn_err(CE_NOTE, "!sndr: refcntsize %d - %d:%s",
231 (int)rdc_refcntsize(krdc), __LINE__, __FILE__);
232 #endif
233 }
234
235 /*
236 * Must be called with krdc->bmapmutex held.
237 */
238 static int
239 rdc_read_header(rdc_k_info_t *krdc, rdc_header_t *header)
240 {
241 int sts;
242 rdc_u_info_t *urdc;
243 union {
244 rdc_header_t *current;
245 rdc_headerv4_t *v4;
246 } u_hdrp;
247
248 if (krdc == NULL) {
249 return (-1);
250 }
251
252 ASSERT(MUTEX_HELD(&krdc->bmapmutex));
253
254 urdc = &rdc_u_info[krdc->index];
255 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED)
256 return (-1);
257
258 if (krdc->bitmapfd == NULL) {
259 return (-1);
260 }
261 if (_rdc_rsrv_devs(krdc, RDC_BMP, RDC_INTERNAL)) {
262 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "reserve failed");
263 return (-1);
264 }
265
266 if (krdc->bmp_kstats) {
267 mutex_enter(krdc->bmp_kstats->ks_lock);
268 kstat_runq_enter(KSTAT_IO_PTR(krdc->bmp_kstats));
269 mutex_exit(krdc->bmp_kstats->ks_lock);
270 }
271
272 sts = rdc_ns_io(krdc->bitmapfd, NSC_RDBUF, 0, (uchar_t *)header,
273 sizeof (rdc_header_t));
274
275 if (krdc->bmp_kstats) {
276 mutex_enter(krdc->bmp_kstats->ks_lock);
277 kstat_runq_exit(KSTAT_IO_PTR(krdc->bmp_kstats));
278 mutex_exit(krdc->bmp_kstats->ks_lock);
279 KSTAT_IO_PTR(krdc->bmp_kstats)->reads++;
280 KSTAT_IO_PTR(krdc->bmp_kstats)->nread += sizeof (rdc_header_t);
281 }
282
283 if (!RDC_SUCCESS(sts)) {
284 cmn_err(CE_WARN, "!rdc_read_header: %s read failed %d",
285 urdc->primary.file, sts);
286 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "read header failed");
287 }
288
289 _rdc_rlse_devs(krdc, RDC_BMP);
290
291 if (!RDC_SUCCESS(sts))
292 return (-1);
293 switch (header->magic) {
294 case RDC_HDR_V4:
295 /*
296 * old header format - upgrade incore copy, disk copy will
297 * be changed when state is re-written.
298 */
299 #ifdef DEBUG
300 cmn_err(CE_NOTE, "!sndr: old style (V4) bit map header");
301 #endif
302 header->magic = RDC_HDR_MAGIC;
303 u_hdrp.current = header;
304 /* copy down items moved by new maxq??? sizes */
305 u_hdrp.current->asyncthr = u_hdrp.v4->asyncthr;
306 u_hdrp.current->syshostid = u_hdrp.v4->syshostid;
307 u_hdrp.current->maxqitems = u_hdrp.v4->maxqitems;
308 u_hdrp.current->maxqfbas = u_hdrp.v4->maxqfbas;
309 u_hdrp.current->refcntsize = 1; /* new field */
310 #ifdef DEBUG_REFCNT
311 cmn_err(CE_NOTE, "!sndr: refcntsize %d - %d:%s",
312 (int)u_hdrp.current->refcntsize, __LINE__, __FILE__);
313 #endif
314 return (0);
315 case RDC_HDR_MAGIC:
316 /* current header type */
317 return (0);
318 default:
319 /* not a header we currently understand */
320 return (0);
321 }
322 }
323
324 /*
325 * Must be called with krdc->bmapmutex held.
326 */
327 static int
328 rdc_write_header(rdc_k_info_t *krdc, rdc_header_t *header)
329 {
330 rdc_u_info_t *urdc;
331 int sts;
332
333 if (krdc == NULL) {
334 return (-1);
335 }
336
337 ASSERT(MUTEX_HELD(&krdc->bmapmutex));
338
339 urdc = &rdc_u_info[krdc->index];
340 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED)
341 return (-1);
342
343 if (krdc->bitmapfd == NULL) {
344 return (-1);
345 }
346
347 if (_rdc_rsrv_devs(krdc, RDC_BMP, RDC_INTERNAL)) {
348 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "reserve failed");
349 return (-1);
350 }
351
352 if (krdc->bmp_kstats) {
353 mutex_enter(krdc->bmp_kstats->ks_lock);
354 kstat_runq_enter(KSTAT_IO_PTR(krdc->bmp_kstats));
355 mutex_exit(krdc->bmp_kstats->ks_lock);
356 }
357
358 sts = rdc_ns_io(krdc->bitmapfd, rdc_wrflag, 0, (uchar_t *)header,
359 sizeof (rdc_header_t));
360
361 if (krdc->bmp_kstats) {
362 mutex_enter(krdc->bmp_kstats->ks_lock);
363 kstat_runq_exit(KSTAT_IO_PTR(krdc->bmp_kstats));
364 mutex_exit(krdc->bmp_kstats->ks_lock);
365 KSTAT_IO_PTR(krdc->bmp_kstats)->writes++;
366 KSTAT_IO_PTR(krdc->bmp_kstats)->nwritten +=
367 sizeof (rdc_header_t);
368 }
369
370 if (!RDC_SUCCESS(sts)) {
371 cmn_err(CE_WARN, "!rdc_write_header: %s write failed %d",
372 urdc->primary.file, sts);
373 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "write failed");
374 }
375
376 _rdc_rlse_devs(krdc, RDC_BMP);
377
378 if (!RDC_SUCCESS(sts))
379 return (-1);
380 else
381 return (0);
382 }
383
384 struct bm_ref_ops rdc_ref_byte_ops;
385 struct bm_ref_ops rdc_ref_int_ops;
386
387 static void
388 rdc_set_refcnt_ops(rdc_k_info_t *krdc, size_t refcntsize)
389 {
390 switch (refcntsize) {
391 default:
392 /* FALLTHRU */
393 case sizeof (unsigned char):
394 krdc->bm_refs = &rdc_ref_byte_ops;
395 break;
396 case sizeof (unsigned int):
397 krdc->bm_refs = &rdc_ref_int_ops;
398 break;
399 }
400 #ifdef DEBUG_REFCNT
401 cmn_err(CE_NOTE, "!sndr: set refcnt ops for refcntsize %d - %d:%s",
402 (int)refcntsize, __LINE__, __FILE__);
403 #endif
404 }
405
406 size_t
407 rdc_refcntsize(rdc_k_info_t *krdc)
408 {
409 if (krdc->bm_refs == &rdc_ref_int_ops)
410 return (sizeof (unsigned int));
411 return (sizeof (unsigned char));
412 }
413
414 int
415 rdc_read_state(rdc_k_info_t *krdc, int *statep, int *hostidp)
416 {
417 rdc_header_t header;
418 rdc_u_info_t *urdc;
419 int sts;
420
421 if (krdc == NULL) {
422 return (-1);
423 }
424
425 mutex_enter(&krdc->bmapmutex);
426
427 urdc = &rdc_u_info[krdc->index];
428 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED) {
429 mutex_exit(&krdc->bmapmutex);
430 return (-1);
431 }
432
433 if (krdc->bitmapfd == NULL) {
434 mutex_exit(&krdc->bmapmutex);
435 return (-1);
436 }
437
438 sts = rdc_read_header(krdc, &header);
439 mutex_exit(&krdc->bmapmutex);
440
441 if (!RDC_SUCCESS(sts)) {
442 return (-1);
443 }
444
445 switch (header.magic) {
446 case RDC_HDR_MAGIC:
447 *statep = header.flags;
448 *hostidp = header.syshostid;
449 rdc_set_refcnt_ops(krdc, header.refcntsize);
450 #ifdef DEBUG_REFCNT
451 cmn_err(CE_NOTE, "!sndr: refcntsize %d - %d:%s",
452 (int)rdc_refcntsize(krdc), __LINE__, __FILE__);
453 #endif
454 sts = 0;
455 break;
456 default:
457 sts = -1;
458 break;
459 }
460
461 return (sts);
462 }
463
464 int
465 rdc_clear_state(rdc_k_info_t *krdc)
466 {
467 rdc_u_info_t *urdc;
468 int sts;
469 rdc_header_t header;
470
471 if (krdc == NULL) {
472 return (-1);
473 }
474
475 mutex_enter(&krdc->bmapmutex);
476
477 urdc = &rdc_u_info[krdc->index];
478 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED) {
479 mutex_exit(&krdc->bmapmutex);
480 return (-1);
481 }
482
483 if (krdc->bitmapfd == NULL) {
484 mutex_exit(&krdc->bmapmutex);
485 return (-1);
486 }
487
488 if (_rdc_rsrv_devs(krdc, RDC_BMP, RDC_INTERNAL)) {
489 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "reserve failed");
490 mutex_exit(&krdc->bmapmutex);
491 return (-1);
492 }
493
494 bzero(&header, sizeof (header));
495
496 if (krdc->bmp_kstats) {
497 mutex_enter(krdc->bmp_kstats->ks_lock);
498 kstat_runq_enter(KSTAT_IO_PTR(krdc->bmp_kstats));
499 mutex_exit(krdc->bmp_kstats->ks_lock);
500 }
501
502 sts = rdc_ns_io(krdc->bitmapfd, rdc_wrflag, 0,
503 (uchar_t *)&header, sizeof (header));
504
505 if (krdc->bmp_kstats) {
506 mutex_enter(krdc->bmp_kstats->ks_lock);
507 kstat_runq_exit(KSTAT_IO_PTR(krdc->bmp_kstats));
508 mutex_exit(krdc->bmp_kstats->ks_lock);
509 KSTAT_IO_PTR(krdc->bmp_kstats)->writes++;
510 KSTAT_IO_PTR(krdc->bmp_kstats)->nwritten +=
511 sizeof (rdc_header_t);
512 }
513
514 if (!RDC_SUCCESS(sts)) {
515 cmn_err(CE_WARN, "!rdc_clear_state: %s write failed",
516 urdc->primary.file);
517 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "write failed");
518 }
519
520 _rdc_rlse_devs(krdc, RDC_BMP);
521 mutex_exit(&krdc->bmapmutex);
522
523 if (!RDC_SUCCESS(sts))
524 return (-1);
525 else
526 return (0);
527 }
528
529 void
530 rdc_write_state(rdc_u_info_t *urdc)
531 {
532 rdc_k_info_t *krdc;
533 int sts;
534 rdc_header_t header;
535
536 if (urdc == NULL) {
537 return;
538 }
539
540 krdc = &rdc_k_info[urdc->index];
541
542 mutex_enter(&krdc->bmapmutex);
543
544 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED) {
545 mutex_exit(&krdc->bmapmutex);
546 return;
547 }
548
549 if (krdc->bitmapfd == NULL) {
550 mutex_exit(&krdc->bmapmutex);
551 return;
552 }
553
554 if (_rdc_rsrv_devs(krdc, RDC_BMP, RDC_INTERNAL)) {
555 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "reserve failed");
556 mutex_exit(&krdc->bmapmutex);
557 return;
558 }
559
560 if (krdc->bmp_kstats) {
561 mutex_enter(krdc->bmp_kstats->ks_lock);
562 kstat_runq_enter(KSTAT_IO_PTR(krdc->bmp_kstats));
563 mutex_exit(krdc->bmp_kstats->ks_lock);
564 }
565
566 sts = rdc_ns_io(krdc->bitmapfd, NSC_RDBUF, 0, (uchar_t *)&header,
567 sizeof (header));
568
569 if (krdc->bmp_kstats) {
570 mutex_enter(krdc->bmp_kstats->ks_lock);
571 kstat_runq_exit(KSTAT_IO_PTR(krdc->bmp_kstats));
572 mutex_exit(krdc->bmp_kstats->ks_lock);
573 KSTAT_IO_PTR(krdc->bmp_kstats)->reads++;
574 KSTAT_IO_PTR(krdc->bmp_kstats)->nread += sizeof (header);
575 }
576
577 if (!RDC_SUCCESS(sts)) {
578 cmn_err(CE_WARN, "!rdc_write_state: %s read failed",
579 urdc->primary.file);
580 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "read failed");
581 goto done;
582 }
583
584 rdc_fill_header(urdc, &header);
585
586 if (krdc->bmp_kstats) {
587 mutex_enter(krdc->bmp_kstats->ks_lock);
588 kstat_runq_enter(KSTAT_IO_PTR(krdc->bmp_kstats));
589 mutex_exit(krdc->bmp_kstats->ks_lock);
590 }
591
592 sts = rdc_ns_io(krdc->bitmapfd, rdc_wrflag, 0,
593 (uchar_t *)&header, sizeof (header));
594
595 if (krdc->bmp_kstats) {
596 mutex_enter(krdc->bmp_kstats->ks_lock);
597 kstat_runq_exit(KSTAT_IO_PTR(krdc->bmp_kstats));
598 mutex_exit(krdc->bmp_kstats->ks_lock);
599 KSTAT_IO_PTR(krdc->bmp_kstats)->writes++;
600 KSTAT_IO_PTR(krdc->bmp_kstats)->nwritten += sizeof (header);
601 }
602
603 if (!RDC_SUCCESS(sts)) {
604 cmn_err(CE_WARN, "!rdc_write_state: %s write failed",
605 urdc->primary.file);
606 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "write failed");
607 }
608
609 done:
610 _rdc_rlse_devs(krdc, RDC_BMP);
611 mutex_exit(&krdc->bmapmutex);
612 }
613
614
615 struct bitmapdata {
616 uchar_t *data;
617 size_t len;
618 };
619
620 static int
621 rdc_read_bitmap(rdc_k_info_t *krdc, struct bitmapdata *data)
622 {
623 rdc_u_info_t *urdc;
624 int sts;
625
626 if (krdc == NULL) {
627 return (-1);
628 }
629
630 if (data != NULL) {
631 data->data = kmem_alloc(krdc->bitmap_size, KM_SLEEP);
632 data->len = krdc->bitmap_size;
633
634 if (data->data == NULL) {
635 return (-1);
636 }
637 }
638
639 mutex_enter(&krdc->bmapmutex);
640
641 urdc = &rdc_u_info[krdc->index];
642 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED) {
643 mutex_exit(&krdc->bmapmutex);
644 return (-1);
645 }
646
647 if (krdc->bitmapfd == NULL) {
648 mutex_exit(&krdc->bmapmutex);
649 return (-1);
650 }
651
652 if (data == NULL && krdc->dcio_bitmap == NULL) {
653 mutex_exit(&krdc->bmapmutex);
654 return (-1);
655 }
656
657 if (_rdc_rsrv_devs(krdc, RDC_BMP, RDC_INTERNAL)) {
658 cmn_err(CE_WARN, "!rdc_read_bitmap: %s reserve failed",
659 urdc->primary.file);
660 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "reserve failed");
661 mutex_exit(&krdc->bmapmutex);
662 return (-1);
663 }
664
665 if (krdc->bmp_kstats) {
666 mutex_enter(krdc->bmp_kstats->ks_lock);
667 kstat_runq_enter(KSTAT_IO_PTR(krdc->bmp_kstats));
668 mutex_exit(krdc->bmp_kstats->ks_lock);
669 }
670
671 sts = rdc_ns_io(krdc->bitmapfd, NSC_RDBUF, RDC_BITMAP_FBA,
672 data ? data->data : krdc->dcio_bitmap, krdc->bitmap_size);
673
674 if (krdc->bmp_kstats) {
675 mutex_enter(krdc->bmp_kstats->ks_lock);
676 kstat_runq_exit(KSTAT_IO_PTR(krdc->bmp_kstats));
677 mutex_exit(krdc->bmp_kstats->ks_lock);
678 KSTAT_IO_PTR(krdc->bmp_kstats)->reads++;
679 KSTAT_IO_PTR(krdc->bmp_kstats)->nread += krdc->bitmap_size;
680 }
681
682 _rdc_rlse_devs(krdc, RDC_BMP);
683
684 if (!RDC_SUCCESS(sts)) {
685 cmn_err(CE_WARN, "!rdc_read_bitmap: %s read failed",
686 urdc->primary.file);
687 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "read failed");
688 mutex_exit(&krdc->bmapmutex);
689 return (-1);
690 }
691
692 mutex_exit(&krdc->bmapmutex);
693 return (0);
694 }
695
696 int
697 rdc_write_bitmap(rdc_k_info_t *krdc)
698 {
699 rdc_u_info_t *urdc;
700 int sts;
701
702 if (krdc == NULL) {
703 return (-1);
704 }
705
706 mutex_enter(&krdc->bmapmutex);
707
708 urdc = &rdc_u_info[krdc->index];
709 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED) {
710 mutex_exit(&krdc->bmapmutex);
711 return (-1);
712 }
713
714 if (krdc->bitmapfd == NULL) {
715 mutex_exit(&krdc->bmapmutex);
716 return (-1);
717 }
718
719 if (krdc->dcio_bitmap == NULL) {
720 mutex_exit(&krdc->bmapmutex);
721 return (-1);
722 }
723
724 if (_rdc_rsrv_devs(krdc, RDC_BMP, RDC_INTERNAL)) {
725 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "reserve failed");
726 mutex_exit(&krdc->bmapmutex);
727 return (-1);
728 }
729
730 if (krdc->bmp_kstats) {
731 mutex_enter(krdc->bmp_kstats->ks_lock);
732 kstat_runq_enter(KSTAT_IO_PTR(krdc->bmp_kstats));
733 mutex_exit(krdc->bmp_kstats->ks_lock);
734 }
735
736 sts = rdc_ns_io(krdc->bitmapfd, rdc_wrflag, RDC_BITMAP_FBA,
737 krdc->dcio_bitmap, krdc->bitmap_size);
738
739 if (krdc->bmp_kstats) {
740 mutex_enter(krdc->bmp_kstats->ks_lock);
741 kstat_runq_exit(KSTAT_IO_PTR(krdc->bmp_kstats));
742 mutex_exit(krdc->bmp_kstats->ks_lock);
743 KSTAT_IO_PTR(krdc->bmp_kstats)->writes++;
744 KSTAT_IO_PTR(krdc->bmp_kstats)->nwritten += krdc->bitmap_size;
745 }
746
747 _rdc_rlse_devs(krdc, RDC_BMP);
748
749 if (!RDC_SUCCESS(sts)) {
750 cmn_err(CE_WARN, "!rdc_write_bitmap: %s write failed",
751 urdc->primary.file);
752 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "write failed");
753 mutex_exit(&krdc->bmapmutex);
754 return (-1);
755 }
756
757 mutex_exit(&krdc->bmapmutex);
758 return (0);
759 }
760
761 int
762 rdc_write_bitmap_fba(rdc_k_info_t *krdc, nsc_off_t fba)
763 {
764 rdc_u_info_t *urdc;
765 int sts;
766
767 if (krdc == NULL) {
768 return (-1);
769 }
770
771 mutex_enter(&krdc->bmapmutex);
772
773 urdc = &rdc_u_info[krdc->index];
774 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED) {
775 mutex_exit(&krdc->bmapmutex);
776 return (-1);
777 }
778
779 if (krdc->bitmapfd == NULL) {
780 mutex_exit(&krdc->bmapmutex);
781 return (-1);
782 }
783
784 if (krdc->dcio_bitmap == NULL) {
785 mutex_exit(&krdc->bmapmutex);
786 return (-1);
787 }
788
789 if (_rdc_rsrv_devs(krdc, RDC_BMP, RDC_INTERNAL)) {
790 cmn_err(CE_WARN, "!rdc_write_bitmap_fba: %s reserve failed",
791 urdc->primary.file);
792 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "reserve failed");
793 mutex_exit(&krdc->bmapmutex);
794 return (-1);
795 }
796
797 if (krdc->bmp_kstats) {
798 mutex_enter(krdc->bmp_kstats->ks_lock);
799 kstat_runq_enter(KSTAT_IO_PTR(krdc->bmp_kstats));
800 mutex_exit(krdc->bmp_kstats->ks_lock);
801 }
802 sts = rdc_ns_io(krdc->bitmapfd, rdc_wrflag, RDC_BITMAP_FBA + fba,
803 krdc->dcio_bitmap + fba * 512, 512);
804
805 if (krdc->bmp_kstats) {
806 mutex_enter(krdc->bmp_kstats->ks_lock);
807 kstat_runq_exit(KSTAT_IO_PTR(krdc->bmp_kstats));
808 mutex_exit(krdc->bmp_kstats->ks_lock);
809 KSTAT_IO_PTR(krdc->bmp_kstats)->writes++;
810 KSTAT_IO_PTR(krdc->bmp_kstats)->nwritten += 512;
811 }
812
813 _rdc_rlse_devs(krdc, RDC_BMP);
814
815 if (!RDC_SUCCESS(sts)) {
816 cmn_err(CE_WARN, "!rdc_write_bitmap_fba: %s write failed",
817 urdc->primary.file);
818 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "write failed");
819 mutex_exit(&krdc->bmapmutex);
820 return (-1);
821 }
822
823 mutex_exit(&krdc->bmapmutex);
824 return (0);
825 }
826
827
828 static int
829 rdc_write_bitmap_pattern(rdc_k_info_t *krdc, const char pattern)
830 {
831 rdc_u_info_t *urdc;
832 char *buffer;
833 nsc_buf_t *h;
834 nsc_vec_t *v;
835 int rc;
836 size_t i;
837 nsc_size_t len;
838 int off;
839 size_t buffer_size;
840 size_t iolen;
841 nsc_size_t fba_req;
842 nsc_off_t fba_len, fba_pos;
843 nsc_size_t maxfbas = 0;
844 nsc_size_t tocopy;
845
846 if (krdc == NULL) {
847 return (-1);
848 }
849
850 mutex_enter(&krdc->bmapmutex);
851
852 urdc = &rdc_u_info[krdc->index];
853 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED) {
854 mutex_exit(&krdc->bmapmutex);
855 return (-1);
856 }
857
858 if (krdc->bitmapfd == NULL) {
859 mutex_exit(&krdc->bmapmutex);
860 return (-1);
861 }
862
863 if (_rdc_rsrv_devs(krdc, RDC_BMP, RDC_INTERNAL)) {
864 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "reserve failed");
865 mutex_exit(&krdc->bmapmutex);
866 return (-1);
867 }
868
869 buffer_size = FBA_SIZE(1);
870 ASSERT(buffer_size < INT32_MAX);
871 buffer = kmem_alloc(buffer_size, KM_SLEEP);
872
873 for (i = 0; i < buffer_size; i++) {
874 buffer[i] = pattern;
875 }
876
877 rc = nsc_maxfbas(krdc->bitmapfd, 0, &maxfbas);
878 if (!RDC_SUCCESS(rc)) {
879 #ifdef DEBUG
880 cmn_err(CE_WARN,
881 "!rdc_write_bitmap_pattern: maxfbas failed (%d)", rc);
882 #endif
883 maxfbas = 256;
884 }
885
886 fba_req = FBA_LEN(krdc->bitmap_size); /* total FBAs left to copy */
887 fba_pos = RDC_BITMAP_FBA; /* current FBA position */
888 tocopy = krdc->bitmap_size; /* total bytes left to copy */
889 loop:
890 h = NULL;
891 fba_len = min(fba_req, maxfbas); /* FBAs to alloc this time */
892
893 rc = nsc_alloc_buf(krdc->bitmapfd, fba_pos, fba_len, rdc_wrflag, &h);
894 if (!RDC_SUCCESS(rc)) {
895 cmn_err(CE_WARN, "!rdc_write_bitmap_pattern: %s "
896 "write failed %d", urdc->primary.file, rc);
897 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "nsc_alloc_buf failed");
898 if (h) {
899 (void) nsc_free_handle(h);
900 }
901
902 _rdc_rlse_devs(krdc, RDC_BMP);
903 mutex_exit(&krdc->bmapmutex);
904 rc = -1;
905 goto finish;
906 }
907
908 /* bytes to copy this time */
909 len = min(tocopy, FBA_SIZE(fba_len));
910 v = h->sb_vec;
911 off = 0;
912
913 while (len) {
914 if (off >= v->sv_len) {
915 off = 0;
916 v++;
917 }
918
919 if (v->sv_addr == 0 || v->sv_len == 0) {
920 #ifdef DEBUG
921 cmn_err(CE_WARN,
922 "!rdc_write_bitmap_pattern: ran off end of handle");
923 #endif
924 break;
925 }
926
927 iolen = (size_t)min(len, buffer_size);
928
929 bcopy(buffer, (char *)(v->sv_addr + off), iolen);
930 off += iolen;
931 len -= iolen;
932 }
933
934 rc = nsc_write(h, h->sb_pos, h->sb_len, 0);
935 if (!RDC_SUCCESS(rc)) {
936 cmn_err(CE_WARN, "!rdc_write_bitmap_pattern: "
937 "%s write failed %d", urdc->primary.file, rc);
938 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "write failed");
939 (void) nsc_free_buf(h);
940 _rdc_rlse_devs(krdc, RDC_BMP);
941 mutex_exit(&krdc->bmapmutex);
942 rc = -1;
943 goto finish;
944 }
945
946 (void) nsc_free_buf(h);
947
948 fba_pos += fba_len;
949 fba_req -= fba_len;
950 tocopy -= FBA_SIZE(fba_len); /* adjust byte length remaining */
951 if (fba_req > 0)
952 goto loop;
953
954 _rdc_rlse_devs(krdc, RDC_BMP);
955 mutex_exit(&krdc->bmapmutex);
956 rc = 0;
957 finish:
958 kmem_free(buffer, buffer_size);
959 return (rc);
960 }
961
962
963 /*
964 * rdc_write_bitmap_fill()
965 *
966 * Write a bitmap full of 1's out to disk without touching the
967 * in-memory bitmap.
968 */
969 int
970 rdc_write_bitmap_fill(rdc_k_info_t *krdc)
971 {
972 return (rdc_write_bitmap_pattern(krdc, 0xff));
973 }
974
975
976 void
977 rdc_merge_bitmaps(rdc_k_info_t *src, rdc_k_info_t *dst)
978 {
979 if (src->dcio_bitmap == NULL || dst->dcio_bitmap == NULL)
980 return;
981
982 rdc_lor(src->dcio_bitmap, dst->dcio_bitmap,
983 min(src->bitmap_size, dst->bitmap_size));
984 if (dst->bitmap_write > 0)
985 (void) rdc_write_bitmap(dst);
986 }
987
988
989 /*
990 * bitmap size in bytes, vol_size fba's
991 */
992
993 size_t
994 rdc_ref_size_possible(nsc_size_t bitmap_size, nsc_size_t vol_size)
995 {
996 nsc_size_t ref_size;
997 nsc_size_t bitmap_end_fbas;
998
999 bitmap_end_fbas = RDC_BITMAP_FBA + FBA_LEN(bitmap_size);
1000 ref_size = FBA_LEN(bitmap_size * BITS_IN_BYTE * sizeof (unsigned char));
1001 if (bitmap_end_fbas + ref_size > vol_size)
1002 return ((size_t)0);
1003
1004 ref_size = FBA_LEN(bitmap_size * BITS_IN_BYTE * sizeof (unsigned int));
1005 if (bitmap_end_fbas + ref_size > vol_size)
1006 return (sizeof (unsigned char));
1007 return (sizeof (unsigned int));
1008 }
1009
1010 int
1011 rdc_move_bitmap(rdc_k_info_t *krdc, char *newbitmap)
1012 {
1013 rdc_u_info_t *urdc;
1014 nsc_fd_t *oldfd;
1015 nsc_fd_t *newfd = NULL;
1016 rdc_header_t header;
1017 int sts;
1018 nsc_size_t vol_size;
1019 nsc_size_t req_size;
1020 size_t ref_size;
1021
1022 if (krdc == NULL) {
1023 return (-1);
1024 }
1025
1026 if (krdc->bitmapfd == NULL) {
1027 return (-1);
1028 }
1029
1030 req_size = RDC_BITMAP_FBA + FBA_LEN(krdc->bitmap_size);
1031 if (RDC_IS_DISKQ(krdc->group)) {
1032 /* new volume must support at least the old refcntsize */
1033 req_size += FBA_LEN(krdc->bitmap_size * BITS_IN_BYTE *
1034 rdc_refcntsize(krdc));
1035 #ifdef DEBUG_REFCNT
1036 cmn_err(CE_NOTE, "!sndr: refcntsize %d - %d:%s",
1037 (int)rdc_refcntsize(krdc), __LINE__, __FILE__);
1038 #endif
1039 }
1040
1041 mutex_enter(&krdc->bmapmutex);
1042
1043 if (rdc_read_header(krdc, &header) < 0) {
1044 #ifdef DEBUG
1045 cmn_err(CE_WARN, "!rdc_move_bitmap: Read old header failed");
1046 #endif
1047 mutex_exit(&krdc->bmapmutex);
1048 return (-1);
1049 }
1050
1051 oldfd = krdc->bitmapfd;
1052
1053 newfd = nsc_open(newbitmap, NSC_RDCHR_ID|NSC_FILE|NSC_RDWR, 0, 0, 0);
1054 if (newfd == NULL) {
1055 newfd = nsc_open(newbitmap,
1056 NSC_RDCHR_ID|NSC_CACHE|NSC_DEVICE|NSC_RDWR, 0, 0, 0);
1057 if (newfd == NULL) {
1058 /* Can't open new bitmap */
1059 cmn_err(CE_WARN,
1060 "!rdc_move_bitmap: Cannot open new bitmap %s",
1061 newbitmap);
1062 goto fail;
1063 }
1064 }
1065
1066 sts = nsc_reserve(newfd, 0);
1067 if (!RDC_SUCCESS(sts)) {
1068 cmn_err(CE_WARN, "!rdc_move_bitmap: Reserve failed for %s",
1069 newbitmap);
1070 goto fail;
1071 }
1072 sts = nsc_partsize(newfd, &vol_size);
1073 nsc_release(newfd);
1074
1075 if (!RDC_SUCCESS(sts)) {
1076 cmn_err(CE_WARN,
1077 "!rdc_move_bitmap: nsc_partsize failed for %s", newbitmap);
1078 goto fail;
1079 }
1080
1081 ref_size = rdc_ref_size_possible(krdc->bitmap_size, vol_size);
1082
1083 if (vol_size < req_size) {
1084 cmn_err(CE_WARN,
1085 "!rdc_move_bitmap: bitmap %s too small: %" NSC_SZFMT
1086 " vs %" NSC_SZFMT " blocks", newbitmap, vol_size, req_size);
1087 goto fail;
1088 }
1089
1090 mutex_enter(&krdc->devices->id_rlock);
1091 krdc->bitmapfd = newfd; /* swap under lock */
1092 if (krdc->bmaprsrv > 0) {
1093 sts = nsc_reserve(krdc->bitmapfd, 0);
1094 if (!RDC_SUCCESS(sts)) {
1095 krdc->bitmapfd = oldfd; /* replace under lock */
1096 mutex_exit(&krdc->devices->id_rlock);
1097 cmn_err(CE_WARN,
1098 "!rdc_move_bitmap: Reserve failed for %s",
1099 newbitmap);
1100 goto fail;
1101 }
1102 }
1103 rdc_set_refcnt_ops(krdc, ref_size);
1104 #ifdef DEBUG_REFCNT
1105 cmn_err(CE_NOTE, "!sndr: refcntsize %d - %d:%s",
1106 (int)rdc_refcntsize(krdc), __LINE__, __FILE__);
1107 #endif
1108 mutex_exit(&krdc->devices->id_rlock);
1109
1110 /* Forget newfd now it is krdc->bitmapfd */
1111 newfd = NULL;
1112
1113 /* Put new bitmap name into header and user-visible data structure */
1114 urdc = &rdc_u_info[krdc->index];
1115 if (rdc_get_vflags(urdc) & RDC_PRIMARY) {
1116 (void) strncpy(header.primary.bitmap, newbitmap, NSC_MAXPATH);
1117 (void) strncpy(urdc->primary.bitmap, newbitmap, NSC_MAXPATH);
1118 } else {
1119 (void) strncpy(header.secondary.bitmap, newbitmap, NSC_MAXPATH);
1120 (void) strncpy(urdc->secondary.bitmap, newbitmap, NSC_MAXPATH);
1121 }
1122
1123 if (rdc_write_header(krdc, &header) < 0) {
1124 cmn_err(CE_WARN,
1125 "!rdc_move_bitmap: Write header %s failed", newbitmap);
1126 goto fail;
1127 }
1128
1129 mutex_exit(&krdc->bmapmutex);
1130
1131 if (rdc_write_bitmap(krdc) < 0) {
1132 mutex_enter(&krdc->bmapmutex);
1133 cmn_err(CE_WARN,
1134 "!rdc_move_bitmap: Write bitmap %s failed", newbitmap);
1135 goto fail;
1136 }
1137
1138 /* Unintercept the old bitmap */
1139 if (krdc->b_tok) {
1140 int rc;
1141
1142 rdc_group_exit(krdc);
1143 rc = nsc_unregister_path(krdc->b_tok, 0);
1144 if (rc)
1145 cmn_err(CE_WARN, "!rdc_move_bitmap: "
1146 "unregister bitmap failed %d", rc);
1147 else
1148 krdc->b_tok = nsc_register_path(newbitmap,
1149 NSC_CACHE | NSC_DEVICE, _rdc_io_hc);
1150 rdc_group_enter(krdc);
1151 }
1152
1153 /* clear the old bitmap header */
1154 bzero(&header, sizeof (header));
1155
1156 sts = nsc_held(oldfd) ? 0 : nsc_reserve(oldfd, 0);
1157 if (sts == 0) {
1158
1159 if (krdc->bmp_kstats) {
1160 mutex_enter(krdc->bmp_kstats->ks_lock);
1161 kstat_runq_enter(KSTAT_IO_PTR(krdc->bmp_kstats));
1162 mutex_exit(krdc->bmp_kstats->ks_lock);
1163 }
1164
1165 sts = rdc_ns_io(oldfd, rdc_wrflag, 0,
1166 (uchar_t *)&header, sizeof (header));
1167
1168 if (krdc->bmp_kstats) {
1169 mutex_enter(krdc->bmp_kstats->ks_lock);
1170 kstat_runq_exit(KSTAT_IO_PTR(krdc->bmp_kstats));
1171 mutex_exit(krdc->bmp_kstats->ks_lock);
1172 KSTAT_IO_PTR(krdc->bmp_kstats)->writes++;
1173 KSTAT_IO_PTR(krdc->bmp_kstats)->nwritten +=
1174 sizeof (header);
1175 }
1176
1177 }
1178 #ifdef DEBUG
1179 if (sts != 0) {
1180 cmn_err(CE_WARN,
1181 "!rdc_move_bitmap: unable to clear bitmap header on %s",
1182 nsc_pathname(oldfd));
1183 }
1184 #endif
1185
1186 /* nsc_close will undo any reservation */
1187 if (nsc_close(oldfd) != 0) {
1188 #ifdef DEBUG
1189 cmn_err(CE_WARN, "!rdc_move_bitmap: close old bitmap failed");
1190 #else
1191 ;
1192 /*EMPTY*/
1193 #endif
1194 }
1195
1196 return (0);
1197
1198 fail:
1199 /* Close newfd if it was unused */
1200 if (newfd && newfd != krdc->bitmapfd) {
1201 (void) nsc_close(newfd);
1202 newfd = NULL;
1203 }
1204
1205 mutex_exit(&krdc->bmapmutex);
1206 return (-1);
1207 }
1208
1209
1210 void
1211 rdc_close_bitmap(rdc_k_info_t *krdc)
1212 {
1213
1214 if (krdc == NULL) {
1215 return;
1216 }
1217
1218 mutex_enter(&krdc->bmapmutex);
1219
1220 if (krdc->bitmapfd) {
1221 if (nsc_close(krdc->bitmapfd) != 0) {
1222 #ifdef DEBUG
1223 cmn_err(CE_WARN, "!nsc_close on bitmap failed");
1224 #else
1225 ;
1226 /*EMPTY*/
1227 #endif
1228 }
1229 krdc->bitmapfd = 0;
1230 }
1231
1232 mutex_exit(&krdc->bmapmutex);
1233 }
1234
1235 void
1236 rdc_free_bitmap(rdc_k_info_t *krdc, int cmd)
1237 {
1238 rdc_header_t header;
1239 rdc_u_info_t *urdc = &rdc_u_info[krdc->index];
1240
1241 if (krdc == NULL) {
1242 return;
1243 }
1244
1245 mutex_enter(&krdc->bmapmutex);
1246
1247 if (cmd != RDC_CMD_SUSPEND) {
1248
1249 bzero((char *)&header, sizeof (rdc_header_t));
1250
1251 if (krdc->bitmapfd)
1252 (void) rdc_write_header(krdc, &header);
1253 } else {
1254 mutex_exit(&krdc->bmapmutex);
1255 /* gotta drop mutex, in case q needs to fail */
1256 if (RDC_IS_DISKQ(krdc->group) && rdc_suspend_diskq(krdc) < 0) {
1257 cmn_err(CE_WARN,
1258 "!rdc_free_bitmap: diskq suspend failed");
1259 }
1260
1261 mutex_enter(&krdc->bmapmutex);
1262 if (rdc_read_header(krdc, &header) < 0) {
1263 cmn_err(CE_WARN,
1264 "!rdc_free_bitmap: Read header failed");
1265 } else {
1266 rdc_fill_header(urdc, &header);
1267
1268 (void) rdc_write_header(krdc, &header);
1269 }
1270 }
1271
1272 mutex_exit(&krdc->bmapmutex);
1273
1274 if (krdc->dcio_bitmap != NULL) {
1275 if (cmd == RDC_CMD_SUSPEND) {
1276 if (krdc->bitmapfd)
1277 (void) rdc_write_bitmap(krdc);
1278 }
1279
1280 kmem_free(krdc->dcio_bitmap, krdc->bitmap_size);
1281 krdc->dcio_bitmap = NULL;
1282 }
1283 if (krdc->bitmap_ref != NULL) {
1284 kmem_free(krdc->bitmap_ref, (krdc->bitmap_size * BITS_IN_BYTE *
1285 BMAP_REF_PREF_SIZE));
1286 krdc->bitmap_ref = NULL;
1287 }
1288
1289 krdc->bitmap_size = 0;
1290 }
1291
1292 static int
1293 rdc_alloc_bitmap(rdc_k_info_t *krdc)
1294 {
1295 rdc_u_info_t *urdc;
1296 char *bitmapname;
1297 nsc_size_t bitmap_ref_size;
1298
1299 if (krdc == NULL) {
1300 return (-1);
1301 }
1302
1303 urdc = &rdc_u_info[krdc->index];
1304 if (rdc_get_vflags(urdc) & RDC_PRIMARY)
1305 bitmapname = &urdc->primary.bitmap[0];
1306 else
1307 bitmapname = &urdc->secondary.bitmap[0];
1308
1309 if (krdc->dcio_bitmap) {
1310 #ifdef DEBUG
1311 cmn_err(CE_WARN,
1312 "!rdc_alloc_bitmap: bitmap %s already allocated",
1313 bitmapname);
1314 #endif
1315 return (0);
1316 }
1317
1318 if (urdc->volume_size == 0)
1319 return (-1);
1320
1321 krdc->bitmap_size = BMAP_LOG_BYTES(urdc->volume_size);
1322 /* Round up */
1323 krdc->bitmap_size = (krdc->bitmap_size + 511) / 512 * 512;
1324
1325 krdc->dcio_bitmap = (uchar_t *)kmem_zalloc(krdc->bitmap_size,
1326 KM_SLEEP);
1327 if (krdc->dcio_bitmap == NULL) {
1328 cmn_err(CE_WARN, "!rdc_alloc_bitmap: alloc %" NSC_SZFMT
1329 " failed for %s", krdc->bitmap_size, bitmapname);
1330 return (-1);
1331 }
1332
1333 /*
1334 * use largest ref count type size as we haven't opened the bitmap
1335 * volume yet to find out what has acutally be used.
1336 */
1337 bitmap_ref_size = krdc->bitmap_size * BITS_IN_BYTE * BMAP_REF_PREF_SIZE;
1338 if ((rdc_get_vflags(urdc) & RDC_PRIMARY) &&
1339 ((krdc->type_flag & RDC_ASYNCMODE) != 0)) {
1340 krdc->bitmap_ref = (uchar_t *)kmem_zalloc(bitmap_ref_size,
1341 KM_SLEEP);
1342 if (krdc->bitmap_ref == NULL) {
1343 cmn_err(CE_WARN,
1344 "!rdc_alloc_bitmap: ref alloc %" NSC_SZFMT
1345 " failed for %s",
1346 bitmap_ref_size, bitmapname);
1347 return (-1);
1348 }
1349 }
1350
1351 return (0);
1352 }
1353
1354
1355 static int
1356 rdc_open_bitmap(rdc_k_info_t *krdc)
1357 {
1358 rdc_u_info_t *urdc;
1359 int sts;
1360 uint_t hints = 0;
1361 nsc_size_t vol_size;
1362 char *bitmapname;
1363 nsc_size_t req_size;
1364 nsc_size_t bit_size;
1365
1366 urdc = &rdc_u_info[krdc->index];
1367 if (rdc_get_vflags(urdc) & RDC_PRIMARY)
1368 bitmapname = &urdc->primary.bitmap[0];
1369 else
1370 bitmapname = &urdc->secondary.bitmap[0];
1371
1372 urdc->bits_set = 0;
1373
1374 bit_size = req_size = RDC_BITMAP_FBA + FBA_LEN(krdc->bitmap_size);
1375 if (RDC_IS_DISKQ(krdc->group)) {
1376 req_size += FBA_LEN(krdc->bitmap_size * BITS_IN_BYTE *
1377 sizeof (unsigned char));
1378 }
1379
1380 mutex_enter(&krdc->bmapmutex);
1381
1382 rdc_set_refcnt_ops(krdc, sizeof (unsigned char));
1383 #ifdef DEBUG_REFCNT
1384 cmn_err(CE_NOTE, "!sndr: refcntsize %d - %d:%s",
1385 (int)rdc_refcntsize(krdc), __LINE__, __FILE__);
1386 #endif
1387 if (krdc->bitmapfd == NULL)
1388 krdc->bitmapfd = nsc_open(bitmapname,
1389 NSC_RDCHR_ID|NSC_FILE|NSC_RDWR, 0, 0, 0);
1390 if (krdc->bitmapfd == NULL) {
1391 krdc->bitmapfd = nsc_open(bitmapname,
1392 NSC_RDCHR_ID|NSC_CACHE|NSC_DEVICE|NSC_RDWR, 0, 0, 0);
1393 if (krdc->bitmapfd == NULL) {
1394 cmn_err(CE_WARN, "!rdc_open_bitmap: Unable to open %s",
1395 bitmapname);
1396 goto fail;
1397 }
1398 }
1399
1400 sts = _rdc_rsrv_devs(krdc, RDC_BMP, RDC_INTERNAL);
1401 if (!RDC_SUCCESS(sts)) {
1402 cmn_err(CE_WARN, "!rdc_open_bitmap: Reserve failed for %s",
1403 bitmapname);
1404 goto fail;
1405 }
1406 sts = nsc_partsize(krdc->bitmapfd, &vol_size);
1407 _rdc_rlse_devs(krdc, RDC_BMP);
1408
1409 if (!RDC_SUCCESS(sts)) {
1410 cmn_err(CE_WARN,
1411 "!rdc_open_bitmap: nsc_partsize failed for %s", bitmapname);
1412 goto fail;
1413 }
1414
1415 if (vol_size < req_size) {
1416 /* minimum size supports unsigned char reference counts */
1417 cmn_err(CE_WARN,
1418 "!rdc_open_bitmap: bitmap %s too small: %" NSC_SZFMT " vs %"
1419 NSC_SZFMT "blocks",
1420 bitmapname, vol_size, req_size);
1421 goto fail;
1422 }
1423
1424 if (rdc_bitmap_mode == RDC_BMP_NEVER) {
1425 krdc->bitmap_write = 0; /* forced off */
1426 } else if (rdc_bitmap_mode == RDC_BMP_ALWAYS ||
1427 (nsc_node_hints(&hints) == 0 && (hints & NSC_FORCED_WRTHRU) == 0)) {
1428 krdc->bitmap_write = 1; /* forced or autodetect on */
1429 } else {
1430 /* autodetect off */
1431 krdc->bitmap_write = 0;
1432 }
1433
1434 mutex_exit(&krdc->bmapmutex);
1435 if (RDC_IS_DISKQ(krdc->group) && (rdc_refcntsize(krdc) <
1436 BMAP_REF_PREF_SIZE)) {
1437 /* test for larger ref counts */
1438 #ifdef DEBUG_REFCNT
1439 cmn_err(CE_NOTE, "!sndr: refcntsize %d - %d:%s",
1440 (int)rdc_refcntsize(krdc), __LINE__, __FILE__);
1441 #endif
1442 req_size = bit_size;
1443 req_size += FBA_LEN(krdc->bitmap_size * BITS_IN_BYTE *
1444 sizeof (unsigned int));
1445 if (vol_size >= req_size)
1446 rdc_set_refcnt_ops(krdc, sizeof (unsigned int));
1447 }
1448 #ifdef DEBUG_REFCNT
1449 cmn_err(CE_NOTE, "!sndr: refcntsize %d - %d:%s",
1450 (int)rdc_refcntsize(krdc), __LINE__, __FILE__);
1451 #endif
1452 return (0);
1453
1454 fail:
1455 mutex_exit(&krdc->bmapmutex);
1456 return (-1);
1457 }
1458
1459 int
1460 rdc_enable_bitmap(rdc_k_info_t *krdc, int set)
1461 {
1462 rdc_header_t header;
1463 rdc_u_info_t *urdc;
1464 char *bitmapname;
1465
1466 urdc = &rdc_u_info[krdc->index];
1467
1468 if (rdc_alloc_bitmap(krdc) < 0)
1469 goto fail;
1470
1471 if (rdc_open_bitmap(krdc) < 0)
1472 goto fail;
1473
1474 if (rdc_get_vflags(urdc) & RDC_PRIMARY)
1475 bitmapname = &urdc->primary.bitmap[0];
1476 else
1477 bitmapname = &urdc->secondary.bitmap[0];
1478
1479 mutex_enter(&krdc->bmapmutex);
1480
1481 rdc_clr_flags(urdc, RDC_BMP_FAILED);
1482 if (rdc_read_header(krdc, &header) < 0) {
1483 cmn_err(CE_WARN,
1484 "!rdc_enable_bitmap: Read header %s failed", bitmapname);
1485 mutex_exit(&krdc->bmapmutex);
1486 goto fail;
1487 }
1488
1489 rdc_fill_header(urdc, &header);
1490 rdc_set_refcnt_ops(krdc, (size_t)header.refcntsize);
1491
1492 if (set)
1493 (void) RDC_FILL_BITMAP(krdc, FALSE);
1494
1495 if (rdc_write_header(krdc, &header) < 0) {
1496 cmn_err(CE_WARN,
1497 "!rdc_enable_bitmap: Write header %s failed",
1498 bitmapname);
1499 mutex_exit(&krdc->bmapmutex);
1500 goto fail;
1501 }
1502 mutex_exit(&krdc->bmapmutex);
1503
1504 if (rdc_write_bitmap(krdc) < 0) {
1505 cmn_err(CE_WARN,
1506 "!rdc_enable_bitmap: Write bitmap %s failed",
1507 bitmapname);
1508 goto fail;
1509 }
1510
1511 return (0);
1512
1513 fail:
1514 rdc_free_bitmap(krdc, RDC_CMD_ENABLE);
1515 rdc_close_bitmap(krdc);
1516
1517 mutex_enter(&krdc->bmapmutex);
1518 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "I/O failed");
1519 mutex_exit(&krdc->bmapmutex);
1520 return (-1);
1521 }
1522
1523 static int
1524 _rdc_rdwr_refcnt(rdc_k_info_t *krdc, int rwflg)
1525 {
1526 rdc_u_info_t *urdc;
1527 int rc;
1528 nsc_off_t offset;
1529 nsc_size_t len;
1530
1531 urdc = &rdc_u_info[krdc->index];
1532
1533 #ifdef DEBUG_REFCNT
1534 cmn_err(CE_NOTE, "!rdc_rdwr_refcnt: %s refcount for %s",
1535 (rwflg == NSC_READ) ? "resuming" : "writing",
1536 urdc->primary.bitmap);
1537 #endif
1538 ASSERT(MUTEX_HELD(QLOCK((&krdc->group->diskq))));
1539 mutex_enter(&krdc->bmapmutex);
1540
1541 if (_rdc_rsrv_devs(krdc, RDC_BMP, RDC_INTERNAL)) {
1542 cmn_err(CE_WARN, "!rdc_rdwr_refcnt: reserve failed");
1543 goto fail;
1544 }
1545
1546 if (krdc->bitmap_size == 0) {
1547 cmn_err(CE_WARN, "!rdc_rdwr_refcnt: NULL bitmap!");
1548 goto fail;
1549 }
1550
1551 offset = RDC_BITREF_FBA(krdc);
1552 len = krdc->bitmap_size * BITS_IN_BYTE * rdc_refcntsize(krdc);
1553
1554 rc = rdc_ns_io(krdc->bitmapfd, rwflg, offset,
1555 (uchar_t *)krdc->bitmap_ref, len);
1556
1557 if (!RDC_SUCCESS(rc)) {
1558 cmn_err(CE_WARN, "!unable to %s refcount from bitmap %s",
1559 (rwflg == NSC_READ) ? "retrieve" : "write",
1560 urdc->primary.bitmap);
1561 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "refcount I/O failed");
1562 goto fail;
1563 }
1564
1565 _rdc_rlse_devs(krdc, RDC_BMP);
1566
1567 mutex_exit(&krdc->bmapmutex);
1568
1569 #ifdef DEBUG_REFCNT
1570 cmn_err(CE_NOTE, "!rdc_rdwr_refcnt: %s refcount for %s",
1571 (rwflg == NSC_READ) ? "resumed" : "wrote",
1572 urdc->primary.bitmap);
1573 #endif
1574 return (0);
1575
1576 fail:
1577 _rdc_rlse_devs(krdc, RDC_BMP);
1578
1579 mutex_exit(&krdc->bmapmutex);
1580
1581 return (-1);
1582
1583 }
1584
1585 /*
1586 * rdc_read_refcount
1587 * read the stored refcount from disk
1588 * queue lock is held
1589 */
1590 int
1591 rdc_read_refcount(rdc_k_info_t *krdc)
1592 {
1593 int rc;
1594
1595 rc = _rdc_rdwr_refcnt(krdc, NSC_READ);
1596
1597 return (rc);
1598 }
1599
1600 /*
1601 * rdc_write_refcount
1602 * writes krdc->bitmap_ref to the diskq
1603 * called with qlock held
1604 */
1605 int
1606 rdc_write_refcount(rdc_k_info_t *krdc)
1607 {
1608 int rc;
1609
1610 rc = _rdc_rdwr_refcnt(krdc, NSC_WRBUF);
1611
1612 return (rc);
1613 }
1614
1615 static int
1616 rdc_resume_state(rdc_k_info_t *krdc, const rdc_header_t *header)
1617 {
1618 rdc_u_info_t *urdc;
1619 char *bitmapname;
1620
1621 urdc = &rdc_u_info[krdc->index];
1622 if (rdc_get_vflags(urdc) & RDC_PRIMARY)
1623 bitmapname = &urdc->primary.bitmap[0];
1624 else
1625 bitmapname = &urdc->secondary.bitmap[0];
1626
1627 if (header->magic != RDC_HDR_MAGIC) {
1628 cmn_err(CE_WARN, "!rdc_resume_state: Bad magic in %s",
1629 bitmapname);
1630 return (-1);
1631 }
1632
1633 if (strncmp(urdc->primary.file, header->primary.file,
1634 NSC_MAXPATH) != 0) {
1635 #ifdef DEBUG
1636 cmn_err(CE_WARN,
1637 "!rdc_resume_state: Found %s Expected %s",
1638 header->primary.file, urdc->primary.file);
1639 #endif /* DEBUG */
1640 return (-1);
1641 }
1642
1643 if (strncmp(urdc->secondary.file, header->secondary.file,
1644 NSC_MAXPATH) != 0) {
1645 #ifdef DEBUG
1646 cmn_err(CE_WARN,
1647 "!rdc_resume_state: Found %s Expected %s",
1648 header->secondary.file, urdc->secondary.file);
1649 #endif /* DEBUG */
1650 return (-1);
1651 }
1652
1653 if (strncmp(urdc->primary.bitmap, header->primary.bitmap,
1654 NSC_MAXPATH) != 0) {
1655 #ifdef DEBUG
1656 cmn_err(CE_WARN,
1657 "!rdc_resume_state: Found %s Expected %s",
1658 header->primary.bitmap, urdc->primary.bitmap);
1659 #endif /* DEBUG */
1660 return (-1);
1661 }
1662
1663 if (strncmp(urdc->secondary.bitmap, header->secondary.bitmap,
1664 NSC_MAXPATH) != 0) {
1665 #ifdef DEBUG
1666 cmn_err(CE_WARN,
1667 "!rdc_resume_state: Found %s Expected %s",
1668 header->secondary.bitmap, urdc->secondary.bitmap);
1669 #endif /* DEBUG */
1670 return (-1);
1671 }
1672
1673 if (header->maxqfbas)
1674 urdc->maxqfbas = header->maxqfbas;
1675
1676 if (header->maxqitems)
1677 urdc->maxqitems = header->maxqitems;
1678
1679 if (header->autosync >= 0)
1680 urdc->autosync = header->autosync;
1681
1682 if (header->asyncthr)
1683 urdc->asyncthr = header->asyncthr;
1684
1685 rdc_many_enter(krdc);
1686 rdc_set_refcnt_ops(krdc, header->refcntsize);
1687 #ifdef DEBUG_REFCNT
1688 cmn_err(CE_NOTE, "!sndr: refcntsize %d - %d:%s",
1689 (int)rdc_refcntsize(krdc), __LINE__, __FILE__);
1690 #endif
1691 if (header->flags & RDC_VOL_FAILED)
1692 rdc_set_flags(urdc, RDC_VOL_FAILED);
1693 if (header->flags & RDC_QUEUING)
1694 rdc_set_flags(urdc, RDC_QUEUING);
1695
1696 rdc_clr_flags(urdc, RDC_SYNC_NEEDED | RDC_RSYNC_NEEDED);
1697 rdc_set_mflags(urdc, (header->flags & RDC_RSYNC_NEEDED));
1698 rdc_set_flags(urdc, (header->flags & RDC_SYNC_NEEDED));
1699 rdc_many_exit(krdc);
1700
1701 if (urdc->flags & RDC_VOL_FAILED) {
1702
1703 /* Our disk was failed so set all the bits in the bitmap */
1704
1705 if (RDC_FILL_BITMAP(krdc, TRUE) != 0) {
1706 cmn_err(CE_WARN,
1707 "!rdc_resume_state: Fill bitmap %s failed",
1708 bitmapname);
1709 return (-1);
1710 }
1711 rdc_many_enter(krdc);
1712 if (IS_STATE(urdc, RDC_QUEUING))
1713 rdc_clr_flags(urdc, RDC_QUEUING);
1714 rdc_many_exit(krdc);
1715 } else {
1716 /* Header was good, so read in the bitmap */
1717
1718 if (rdc_read_bitmap(krdc, NULL) < 0) {
1719 cmn_err(CE_WARN,
1720 "!rdc_resume_state: Read bitmap %s failed",
1721 bitmapname);
1722 return (-1);
1723 }
1724
1725 urdc->bits_set = RDC_COUNT_BITMAP(krdc);
1726
1727 /*
1728 * Check if another node went down with bits set, but
1729 * without setting logging mode.
1730 */
1731 if (urdc->bits_set != 0 &&
1732 (rdc_get_vflags(urdc) & RDC_ENABLED) &&
1733 !(rdc_get_vflags(urdc) & RDC_LOGGING)) {
1734 rdc_group_log(krdc, RDC_NOFLUSH | RDC_NOREMOTE, NULL);
1735 }
1736 }
1737
1738 /* if we are using a disk queue, read in the reference count bits */
1739 if (RDC_IS_DISKQ(krdc->group)) {
1740 disk_queue *q = &krdc->group->diskq;
1741 mutex_enter(QLOCK(q));
1742 if ((rdc_read_refcount(krdc) < 0)) {
1743 cmn_err(CE_WARN,
1744 "!rdc_resume_state: Resume bitmap %s's refcount"
1745 "failed",
1746 urdc->primary.bitmap);
1747 mutex_exit(QLOCK(q));
1748 rdc_many_enter(krdc);
1749 if (IS_STATE(urdc, RDC_QUEUING))
1750 rdc_clr_flags(urdc, RDC_QUEUING);
1751 rdc_many_exit(krdc);
1752 return (-1);
1753 }
1754 mutex_exit(QLOCK(q));
1755 }
1756
1757 return (0);
1758 }
1759
1760
1761 int
1762 rdc_resume_bitmap(rdc_k_info_t *krdc)
1763 {
1764 rdc_header_t header;
1765 rdc_u_info_t *urdc = &rdc_u_info[krdc->index];
1766 char *bitmapname;
1767
1768 if (rdc_alloc_bitmap(krdc) < 0)
1769 goto allocfail;
1770
1771 if (rdc_open_bitmap(krdc) < 0)
1772 goto fail;
1773
1774 if (rdc_get_vflags(urdc) & RDC_PRIMARY)
1775 bitmapname = &urdc->primary.bitmap[0];
1776 else
1777 bitmapname = &urdc->secondary.bitmap[0];
1778
1779 mutex_enter(&krdc->bmapmutex);
1780
1781 rdc_clr_flags(urdc, RDC_BMP_FAILED);
1782 if (rdc_read_header(krdc, &header) < 0) {
1783 cmn_err(CE_WARN,
1784 "!rdc_resume_bitmap: Read header %s failed", bitmapname);
1785 mutex_exit(&krdc->bmapmutex);
1786 goto fail;
1787 }
1788
1789 mutex_exit(&krdc->bmapmutex);
1790
1791 /* Resuming from the bitmap, so do some checking */
1792
1793 /*CONSTCOND*/
1794 ASSERT(FBA_LEN(sizeof (rdc_header_t)) <= RDC_BITMAP_FBA);
1795 /*CONSTCOND*/
1796 ASSERT(sizeof (rdc_header_t) >= sizeof (rdc_headerv2_t));
1797
1798 if (header.magic == RDC_HDR_V2) {
1799 rdc_headerv2_t *hdr_v2 = (rdc_headerv2_t *)&header;
1800 rdc_header_t new_header;
1801
1802 #ifdef DEBUG
1803 cmn_err(CE_WARN,
1804 "!rdc_resume_bitmap: Converting v2 header for bitmap %s",
1805 bitmapname);
1806 #endif
1807 bzero((char *)&new_header, sizeof (rdc_header_t));
1808
1809 new_header.autosync = -1;
1810 new_header.magic = RDC_HDR_MAGIC;
1811 new_header.syshostid = urdc->syshostid;
1812
1813 if (hdr_v2->volume_failed)
1814 new_header.flags |= RDC_VOL_FAILED;
1815 if (hdr_v2->sync_needed == RDC_SYNC)
1816 new_header.flags |= RDC_SYNC_NEEDED;
1817 if (hdr_v2->sync_needed == RDC_FULL_SYNC)
1818 new_header.flags |= RDC_SYNC_NEEDED;
1819 if (hdr_v2->sync_needed == RDC_REV_SYNC)
1820 new_header.flags |= RDC_RSYNC_NEEDED;
1821 if (rdc_get_vflags(urdc) & RDC_PRIMARY) {
1822 (void) strncpy(new_header.primary.file,
1823 hdr_v2->filename, NSC_MAXPATH);
1824 (void) strncpy(new_header.primary.bitmap,
1825 hdr_v2->bitmapname, NSC_MAXPATH);
1826 (void) strncpy(new_header.secondary.file,
1827 urdc->secondary.file, NSC_MAXPATH);
1828 (void) strncpy(new_header.secondary.bitmap,
1829 urdc->secondary.bitmap, NSC_MAXPATH);
1830 } else {
1831 (void) strncpy(new_header.secondary.file,
1832 hdr_v2->filename, NSC_MAXPATH);
1833 (void) strncpy(new_header.secondary.bitmap,
1834 hdr_v2->bitmapname, NSC_MAXPATH);
1835 (void) strncpy(new_header.primary.file,
1836 urdc->primary.file, NSC_MAXPATH);
1837 (void) strncpy(new_header.primary.bitmap,
1838 urdc->primary.bitmap, NSC_MAXPATH);
1839 }
1840
1841 bcopy(&new_header, &header, sizeof (rdc_header_t));
1842
1843 mutex_enter(&krdc->bmapmutex);
1844 if (rdc_write_header(krdc, &header) < 0) {
1845 mutex_exit(&krdc->bmapmutex);
1846 cmn_err(CE_WARN,
1847 "!rdc_resume_bitmap: Write header %s failed",
1848 bitmapname);
1849 goto fail;
1850 }
1851 mutex_exit(&krdc->bmapmutex);
1852
1853 } else if (header.magic == RDC_HDR_V3) {
1854 /*
1855 * just update asyncthr and magic, and then we're done
1856 */
1857 header.magic = RDC_HDR_MAGIC;
1858 header.asyncthr = RDC_ASYNCTHR;
1859 mutex_enter(&krdc->bmapmutex);
1860 if (rdc_write_header(krdc, &header) < 0) {
1861 mutex_exit(&krdc->bmapmutex);
1862 cmn_err(CE_WARN,
1863 "!rdc_resume_bitmap: Write header %s failed",
1864 bitmapname);
1865 goto fail;
1866 }
1867 mutex_exit(&krdc->bmapmutex);
1868 }
1869
1870 if (rdc_resume_state(krdc, &header) == 0)
1871 return (0);
1872
1873 rdc_close_bitmap(krdc);
1874
1875 fail:
1876 (void) RDC_FILL_BITMAP(krdc, FALSE);
1877 rdc_clr_flags(urdc, RDC_QUEUING);
1878 if (krdc->bitmap_ref)
1879 bzero(krdc->bitmap_ref, krdc->bitmap_size * BITS_IN_BYTE *
1880 rdc_refcntsize(krdc));
1881
1882 allocfail:
1883 mutex_enter(&krdc->bmapmutex);
1884 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "resume bitmap failed");
1885 mutex_exit(&krdc->bmapmutex);
1886
1887 return (-1);
1888 }
1889
1890 void
1891 rdc_std_zero_bitref(rdc_k_info_t *krdc)
1892 {
1893 nsc_size_t vol_size;
1894 int sts;
1895 size_t newrefcntsize;
1896
1897 if (krdc->bitmap_ref) {
1898 mutex_enter(&krdc->bmapmutex);
1899 bzero(krdc->bitmap_ref, krdc->bitmap_size * BITS_IN_BYTE *
1900 BMAP_REF_PREF_SIZE);
1901 if (RDC_IS_DISKQ(krdc->group) && rdc_refcntsize(krdc) !=
1902 BMAP_REF_PREF_SIZE) {
1903 /* see if we can upgrade the size of the ref counters */
1904 sts = _rdc_rsrv_devs(krdc, RDC_BMP, RDC_INTERNAL);
1905 if (!RDC_SUCCESS(sts)) {
1906 goto nochange;
1907 }
1908 sts = nsc_partsize(krdc->bitmapfd, &vol_size);
1909
1910 newrefcntsize = rdc_ref_size_possible(krdc->bitmap_size,
1911 vol_size);
1912 if (newrefcntsize > rdc_refcntsize(krdc)) {
1913 rdc_set_refcnt_ops(krdc, newrefcntsize);
1914 #ifdef DEBUG_REFCNT
1915 cmn_err(CE_NOTE, "!sndr: refcntsize %d - %d:%s",
1916 (int)rdc_refcntsize(krdc), __LINE__, __FILE__);
1917 #endif
1918 }
1919 nochange:
1920 _rdc_rlse_devs(krdc, RDC_BMP);
1921 }
1922 mutex_exit(&krdc->bmapmutex);
1923 }
1924 }
1925
1926 int
1927 rdc_reset_bitmap(rdc_k_info_t *krdc)
1928 {
1929 rdc_u_info_t *urdc;
1930 rdc_header_t header;
1931 char *bitmapname;
1932
1933 urdc = &rdc_u_info[krdc->index];
1934 if (rdc_get_vflags(urdc) & RDC_PRIMARY)
1935 bitmapname = &urdc->primary.bitmap[0];
1936 else
1937 bitmapname = &urdc->secondary.bitmap[0];
1938
1939 mutex_enter(&krdc->bmapmutex);
1940
1941 rdc_clr_flags(urdc, RDC_BMP_FAILED);
1942 if (rdc_read_header(krdc, &header) < 0) {
1943 cmn_err(CE_WARN,
1944 "!rdc_reset_bitmap: Read header %s failed", bitmapname);
1945 goto fail_with_mutex;
1946 }
1947
1948 rdc_fill_header(urdc, &header);
1949
1950 if (rdc_write_header(krdc, &header) < 0) {
1951 cmn_err(CE_WARN,
1952 "!rdc_reset_bitmap: Write header %s failed",
1953 bitmapname);
1954 goto fail_with_mutex;
1955 }
1956 mutex_exit(&krdc->bmapmutex);
1957
1958 if (krdc->bitmap_write == -1)
1959 krdc->bitmap_write = 0;
1960
1961 if (krdc->bitmap_write == 0) {
1962 if (rdc_write_bitmap_fill(krdc) < 0) {
1963 cmn_err(CE_WARN,
1964 "!rdc_reset_bitmap: Write bitmap %s failed",
1965 bitmapname);
1966 goto fail;
1967 }
1968 krdc->bitmap_write = -1;
1969 } else if (rdc_write_bitmap(krdc) < 0) {
1970 cmn_err(CE_WARN,
1971 "!rdc_reset_bitmap: Write bitmap %s failed",
1972 bitmapname);
1973 goto fail;
1974 }
1975
1976 return (0);
1977
1978 fail:
1979 mutex_enter(&krdc->bmapmutex);
1980 fail_with_mutex:
1981 rdc_set_flags_log(urdc, RDC_BMP_FAILED, "reset failed");
1982 mutex_exit(&krdc->bmapmutex);
1983 #ifdef DEBUG
1984 cmn_err(CE_NOTE, "!SNDR: unable to reset bitmap for %s:%s",
1985 urdc->secondary.intf, urdc->secondary.file);
1986 #endif
1987 return (-1);
1988 }
1989
1990
1991 /*
1992 * General bitmap operations
1993 */
1994
1995 /*
1996 * rdc_set_bitmap_many()
1997 *
1998 * Used during reverse syncs to a 1-to-many primary to keep the 'many'
1999 * bitmaps up to date.
2000 */
2001 void
2002 rdc_set_bitmap_many(rdc_k_info_t *krdc, nsc_off_t pos, nsc_size_t len)
2003 {
2004 uint_t dummy;
2005
2006 #ifdef DEBUG
2007 rdc_u_info_t *urdc = &rdc_u_info[krdc->index];
2008 if (!(rdc_get_vflags(urdc) & RDC_PRIMARY)) {
2009 cmn_err(CE_PANIC, "rdc_set_bitmap_many: not primary, urdc %p",
2010 (void *) urdc);
2011 }
2012 #endif
2013
2014 if (IS_MANY(krdc)) {
2015 rdc_k_info_t *krd;
2016 rdc_u_info_t *urd;
2017
2018 rdc_many_enter(krdc);
2019
2020 for (krd = krdc->many_next; krd != krdc; krd = krd->many_next) {
2021 urd = &rdc_u_info[krd->index];
2022 if (!IS_ENABLED(urd))
2023 continue;
2024 ASSERT(urd->flags & RDC_PRIMARY);
2025 (void) RDC_SET_BITMAP(krd, pos, len, &dummy);
2026 }
2027
2028 rdc_many_exit(krdc);
2029 }
2030 }
2031
2032
2033 static int
2034 _rdc_net_bmap(const struct bmap6 *b6, net_bdata6 *bd6)
2035 {
2036 rdc_k_info_t *krdc = &rdc_k_info[b6->cd];
2037 struct timeval t;
2038 int e, ret;
2039 uint64_t left;
2040 uint64_t bmap_blksize;
2041
2042 bmap_blksize = krdc->rpc_version < RDC_VERSION7 ?
2043 BMAP_BLKSIZE : BMAP_BLKSIZEV7;
2044
2045 t.tv_sec = rdc_rpc_tmout;
2046 t.tv_usec = 0;
2047
2048 if (bd6->data.data_val == NULL) {
2049 return (EINVAL);
2050 }
2051
2052 left = b6->size;
2053 bd6->endoblk = 0;
2054 while (left) {
2055 if (left >= bmap_blksize)
2056 bd6->size = (int)bmap_blksize;
2057 else
2058 bd6->size = (int)left;
2059
2060 bd6->data.data_len = bd6->size;
2061
2062 if ((uint64_t)bd6->size > left) {
2063 left = 0;
2064 } else {
2065 left -= bd6->size;
2066 }
2067 /*
2068 * mark the last block sent.
2069 */
2070 if (left == 0) {
2071 bd6->endoblk = 1;
2072 }
2073 ASSERT(krdc->rpc_version);
2074 if (krdc->rpc_version <= RDC_VERSION5) {
2075 struct net_bdata bd;
2076 bd.cd = bd6->cd;
2077 bd.offset = bd6->offset;
2078 bd.size = bd6->size;
2079 bd.data.data_len = bd6->data.data_len;
2080 bd.data.data_val = bd6->data.data_val;
2081 e = rdc_clnt_call(krdc->lsrv, RDCPROC_BDATA,
2082 krdc->rpc_version, xdr_net_bdata, (char *)&bd,
2083 xdr_int, (char *)&ret, &t);
2084 } else {
2085 e = rdc_clnt_call(krdc->lsrv, RDCPROC_BDATA6,
2086 krdc->rpc_version, xdr_net_bdata6, (char *)bd6,
2087 xdr_int, (char *)&ret, &t);
2088 }
2089 if (e || ret) {
2090 if (e)
2091 ret = e;
2092 return (ret);
2093 }
2094 bd6->offset += bmap_blksize;
2095 bd6->data.data_val += bmap_blksize;
2096 }
2097 return (0);
2098 }
2099
2100
2101 /*
2102 * Standard bitmap operations (combined kmem/disk bitmaps).
2103 */
2104
2105 /*
2106 * rdc_std_set_bitmask(pos, len, &bitmask)
2107 * set a bitmask for this range. used to clear the correct
2108 * bits after flushing
2109 */
2110 static void
2111 rdc_std_set_bitmask(const nsc_off_t fba_pos, const nsc_size_t fba_len,
2112 uint_t *bitmask)
2113 {
2114 int first, st, en;
2115 if (bitmask)
2116 *bitmask = 0;
2117 else
2118 return;
2119
2120 first = st = FBA_TO_LOG_NUM(fba_pos);
2121 en = FBA_TO_LOG_NUM(fba_pos + fba_len - 1);
2122 while (st <= en) {
2123 BMAP_BIT_SET((uchar_t *)bitmask, st - first);
2124 st++;
2125 }
2126
2127 }
2128 /*
2129 * rdc_std_set_bitmap(krdc, fba_pos, fba_len, &bitmask)
2130 *
2131 * Mark modified segments in the dual copy file bitmap
2132 * to provide fast recovery
2133 * Note that bitmask allows for 32 segments, which at 32k per segment equals
2134 * 1 megabyte. If we ever allow more than this to be transferred in one
2135 * operation, or decrease the segment size, then this code will have to be
2136 * changed accordingly.
2137 */
2138
2139 static int
2140 rdc_std_set_bitmap(rdc_k_info_t *krdc, const nsc_off_t fba_pos,
2141 const nsc_size_t fba_len, uint_t *bitmask)
2142 {
2143 int first, st, en;
2144 int fbaset = 0;
2145 nsc_off_t fba = 0;
2146 int printerr = 10;
2147 int tries = RDC_FUTILE_ATTEMPTS;
2148 int queuing = RDC_QUEUING;
2149 rdc_u_info_t *urdc;
2150
2151 if (bitmask)
2152 *bitmask = 0;
2153 else
2154 return (-1);
2155
2156 urdc = &rdc_u_info[krdc->index];
2157 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED)
2158 return (-1);
2159
2160 if (krdc->bitmap_write == 0) {
2161 if (rdc_write_bitmap_fill(krdc) < 0)
2162 return (-1);
2163 krdc->bitmap_write = -1;
2164 }
2165 first = st = FBA_TO_LOG_NUM(fba_pos);
2166 en = FBA_TO_LOG_NUM(fba_pos + fba_len - 1);
2167 ASSERT(st <= en);
2168 while (st <= en) {
2169 int use_ref;
2170 again:
2171 mutex_enter(&krdc->bmapmutex);
2172
2173 if (krdc->dcio_bitmap == NULL) {
2174 #ifdef DEBUG
2175 cmn_err(CE_WARN, "!rdc_std_set_bitmap: "
2176 "recovery bitmaps not allocated");
2177 #endif
2178 mutex_exit(&krdc->bmapmutex);
2179 return (-1);
2180 }
2181
2182 use_ref = IS_PRIMARY(urdc) && IS_ASYNC(urdc) &&
2183 ((rdc_get_vflags(urdc) & RDC_QUEUING) ||
2184 !(rdc_get_vflags(urdc) & RDC_LOGGING));
2185
2186
2187 if (!BMAP_BIT_ISSET(krdc->dcio_bitmap, st)) {
2188 BMAP_BIT_SET(krdc->dcio_bitmap, st);
2189 if (use_ref) {
2190 ASSERT(BMAP_REF_ISSET(krdc, st) ==
2191 0);
2192 BMAP_REF_FORCE(krdc, st, 1);
2193 }
2194 BMAP_BIT_SET((uchar_t *)bitmask, st - first);
2195 urdc->bits_set++;
2196 if ((!fbaset) || fba != BIT_TO_FBA(st)) {
2197 if (fbaset && krdc->bitmap_write > 0) {
2198 mutex_exit(&krdc->bmapmutex);
2199 if (rdc_write_bitmap_fba(krdc, fba) < 0)
2200 return (-1);
2201 mutex_enter(&krdc->bmapmutex);
2202 }
2203 fba = BIT_TO_FBA(st);
2204 fbaset = 1;
2205 }
2206 } else {
2207 /*
2208 * Just bump reference count
2209 * For logging or syncing we do not care what the reference
2210 * is as it will be forced back on the state transition.
2211 */
2212 if (use_ref) {
2213 if (BMAP_REF_ISSET(krdc, st) ==
2214 BMAP_REF_MAXVAL(krdc)) {
2215 /*
2216 * Rollover of reference count.
2217 */
2218
2219 if (!(rdc_get_vflags(urdc) &
2220 RDC_VOL_FAILED)) {
2221 /*
2222 * Impose throttle to help dump
2223 * queue
2224 */
2225 mutex_exit(&krdc->bmapmutex);
2226 delay(4);
2227 rdc_bitmap_delay++;
2228 if (printerr--) {
2229 cmn_err(CE_WARN, "!SNDR: bitmap reference count maxed out for %s:%s",
2230 urdc->secondary.intf, urdc->secondary.file);
2231
2232 }
2233
2234 if ((tries-- <= 0) &&
2235 IS_STATE(urdc, queuing)) {
2236 cmn_err(CE_WARN, "!SNDR: giving up on reference count, logging set"
2237 " %s:%s", urdc->secondary.intf, urdc->secondary.file);
2238 rdc_group_enter(krdc);
2239 rdc_group_log(krdc,
2240 RDC_NOFLUSH |
2241 RDC_NOREMOTE|
2242 RDC_FORCE_GROUP,
2243 "ref count retry limit exceeded");
2244 rdc_group_exit(krdc);
2245 }
2246 goto again;
2247 }
2248 } else {
2249 BMAP_REF_SET(krdc, st);
2250 }
2251 }
2252 }
2253 mutex_exit(&krdc->bmapmutex);
2254 st++;
2255 }
2256 if (fbaset && krdc->bitmap_write > 0) {
2257 if (rdc_write_bitmap_fba(krdc, fba) < 0)
2258 return (-1);
2259 }
2260 return (0);
2261 }
2262
2263 static void
2264 rdc_std_clr_bitmap(rdc_k_info_t *krdc, const nsc_off_t fba_pos,
2265 const nsc_size_t fba_len, const uint_t bitmask, const int force)
2266 {
2267 int first, st, en;
2268 nsc_off_t fba = 0;
2269 int fbaset = 0;
2270 uint_t bm = bitmask;
2271 uchar_t *ptr = (uchar_t *)&bm;
2272 rdc_u_info_t *urdc = &rdc_u_info[krdc->index];
2273
2274 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED)
2275 return;
2276
2277 first = st = FBA_TO_LOG_NUM(fba_pos);
2278 en = FBA_TO_LOG_NUM(fba_pos + fba_len - 1);
2279 ASSERT(st <= en);
2280 while (st <= en) {
2281 mutex_enter(&krdc->bmapmutex);
2282
2283 if (krdc->dcio_bitmap == NULL) {
2284 #ifdef DEBUG
2285 cmn_err(CE_WARN, "!rdc_std_clr_bitmap: "
2286 "recovery bitmaps not allocated");
2287 #endif
2288 mutex_exit(&krdc->bmapmutex);
2289 return;
2290 }
2291
2292 if (((bitmask == 0xffffffff) ||
2293 (BMAP_BIT_ISSET(ptr, st - first))) &&
2294 BMAP_BIT_ISSET(krdc->dcio_bitmap, st)) {
2295
2296 int use_ref = IS_PRIMARY(urdc) && IS_ASYNC(urdc) &&
2297 ((rdc_get_vflags(urdc) & RDC_QUEUING) ||
2298 !(rdc_get_vflags(urdc) & RDC_LOGGING));
2299
2300 if (force || (use_ref == 0)) {
2301 if (krdc->bitmap_ref)
2302 BMAP_REF_FORCE(krdc, st, 0);
2303 } else if (use_ref) {
2304 if (BMAP_REF_ISSET(krdc, st) != 0)
2305 BMAP_REF_CLR(krdc, st);
2306
2307 }
2308
2309 if ((use_ref == 0) || (use_ref &&
2310 !BMAP_REF_ISSET(krdc, st))) {
2311 BMAP_BIT_CLR(krdc->dcio_bitmap, st);
2312
2313 urdc->bits_set--;
2314 if (!fbaset || fba != BIT_TO_FBA(st)) {
2315 if (fbaset &&
2316 krdc->bitmap_write > 0) {
2317 mutex_exit(&krdc->bmapmutex);
2318 if (rdc_write_bitmap_fba(krdc,
2319 fba) < 0)
2320 return;
2321 mutex_enter(&krdc->bmapmutex);
2322 }
2323 fba = BIT_TO_FBA(st);
2324 fbaset = 1;
2325 }
2326 }
2327 }
2328 mutex_exit(&krdc->bmapmutex);
2329 st++;
2330 }
2331 if (fbaset && krdc->bitmap_write > 0) {
2332 if (rdc_write_bitmap_fba(krdc, fba) < 0)
2333 return;
2334 }
2335 }
2336
2337 /*
2338 * make sure that this bit is set. if it isn't, set it
2339 * used when transitioning from async to sync while going
2340 * from rep to log. an overlapping sync write may unconditionally
2341 * clear the bit that has not been replicated. when the queue
2342 * is being dumped or this is called just to make sure pending stuff
2343 * is in the bitmap
2344 */
2345 void
2346 rdc_std_check_bit(rdc_k_info_t *krdc, nsc_off_t pos, nsc_size_t len)
2347 {
2348 int st;
2349 int en;
2350 nsc_off_t fba;
2351 rdc_u_info_t *urdc = &rdc_u_info[krdc->index];
2352 st = FBA_TO_LOG_NUM(pos);
2353 en = FBA_TO_LOG_NUM(pos + len - 1);
2354
2355 if (rdc_get_vflags(urdc) & RDC_BMP_FAILED)
2356 return;
2357
2358 while (st <= en) {
2359 mutex_enter(&krdc->bmapmutex);
2360
2361 if (krdc->dcio_bitmap == NULL) {
2362 #ifdef DEBUG
2363 cmn_err(CE_WARN, "!rdc_std_check_bit: "
2364 "recovery bitmaps not allocated");
2365 #endif
2366 mutex_exit(&krdc->bmapmutex);
2367 return;
2368 }
2369
2370 if (!BMAP_BIT_ISSET(krdc->dcio_bitmap, st)) {
2371 BMAP_BIT_SET(krdc->dcio_bitmap, st);
2372 if (krdc->bitmap_write > 0) {
2373 fba = BIT_TO_FBA(st);
2374 mutex_exit(&krdc->bmapmutex);
2375 (void) rdc_write_bitmap_fba(krdc, fba);
2376 mutex_enter(&krdc->bmapmutex);
2377 }
2378 urdc->bits_set++;
2379
2380 }
2381 mutex_exit(&krdc->bmapmutex);
2382 st++;
2383 }
2384
2385 }
2386
2387 /*
2388 * rdc_std_count_dirty(krdc):
2389 *
2390 * Determine the number of segments that need to be flushed, This should
2391 * agree with the number of segments logged, but since we don't lock when
2392 * we increment, we force these values to agree
2393 */
2394 static int
2395 rdc_std_count_dirty(rdc_k_info_t *krdc)
2396 {
2397 rdc_u_info_t *urdc = &rdc_u_info[krdc->index];
2398 int i, count, size;
2399
2400 if (krdc->dcio_bitmap == NULL) {
2401 #ifdef DEBUG
2402 cmn_err(CE_WARN,
2403 "!rdc_std_count_dirty: no bitmap configured for %s",
2404 urdc->primary.file);
2405 #endif
2406 return (0);
2407 }
2408
2409 count = 0;
2410 ASSERT(urdc->volume_size != 0);
2411 size = FBA_TO_LOG_LEN(urdc->volume_size);
2412 for (i = 0; i < size; i++)
2413 if (BMAP_BIT_ISSET(krdc->dcio_bitmap, i))
2414 count++;
2415
2416 if (count > size)
2417 count = size;
2418
2419 return (count);
2420 }
2421
2422
2423 static int
2424 rdc_std_bit_isset(rdc_k_info_t *krdc, const int bit)
2425 {
2426 return (BMAP_BIT_ISSET(krdc->dcio_bitmap, bit));
2427 }
2428
2429
2430 /*
2431 * rdc_std_fill_bitmap(krdc, write)
2432 *
2433 * Called to force bitmaps to a fully dirty state
2434 */
2435 static int
2436 rdc_std_fill_bitmap(rdc_k_info_t *krdc, const int write)
2437 {
2438 rdc_u_info_t *urdc = &rdc_u_info[krdc->index];
2439 int i, size;
2440
2441 if (krdc->dcio_bitmap == NULL) {
2442 #ifdef DEBUG
2443 cmn_err(CE_WARN,
2444 "!rdc_std_fill_bitmap: no bitmap configured for %s",
2445 urdc->primary.file);
2446 #endif
2447 return (-1);
2448 }
2449
2450 ASSERT(urdc->volume_size != 0);
2451 size = FBA_TO_LOG_LEN(urdc->volume_size);
2452 for (i = 0; i < size; i++)
2453 BMAP_BIT_SET(krdc->dcio_bitmap, i);
2454
2455 urdc->bits_set = size;
2456
2457 if (write)
2458 return (rdc_write_bitmap(krdc));
2459
2460 return (0);
2461 }
2462
2463
2464 /*
2465 * rdc_std_zero_bitmap(krdc)
2466 *
2467 * Called on the secondary after a sync has completed to force bitmaps
2468 * to a fully clean state
2469 */
2470 static void
2471 rdc_std_zero_bitmap(rdc_k_info_t *krdc)
2472 {
2473 rdc_u_info_t *urdc = &rdc_u_info[krdc->index];
2474 int i, size;
2475
2476 if (krdc->dcio_bitmap == NULL) {
2477 #ifdef DEBUG
2478 cmn_err(CE_WARN,
2479 "!rdc_std_zero_bitmap: no bitmap configured for %s",
2480 urdc->primary.file);
2481 #endif
2482 return;
2483 }
2484 #ifdef DEBUG
2485 cmn_err(CE_NOTE, "!Clearing bitmap for %s", urdc->secondary.file);
2486 #endif
2487
2488 ASSERT(urdc->volume_size != 0);
2489 size = FBA_TO_LOG_LEN(urdc->volume_size);
2490 for (i = 0; i < size; i++)
2491 BMAP_BIT_CLR(krdc->dcio_bitmap, i);
2492 if (krdc->bitmap_write > 0)
2493 (void) rdc_write_bitmap(krdc);
2494
2495 urdc->bits_set = 0;
2496 }
2497
2498
2499 /*
2500 * rdc_std_net_bmap()
2501 *
2502 * WARNING acts as both client and server
2503 */
2504 static int
2505 rdc_std_net_bmap(const struct bmap6 *b)
2506 {
2507 rdc_k_info_t *krdc = &rdc_k_info[b->cd];
2508 struct net_bdata6 bd;
2509
2510 bd.data.data_val = (char *)krdc->dcio_bitmap;
2511 bd.cd = b->dual;
2512 bd.offset = 0;
2513
2514 return (_rdc_net_bmap(b, &bd));
2515 }
2516
2517
2518 /*
2519 * rdc_std_net_bdata
2520 */
2521 static int
2522 rdc_std_net_bdata(const struct net_bdata6 *bd)
2523 {
2524 rdc_k_info_t *krdc = &rdc_k_info[bd->cd];
2525
2526 rdc_lor((uchar_t *)bd->data.data_val,
2527 (uchar_t *)(((char *)krdc->dcio_bitmap) + bd->offset), bd->size);
2528
2529 return (0);
2530 }
2531
2532
2533 static struct rdc_bitmap_ops rdc_std_bitmap_ops = {
2534 rdc_std_set_bitmap,
2535 rdc_std_clr_bitmap,
2536 rdc_std_count_dirty,
2537 rdc_std_bit_isset,
2538 rdc_std_fill_bitmap,
2539 rdc_std_zero_bitmap,
2540 rdc_std_net_bmap,
2541 rdc_std_net_bdata,
2542 rdc_std_zero_bitref,
2543 rdc_std_set_bitmask,
2544 rdc_std_check_bit
2545 };
2546
2547
2548 void
2549 rdc_bitmap_init()
2550 {
2551 rdc_bitmap_ops = &rdc_std_bitmap_ops;
2552 rdc_wrflag = NSC_WRITE;
2553 }
2554
2555 static void
2556 rdc_bmap_ref_byte_set(rdc_k_info_t *krdc, int ind)
2557 {
2558 unsigned char *bmap = (unsigned char *)krdc->bitmap_ref;
2559
2560 ASSERT(BMAP_REF_SIZE(krdc) == sizeof (unsigned char));
2561 bmap[ind]++;
2562 }
2563
2564 static void
2565 rdc_bmap_ref_byte_clr(rdc_k_info_t *krdc, int ind)
2566 {
2567 unsigned char *bmap = (unsigned char *)krdc->bitmap_ref;
2568
2569 ASSERT(BMAP_REF_SIZE(krdc) == sizeof (unsigned char));
2570 bmap[ind]--;
2571 }
2572
2573 static unsigned int
2574 rdc_bmap_ref_byte_isset(rdc_k_info_t *krdc, int ind)
2575 {
2576 unsigned char *bmap = (unsigned char *)krdc->bitmap_ref;
2577
2578 ASSERT(BMAP_REF_SIZE(krdc) == sizeof (unsigned char));
2579 return ((unsigned int)(bmap[ind]));
2580 }
2581
2582 static void
2583 rdc_bmap_ref_byte_force(rdc_k_info_t *krdc, int ind, unsigned int val)
2584 {
2585 unsigned char *bmap = (unsigned char *)krdc->bitmap_ref;
2586
2587 ASSERT(BMAP_REF_SIZE(krdc) == sizeof (unsigned char));
2588 bmap[ind] = (unsigned char) val;
2589 }
2590
2591 /* ARGSUSED */
2592 static unsigned int
2593 rdc_bmap_ref_byte_maxval(rdc_k_info_t *krdc)
2594 {
2595 ASSERT(BMAP_REF_SIZE(krdc) == sizeof (unsigned char));
2596 return ((unsigned int)(UINT8_MAX));
2597 }
2598
2599 struct bm_ref_ops rdc_ref_byte_ops = {
2600 rdc_bmap_ref_byte_set,
2601 rdc_bmap_ref_byte_clr,
2602 rdc_bmap_ref_byte_isset,
2603 rdc_bmap_ref_byte_force,
2604 rdc_bmap_ref_byte_maxval,
2605 sizeof (unsigned char)
2606 };
2607
2608 static void
2609 rdc_bmap_ref_int_set(rdc_k_info_t *krdc, int ind)
2610 {
2611 unsigned int *bmap = (unsigned int *)krdc->bitmap_ref;
2612
2613 ASSERT(BMAP_REF_SIZE(krdc) == sizeof (unsigned int));
2614 bmap[ind]++;
2615 }
2616
2617 static void
2618 rdc_bmap_ref_int_clr(rdc_k_info_t *krdc, int ind)
2619 {
2620 unsigned int *bmap = (unsigned int *)krdc->bitmap_ref;
2621
2622 ASSERT(BMAP_REF_SIZE(krdc) == sizeof (unsigned int));
2623 bmap[ind]--;
2624 }
2625
2626 static unsigned int
2627 rdc_bmap_ref_int_isset(rdc_k_info_t *krdc, int ind)
2628 {
2629 unsigned int *bmap = (unsigned int *)krdc->bitmap_ref;
2630
2631 ASSERT(BMAP_REF_SIZE(krdc) == sizeof (unsigned int));
2632 return ((bmap[ind]));
2633 }
2634
2635 static void
2636 rdc_bmap_ref_int_force(rdc_k_info_t *krdc, int ind, unsigned int val)
2637 {
2638 unsigned int *bmap = (unsigned int *)krdc->bitmap_ref;
2639
2640 ASSERT(BMAP_REF_SIZE(krdc) == sizeof (unsigned int));
2641 bmap[ind] = val;
2642 }
2643
2644 /* ARGSUSED */
2645 static unsigned int
2646 rdc_bmap_ref_int_maxval(rdc_k_info_t *krdc)
2647 {
2648 ASSERT(BMAP_REF_SIZE(krdc) == sizeof (unsigned int));
2649 return ((unsigned int)(UINT_MAX));
2650 }
2651
2652 struct bm_ref_ops rdc_ref_int_ops = {
2653 rdc_bmap_ref_int_set,
2654 rdc_bmap_ref_int_clr,
2655 rdc_bmap_ref_int_isset,
2656 rdc_bmap_ref_int_force,
2657 rdc_bmap_ref_int_maxval,
2658 sizeof (unsigned int)
2659 };