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 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <sys/dkio.h>
29 #include <sys/vtoc.h>
30 #include <sys/mkdev.h>
31 #ifdef DKIOCPARTITION
32 #include <sys/efi_partition.h>
33 #endif
34 #include <strings.h>
35 #include <stdarg.h>
36 #include <stdlib.h>
37 #include <fcntl.h>
38 #include <errno.h>
39 #include <stdio.h>
40 #include <locale.h>
41 #include <unistd.h>
42 #include <libgen.h>
43 #include <kstat.h>
44
45 #include <sys/unistat/spcs_s.h>
46 #include <sys/unistat/spcs_s_u.h>
47 #include <sys/unistat/spcs_errors.h>
48
49 #include <sys/nsctl/dsw.h>
50 #include <sys/nsctl/dsw_dev.h>
51 #include <sys/nsctl/rdc_io.h>
52 #include <sys/nsctl/rdc_bitmap.h>
53
54 enum { UNKNOWN = 0, SNDR, II };
55
56 static char *program;
57
58 void
59 usage(void)
60 {
61 (void) printf(gettext("usage: %s -h\n"), program);
62 (void) printf(gettext(" %s { -p | -r } data_volume "
63 "[bitmap_volume]\n"), program);
64 (void) printf(gettext(" -h : This usage message\n"));
65 (void) printf(gettext(" -p : Calculate size of Point in Time "
66 "bitmap\n"));
67 (void) printf(gettext(" -r : Calculate size of Remote Mirror "
68 "bitmap\n"));
69 }
70
71
72 static void
73 message(char *prefix, spcs_s_info_t *status, caddr_t string, va_list ap)
74 {
75 (void) fprintf(stderr, "%s: %s: ", program, prefix);
76 (void) vfprintf(stderr, string, ap);
77 (void) fprintf(stderr, "\n");
78
79 if (status) {
80 spcs_s_report(*status, stderr);
81 spcs_s_ufree(status);
82 }
83 }
84
85
86 static void
87 error(spcs_s_info_t *status, char *string, ...)
88 {
89 va_list ap;
90 va_start(ap, string);
91
92 message(gettext("error"), status, string, ap);
93 va_end(ap);
94 exit(1);
95 }
96
97
98 static void
99 warn(spcs_s_info_t *status, char *string, ...)
100 {
101 va_list ap;
102 va_start(ap, string);
103
104 message(gettext("warning"), status, string, ap);
105 va_end(ap);
106 }
107
108 #if defined(_LP64)
109 /* max value of a "long int" */
110 #define ULONG_MAX 18446744073709551615UL
111 #else /* _ILP32 */
112 #define ULONG_MAX 4294967295UL /* max of "unsigned long int" */
113 #endif
114
115 static uint64_t
116 get_partsize(char *partition)
117 {
118 #ifdef DKIOCPARTITION
119 struct dk_cinfo dki_info;
120 struct partition64 p64;
121 #endif
122 struct vtoc vtoc;
123 uint64_t size;
124 int fd;
125 int rc;
126
127 if ((fd = open(partition, O_RDONLY)) < 0) {
128 error(NULL, gettext("unable to open partition, %s: %s"),
129 partition, strerror(errno));
130 /* NOTREACHED */
131 }
132
133 rc = read_vtoc(fd, &vtoc);
134 if (rc >= 0) {
135 size = (uint64_t)(ULONG_MAX & vtoc.v_part[rc].p_size);
136 return (size);
137 }
138 #ifdef DKIOCPARTITION
139 else if (rc != VT_ENOTSUP) {
140 #endif
141 error(NULL,
142 gettext("unable to read the vtoc from partition, %s: %s"),
143 partition, strerror(errno));
144 /* NOTREACHED */
145 #ifdef DKIOCPARTITION
146 }
147
148 /* See if there is an EFI label */
149 rc = ioctl(fd, DKIOCINFO, &dki_info);
150 if (rc < 0) {
151 error(NULL, gettext("unable to get controller info "
152 "from partition, %s: %s"),
153 partition, strerror(errno));
154 /* NOTREACHED */
155 }
156
157 bzero(&p64, sizeof (p64));
158 p64.p_partno = (uint_t)dki_info.dki_partition;
159 rc = ioctl(fd, DKIOCPARTITION, &p64);
160 if (rc >= 0) {
161 size = (uint64_t)p64.p_size;
162 return (size);
163 } else {
164 struct stat64 stb1, stb2;
165 struct dk_minfo dkm;
166
167 /*
168 * See if the stat64 for ZFS's zvol matches
169 * this file descriptor's fstat64 data.
170 */
171 if (stat64("/devices/pseudo/zfs@0:zfs", &stb1) != 0 ||
172 fstat64(fd, &stb2) != 0 ||
173 !S_ISCHR(stb1.st_mode) ||
174 !S_ISCHR(stb2.st_mode) ||
175 major(stb1.st_rdev) != major(stb2.st_rdev)) {
176 error(NULL,
177 gettext("unable to read disk partition, %s: %s"),
178 partition, strerror(errno));
179 /* NOTREACHED */
180 }
181
182 rc = ioctl(fd, DKIOCGMEDIAINFO, (void *)&dkm);
183 if (rc >= 0) {
184 size = LE_64(dkm.dki_capacity) *
185 dkm.dki_lbsize / 512;
186 return (size);
187 } else {
188 error(NULL, gettext("unable to read EFI label "
189 "from partition, %s: %s"),
190 partition, strerror(errno));
191 /* NOTREACHED */
192 }
193 }
194 return (size);
195
196 #endif /* DKIOCPARTITION */
197 }
198
199
200 int
201 do_sndr(char *volume, char *bitmap)
202 {
203 uint64_t vblocks;
204 uint64_t bblocks;
205 uint64_t bsize_bits; /* size of the bits alone */
206 uint64_t bsize_simple; /* size of the simple bitmap */
207 uint64_t bsize_diskq; /* size of the diskq bitmap, 8 bit refcnt */
208 uint64_t bsize_diskq32; /* size of the diskq bitmap, 32 bit refcnt */
209 int rc = 0;
210
211 vblocks = get_partsize(volume);
212 if (bitmap) {
213 bblocks = get_partsize(bitmap);
214 }
215
216 bsize_bits = BMAP_LOG_BYTES(vblocks);
217 bsize_bits = (bsize_bits + 511) / 512;
218
219 bsize_simple = RDC_BITMAP_FBA + bsize_bits;
220 bsize_diskq = RDC_BITMAP_FBA + bsize_bits + (BITS_IN_BYTE * bsize_bits);
221 bsize_diskq32 = RDC_BITMAP_FBA + bsize_bits + (BITS_IN_BYTE *
222 bsize_bits * sizeof (unsigned int));
223
224 (void) printf(gettext("Remote Mirror bitmap sizing\n\n"));
225 (void) printf(gettext("Data volume (%s) size: %llu blocks\n"),
226 volume, vblocks);
227
228 (void) printf(gettext("Required bitmap volume size:\n"));
229 (void) printf(gettext(" Sync replication: %llu blocks\n"),
230 bsize_simple);
231 (void) printf(gettext(" Async replication with memory queue: "
232 "%llu blocks\n"), bsize_simple);
233 (void) printf(gettext(" Async replication with disk queue: "
234 "%llu blocks\n"), bsize_diskq);
235 (void) printf(gettext(" Async replication with disk queue and 32 bit "
236 "refcount: %llu blocks\n"), bsize_diskq32);
237
238 if (bitmap) {
239 (void) printf("\n");
240 (void) printf(gettext("Supplied bitmap volume %s "
241 "(%llu blocks)\n"),
242 bitmap, bblocks);
243 if (bblocks >= bsize_diskq32) {
244 (void) printf(gettext("is large enough for all "
245 "replication modes\n"));
246 } else if (bblocks >= bsize_diskq) {
247 (void) printf(gettext("is large enough for all "
248 "replication modes, but with restricted diskq "
249 "reference counts\n"));
250 } else if (bblocks >= bsize_simple) {
251 (void) printf(gettext(
252 "is large enough for: Sync and Async(memory) "
253 "replication modes only\n"));
254 rc = 3;
255 } else {
256 (void) printf(gettext(
257 "is not large enough for any replication modes\n"));
258 rc = 4;
259 }
260 }
261
262 return (rc);
263 }
264
265
266 /* sizes in bytes */
267 #define KILO (1024)
268 #define MEGA (KILO * KILO)
269 #define GIGA (MEGA * KILO)
270 #define TERA ((uint64_t)((uint64_t)GIGA * (uint64_t)KILO))
271
272 /* rounding function */
273 #define roundup_2n(x, y) (((x) + ((y) - 1)) & (~y))
274
275 int
276 do_ii(char *volume, char *bitmap)
277 {
278 const uint64_t int64_bits = sizeof (uint64_t) * BITS_IN_BYTE;
279 const uint64_t int32_bits = sizeof (uint32_t) * BITS_IN_BYTE;
280 const uint64_t terablocks = TERA / ((uint64_t)FBA_SIZE(1));
281 uint64_t vblocks_phys, vblocks;
282 uint64_t bblocks;
283 uint64_t bsize_ind; /* indep and dep not compact */
284 uint64_t bsize_cdep; /* compact dep */
285 int rc = 0;
286
287 vblocks_phys = get_partsize(volume);
288 if (bitmap) {
289 bblocks = get_partsize(bitmap);
290 }
291
292 /* round up to multiple of DSW_SIZE blocks */
293 vblocks = roundup_2n(vblocks_phys, DSW_SIZE);
294 bsize_ind = DSW_SHD_BM_OFFSET + (2 * DSW_BM_FBA_LEN(vblocks));
295 bsize_cdep = bsize_ind;
296 bsize_cdep += DSW_BM_FBA_LEN(vblocks) *
297 ((vblocks < (uint64_t)(terablocks * DSW_SIZE)) ?
298 int32_bits : int64_bits);
299
300 (void) printf(gettext("Point in Time bitmap sizing\n\n"));
301 (void) printf(gettext("Data volume (%s) size: %llu blocks\n"),
302 volume, vblocks_phys);
303
304 (void) printf(gettext("Required bitmap volume size:\n"));
305 (void) printf(gettext(" Independent shadow: %llu blocks\n"),
306 bsize_ind);
307 (void) printf(gettext(" Full size dependent shadow: %llu blocks\n"),
308 bsize_ind);
309 (void) printf(gettext(" Compact dependent shadow: %llu blocks\n"),
310 bsize_cdep);
311
312 if (bitmap) {
313 (void) printf("\n");
314 (void) printf(gettext("Supplied bitmap volume %s "
315 "(%llu blocks)\n"), bitmap, bblocks);
316
317 if (bblocks >= bsize_cdep) {
318 (void) printf(gettext("is large enough for all types "
319 "of shadow volume\n"));
320 } else if (bblocks >= bsize_ind) {
321 (void) printf(gettext("is large enough for: "
322 "Independent and full size dependent shadow "
323 "volumes only\n"));
324 rc = 6;
325 } else {
326 (void) printf(gettext("is not large enough for"
327 "any type of shadow volume\n"));
328 rc = 5;
329 }
330 }
331
332 return (rc);
333 }
334
335
336 /*
337 * Return codes:
338 * 0 success (if bitmap was supplied it is large enough for all uses)
339 * 1 usage, programing, or access errors
340 * 2 unknown option supplied on command line
341 * 3 SNDR bitmap is not large enough for diskq usage
342 * 4 SNDR bitmap is not large enough for any usage
343 * 5 II bitmap is not large enough for any usage
344 * 6 II bitmap is not large enough for compact dependent usage
345 */
346 int
347 main(int argc, char *argv[])
348 {
349 extern int optind;
350 char *volume, *bitmap;
351 int type = UNKNOWN;
352 int opt;
353 int rc = 0;
354
355 (void) setlocale(LC_ALL, "");
356 (void) textdomain("dsbitmap");
357
358 program = strdup(basename(argv[0]));
359
360 while ((opt = getopt(argc, argv, "hpr")) != EOF) {
361 switch (opt) {
362 case 'p':
363 if (type != UNKNOWN) {
364 warn(NULL, gettext(
365 "cannot specify -p with other options"));
366 usage();
367 return (1);
368 }
369 type = II;
370 break;
371
372 case 'r':
373 if (type != UNKNOWN) {
374 warn(NULL, gettext(
375 "cannot specify -r with other options"));
376 usage();
377 return (1);
378 }
379 type = SNDR;
380 break;
381
382 case 'h':
383 if (argc != 2) {
384 warn(NULL, gettext(
385 "cannot specify -h with other options"));
386 rc = 1;
387 }
388 usage();
389 return (rc);
390 /* NOTREACHED */
391
392 default:
393 usage();
394 return (2);
395 /* NOTREACHED */
396 }
397 }
398
399 if (type == UNKNOWN) {
400 warn(NULL, gettext("one of -p and -r must be specified"));
401 usage();
402 return (1);
403 }
404
405 if ((argc - optind) != 1 && (argc - optind) != 2) {
406 warn(NULL, gettext("incorrect number of arguments to %s"),
407 (type == SNDR) ? "-r" : "-p");
408 usage();
409 return (1);
410 }
411
412 volume = argv[optind];
413 if ((argc - optind) == 2) {
414 bitmap = argv[optind+1];
415 } else {
416 bitmap = NULL;
417 }
418
419 switch (type) {
420 case SNDR:
421 rc = do_sndr(volume, bitmap);
422 break;
423
424 case II:
425 rc = do_ii(volume, bitmap);
426 break;
427
428 default:
429 /* cannot happen */
430 warn(NULL, gettext("one of -p and -r must be specified"));
431 rc = 1;
432 break;
433 }
434
435 return (rc);
436 }