2 * Soft: Description here...
4 * Version: $Id: main.h,v 0.0.1 2003/09/18 15:13:38 cvaroqui Exp $
6 * Author: Copyright (C) 2003 Christophe Varoqui
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11 * See the GNU General Public License for more details.
13 * This program is free software; you can redistribute it and/or
14 * modify it under the terms of the GNU General Public License
15 * as published by the Free Software Foundation; either version
16 * 2 of the License, or (at your option) any later version.
23 #include <sys/types.h>
25 #include <linux/kdev_t.h>
28 #include <sys/ioctl.h>
30 #include <libdevmapper.h>
34 do_inq(int sg_fd, int cmddt, int evpd, unsigned int pg_op,
35 void *resp, int mx_resp_len, int noisy)
38 unsigned char inqCmdBlk[INQUIRY_CMDLEN] =
39 { INQUIRY_CMD, 0, 0, 0, 0, 0 };
40 unsigned char sense_b[SENSE_BUFF_LEN];
41 struct sg_io_hdr io_hdr;
47 inqCmdBlk[2] = (unsigned char) pg_op;
48 inqCmdBlk[4] = (unsigned char) mx_resp_len;
49 memset(&io_hdr, 0, sizeof (struct sg_io_hdr));
50 io_hdr.interface_id = 'S';
51 io_hdr.cmd_len = sizeof (inqCmdBlk);
52 io_hdr.mx_sb_len = sizeof (sense_b);
53 io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
54 io_hdr.dxfer_len = mx_resp_len;
56 io_hdr.cmdp = inqCmdBlk;
58 io_hdr.timeout = DEF_TIMEOUT;
60 if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) {
61 perror("SG_IO (inquiry) error");
64 res = sg_err_category3(&io_hdr);
66 case SG_ERR_CAT_CLEAN:
67 case SG_ERR_CAT_RECOVERED:
77 unsigned char turCmdBlk[TUR_CMD_LEN] = { 0x00, 0, 0, 0, 0, 0 };
78 struct sg_io_hdr io_hdr;
79 unsigned char sense_buffer[32];
81 memset(&io_hdr, 0, sizeof (struct sg_io_hdr));
82 io_hdr.interface_id = 'S';
83 io_hdr.cmd_len = sizeof (turCmdBlk);
84 io_hdr.mx_sb_len = sizeof (sense_buffer);
85 io_hdr.dxfer_direction = SG_DXFER_NONE;
86 io_hdr.cmdp = turCmdBlk;
87 io_hdr.sbp = sense_buffer;
88 io_hdr.timeout = 20000;
90 if (ioctl(fd, SG_IO, &io_hdr) < 0) {
94 if (io_hdr.info & SG_INFO_OK_MASK) {
101 sprint_wwid(char * buff, const char * str)
110 for (i = 0; i <= WWID_SIZE / 2 - 1; i++) {
112 sprintf(cursor, "%.2x", (int) (unsigned char) c);
115 buff[WWID_SIZE - 1] = '\0';
119 get_lun_strings(int fd, struct path * mypath)
123 if (0 == do_inq(fd, 0, 0, 0, buff, 36, 1)) {
124 memcpy(mypath->vendor_id, &buff[8], 8);
125 memcpy(mypath->product_id, &buff[16], 16);
126 memcpy(mypath->rev, &buff[32], 4);
134 get_serial (int fd, char * str)
136 char buff[MX_ALLOC_LEN + 1];
139 if (0 == do_inq(fd, 0, 1, 0x80, buff, MX_ALLOC_LEN, 0)) {
142 memcpy(str, buff + 4, len);
151 /* hardware vendor specifics : add support for new models below */
153 get_storageworks_wwid(int fd, char *str)
157 if (0 == do_inq(fd, 0, 1, 0x83, buff, sizeof (buff), 1)) {
158 sprint_wwid(str, &buff[8]);
164 /* White list switch */
166 get_unique_id(int fd, struct path * mypath)
168 if (strncmp(mypath->product_id, "HSV110 (C)COMPAQ", 16) == 0 ||
169 strncmp(mypath->product_id, "HSG80 ", 16) == 0) {
170 get_storageworks_wwid(fd, mypath->wwid);
178 basename(char * str1, char * str2)
180 char *p = str1 + (strlen(str1) - 1);
188 get_all_paths_sysfs(struct env * conf, struct path * all_paths)
192 struct sysfs_directory * sdir;
193 struct sysfs_directory * devp;
194 struct sysfs_dlink * linkp;
195 char buff[FILE_NAME_SIZE];
197 char block_path[FILE_NAME_SIZE];
199 sprintf(block_path, "%s/block", conf->sysfs_path);
200 sdir = sysfs_open_directory(block_path);
201 sysfs_read_directory(sdir);
202 devp = sdir->subdirs;
203 while (devp != NULL) {
204 sysfs_read_directory(devp);
206 while (linkp != NULL) {
207 if (!strncmp(linkp->name, "device", 6))
216 basename(devp->path, buff);
217 sprintf(all_paths[k].sg_dev, "/dev/%s", buff);
218 strcpy(all_paths[k].dev, all_paths[k].sg_dev);
219 if ((sg_fd = open(all_paths[k].sg_dev, O_RDONLY)) < 0) {
223 get_lun_strings(sg_fd, &all_paths[k]);
224 get_unique_id(sg_fd, &all_paths[k]);
225 all_paths[k].state = do_tur(sg_fd);
227 basename(linkp->target->path, buff);
228 sscanf(buff, "%i:%i:%i:%i",
229 &all_paths[k].sg_id.host_no,
230 &all_paths[k].sg_id.channel,
231 &all_paths[k].sg_id.scsi_id,
232 &all_paths[k].sg_id.lun);
236 sysfs_close_directory(sdir);
242 get_all_paths_nosysfs(struct env * conf, struct path * all_paths,
243 struct scsi_dev * all_scsi_ids)
246 char buff[FILE_NAME_SIZE];
247 char file_name[FILE_NAME_SIZE];
249 for (k = 0; k < conf->max_devs; k++) {
250 strcpy(file_name, "/dev/sg");
251 sprintf(buff, "%d", k);
252 strncat(file_name, buff, FILE_NAME_SIZE);
253 strcpy(all_paths[k].sg_dev, file_name);
254 if ((sg_fd = open(file_name, O_RDONLY)) < 0)
256 get_lun_strings(sg_fd, &all_paths[k]);
257 get_unique_id(sg_fd, &all_paths[k]);
258 all_paths[k].state = do_tur(sg_fd);
259 if (0 > ioctl(sg_fd, SG_GET_SCSI_ID, &(all_paths[k].sg_id)))
260 printf("device %s failed on sg ioctl, skip\n",
265 for (i = 0; i < conf->max_devs; i++) {
266 if ((all_paths[k].sg_id.host_no ==
267 all_scsi_ids[i].host_no)
268 && (all_paths[k].sg_id.scsi_id ==
269 (all_scsi_ids[i].scsi_id.dev_id & 0xff))
270 && (all_paths[k].sg_id.lun ==
271 ((all_scsi_ids[i].scsi_id.dev_id >> 8) & 0xff))
272 && (all_paths[k].sg_id.channel ==
273 ((all_scsi_ids[i].scsi_id.
274 dev_id >> 16) & 0xff))) {
275 strcpy(all_paths[k].dev, all_scsi_ids[i].dev);
284 get_all_scsi_ids(struct env * conf, struct scsi_dev * all_scsi_ids)
286 int k, big, little, res, host_no, fd;
288 char fname[FILE_NAME_SIZE];
289 struct scsi_idlun my_scsi_id;
291 for (k = 0; k < conf->max_devs; k++) {
292 strcpy(fname, "/dev/sd");
294 buff[0] = 'a' + (char) k;
297 } else if (k <= 255) { /* assumes sequence goes x,y,z,aa,ab,ac etc */
299 little = k - (26 * big);
302 buff[0] = 'a' + (char) big;
303 buff[1] = 'a' + (char) little;
307 strcat(fname, "xxxx");
309 if ((fd = open(fname, O_RDONLY)) < 0)
312 res = ioctl(fd, SCSI_IOCTL_GET_IDLUN, &my_scsi_id);
315 printf("Could not get scsi idlun\n");
319 res = ioctl(fd, SCSI_IOCTL_GET_BUS_NUMBER, &host_no);
322 printf("Could not get host_no\n");
328 strcpy(all_scsi_ids[k].dev, fname);
329 all_scsi_ids[k].scsi_id = my_scsi_id;
330 all_scsi_ids[k].host_no = host_no;
335 /* print_path style */
340 print_path(struct path * all_paths, int k, int style)
343 printf("%s ", all_paths[k].wwid);
346 printf("(%i %i %i %i) ",
347 all_paths[k].sg_id.host_no,
348 all_paths[k].sg_id.channel,
349 all_paths[k].sg_id.scsi_id, all_paths[k].sg_id.lun);
350 printf("%s ", all_paths[k].sg_dev);
351 printf("op:%i ", all_paths[k].state);
352 printf("%s ", all_paths[k].dev);
353 printf("[%.16s]\n", all_paths[k].product_id);
357 print_all_path(struct env * conf, struct path * all_paths)
360 char empty_buff[WWID_SIZE];
362 memset(empty_buff, 0, WWID_SIZE);
363 for (k = 0; k < conf->max_devs; k++) {
364 if (memcmp(empty_buff, all_paths[k].wwid, WWID_SIZE) == 0)
366 print_path(all_paths, k, ALL);
371 print_all_mp(struct path * all_paths, struct multipath * mp, int nmp)
375 for (k = 0; k <= nmp; k++) {
376 printf("%s\n", mp[k].wwid);
377 for (i = 0; i <= mp[k].npaths; i++)
378 print_path(all_paths, PINDEX(k,i), NOWWID);
383 coalesce_paths(struct env * conf, struct multipath * mp,
384 struct path * all_paths)
386 int k, i, nmp, np, already_done;
387 char empty_buff[WWID_SIZE];
391 memset(empty_buff, 0, WWID_SIZE);
393 for (k = 0; k < conf->max_devs - 1; k++) {
394 /* skip this path if no unique id has been found */
395 if (memcmp(empty_buff, all_paths[k].wwid, WWID_SIZE) == 0)
399 for (i = 0; i <= nmp; i++) {
400 if (0 == strcmp(mp[i].wwid, all_paths[k].wwid))
410 strcpy(mp[nmp].wwid, all_paths[k].wwid);
413 for (i = k + 1; i < conf->max_devs; i++) {
414 if (0 == strcmp(all_paths[k].wwid, all_paths[i].wwid)) {
425 get_disk_size (struct env * conf, char * dev) {
428 char attr_path[FILE_NAME_SIZE];
429 char buff[FILE_NAME_SIZE];
430 char basedev[FILE_NAME_SIZE];
432 if(conf->with_sysfs) {
433 basename(dev, basedev);
434 sprintf(attr_path, "%s/block/%s/size",
435 conf->sysfs_path, basedev);
436 if (0 > sysfs_read_attribute_value(attr_path, buff,
437 FILE_NAME_SIZE * sizeof(char)))
442 if ((fd = open(dev, O_RDONLY)) < 0)
444 if(!ioctl(fd, BLKGETSIZE, &size))
451 make_dm_node(char * str)
455 char buff[FILE_NAME_SIZE];
457 struct dm_names * names;
461 if (!(dmt = dm_task_create(DM_DEVICE_LIST)))
464 if (!dm_task_run(dmt))
467 if (!(names = dm_task_get_names(dmt)))
476 if (0 == strcmp(names->name, str))
479 names = (void *) names + next;
482 major = (int) MAJOR(names->dev);
483 minor = (int) MINOR(names->dev);
485 dev = major << sizeof(dev_t);
487 sprintf(buff, "/dev/mapper/%s", str);
489 mknod(buff, 0600 | S_IFBLK, dev);
492 dm_task_destroy(dmt);
499 del_map(char * str) {
502 if (!(dmt = dm_task_create(DM_DEVICE_REMOVE)))
504 if (!dm_task_set_name(dmt, str))
506 if (!dm_task_run(dmt))
509 printf("Deleted device map : %s\n", str);
512 dm_task_destroy(dmt);
518 add_map(struct env * conf, struct path * all_paths,
519 struct multipath * mp, int index, int op)
527 if (!(dmt = dm_task_create(op)))
530 if (!dm_task_set_name(dmt, mp[index].wwid))
532 params_p = ¶ms[0];
535 for (i=0; i<=mp[index].npaths; i++) {
536 if ((1 == all_paths[PINDEX(index,i)].state) &&
537 (0 == all_paths[PINDEX(index,i)].sg_id.scsi_type))
542 params_p += sprintf(params_p, "%i 32", np);
544 for (i=0; i<=mp[index].npaths; i++) {
545 if (( 0 == all_paths[PINDEX(index,i)].state) ||
546 (0 != all_paths[PINDEX(index,i)].sg_id.scsi_type))
549 size = get_disk_size(conf, all_paths[PINDEX(index,0)].dev);
550 params_p += sprintf(params_p, " %s %i",
551 all_paths[PINDEX(index,i)].dev, 0);
558 if (op == DM_DEVICE_RELOAD)
560 if (op == DM_DEVICE_CREATE)
562 printf("%s : 0 %li %s %s\n",
563 mp[index].wwid, size, DM_TARGET, params);
566 if (!dm_task_add_target(dmt, 0, size, DM_TARGET, params))
569 if (!dm_task_run(dmt))
573 make_dm_node(mp[index].wwid);
576 dm_task_destroy(dmt);
582 get_table(const char * str)
587 uint64_t start, length;
588 char *target_type = NULL;
591 if (!(dmt = dm_task_create(DM_DEVICE_TABLE)))
594 if (!dm_task_set_name(dmt, str))
597 if (!dm_task_run(dmt))
601 next = dm_get_next_target(dmt, next, &start, &length,
602 &target_type, ¶ms);
604 printf("%" PRIu64 " %" PRIu64 " %s %s\n",
605 start, length, target_type, params);
612 dm_task_destroy(dmt);
619 map_present(char * str)
623 struct dm_names *names;
626 if (!(dmt = dm_task_create(DM_DEVICE_LIST)))
629 if (!dm_task_run(dmt))
632 if (!(names = dm_task_get_names(dmt)))
640 if (0 == strcmp(names->name, str))
643 names = (void *) names + next;
647 dm_task_destroy(dmt);
652 usage(char * progname)
654 fprintf(stderr, VERSION_STRING);
655 fprintf(stderr, "Usage: %s [-v|-q] [-d] [-m max_devs]\n", progname);
656 fprintf(stderr, "\t-v\t\tverbose, print all paths and multipaths\n");
657 fprintf(stderr, "\t-q\t\tquiet, no output at all\n");
658 fprintf(stderr, "\t-d\t\tdry run, do not create or update devmaps\n");
659 fprintf(stderr, "\t-m max_devs\tscan {max_devs} devices at most\n");
664 main(int argc, char *argv[])
666 struct multipath * mp;
667 struct path * all_paths;
668 struct scsi_dev * all_scsi_ids;
672 /* Default behaviour */
673 conf.max_devs = MAX_DEVS;
674 conf.dry_run = 0; /* 1 == Do not Create/Update devmaps */
675 conf.verbose = 0; /* 1 == Print all_paths and mp */
676 conf.quiet = 0; /* 1 == Do not even print devmaps */
677 conf.with_sysfs = 0; /* Default to compat / suboptimal behaviour */
679 /* kindly provided by libsysfs */
680 if (0 == sysfs_get_mnt_path(conf.sysfs_path, FILE_NAME_SIZE))
683 for (i = 1; i < argc; ++i) {
684 if (0 == strcmp("-v", argv[i])) {
688 } else if (0 == strcmp("-m", argv[i])) {
689 conf.max_devs = atoi(argv[++i]);
690 if (conf.max_devs < 2)
692 } else if (0 == strcmp("-q", argv[i])) {
693 if (conf.verbose == 1)
696 } else if (0 == strcmp("-d", argv[i]))
698 else if (*argv[i] == '-') {
699 fprintf(stderr, "Unknown switch: %s\n", argv[i]);
701 } else if (*argv[i] != '-') {
702 fprintf(stderr, "Unknown argument\n");
708 /* dynamic allocations */
709 mp = malloc(conf.max_devs * sizeof(struct multipath));
710 all_paths = malloc(conf.max_devs * sizeof(struct path));
711 all_scsi_ids = malloc(conf.max_devs * sizeof(struct scsi_dev));
712 if (mp == NULL || all_paths == NULL || all_scsi_ids == NULL)
715 if (!conf.with_sysfs) {
716 get_all_scsi_ids(&conf, all_scsi_ids);
717 get_all_paths_nosysfs(&conf, all_paths, all_scsi_ids);
719 get_all_paths_sysfs(&conf, all_paths);
721 nmp = coalesce_paths(&conf, mp, all_paths);
724 print_all_path(&conf, all_paths);
726 print_all_mp(all_paths, mp, nmp);
733 for (k=0; k<=nmp; k++) {
734 if (map_present(mp[k].wwid)) {
735 add_map(&conf, all_paths, mp, k, DM_DEVICE_RELOAD);
737 add_map(&conf, all_paths, mp, k, DM_DEVICE_CREATE);