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>
27 #include <sys/ioctl.h>
29 #include "libdevmapper/libdevmapper.h"
33 do_inq(int sg_fd, int cmddt, int evpd, unsigned int pg_op,
34 void *resp, int mx_resp_len, int noisy)
36 unsigned char inqCmdBlk[INQUIRY_CMDLEN] =
37 { INQUIRY_CMD, 0, 0, 0, 0, 0 };
38 unsigned char sense_b[SENSE_BUFF_LEN];
39 struct sg_io_hdr io_hdr;
45 inqCmdBlk[2] = (unsigned char) pg_op;
46 inqCmdBlk[4] = (unsigned char) mx_resp_len;
47 memset(&io_hdr, 0, sizeof (struct sg_io_hdr));
48 io_hdr.interface_id = 'S';
49 io_hdr.cmd_len = sizeof (inqCmdBlk);
50 io_hdr.mx_sb_len = sizeof (sense_b);
51 io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
52 io_hdr.dxfer_len = mx_resp_len;
54 io_hdr.cmdp = inqCmdBlk;
56 io_hdr.timeout = DEF_TIMEOUT;
58 if (ioctl(sg_fd, SG_IO, &io_hdr) < 0) {
59 perror("SG_IO (inquiry) error");
63 /* treat SG_ERR here to get rid of sg_err.[ch] */
64 io_hdr.status &= 0x7e;
65 if ((0 == io_hdr.status) && (0 == io_hdr.host_status) &&
66 (0 == io_hdr.driver_status))
68 if ((SCSI_CHECK_CONDITION == io_hdr.status) ||
69 (SCSI_COMMAND_TERMINATED == io_hdr.status) ||
70 (SG_ERR_DRIVER_SENSE == (0xf & io_hdr.driver_status))) {
71 if (io_hdr.sbp && (io_hdr.sb_len_wr > 2)) {
73 unsigned char * sense_buffer = io_hdr.sbp;
74 if (sense_buffer[0] & 0x2)
75 sense_key = sense_buffer[1] & 0xf;
77 sense_key = sense_buffer[2] & 0xf;
78 if(RECOVERED_ERROR == sense_key)
88 unsigned char turCmdBlk[TUR_CMD_LEN] = { 0x00, 0, 0, 0, 0, 0 };
89 struct sg_io_hdr io_hdr;
90 unsigned char sense_buffer[32];
92 memset(&io_hdr, 0, sizeof (struct sg_io_hdr));
93 io_hdr.interface_id = 'S';
94 io_hdr.cmd_len = sizeof (turCmdBlk);
95 io_hdr.mx_sb_len = sizeof (sense_buffer);
96 io_hdr.dxfer_direction = SG_DXFER_NONE;
97 io_hdr.cmdp = turCmdBlk;
98 io_hdr.sbp = sense_buffer;
99 io_hdr.timeout = 20000;
101 if (ioctl(fd, SG_IO, &io_hdr) < 0) {
105 if (io_hdr.info & SG_INFO_OK_MASK) {
112 sprint_wwid(char * buff, const char * str)
121 for (i = 0; i <= WWID_SIZE / 2 - 1; i++) {
123 sprintf(cursor, "%.2x", (int) (unsigned char) c);
126 buff[WWID_SIZE - 1] = '\0';
130 get_lun_strings(int fd, struct path * mypath)
134 if (0 == do_inq(fd, 0, 0, 0, buff, 36, 1)) {
135 memcpy(mypath->vendor_id, &buff[8], 8);
136 memcpy(mypath->product_id, &buff[16], 16);
137 memcpy(mypath->rev, &buff[32], 4);
145 get_serial (int fd, char * str)
147 char buff[MX_ALLOC_LEN + 1];
150 if (0 == do_inq(fd, 0, 1, 0x80, buff, MX_ALLOC_LEN, 0)) {
153 memcpy(str, buff + 4, len);
162 /* hardware vendor specifics : add support for new models below */
164 get_storageworks_wwid(int fd, char *str)
168 if (0 == do_inq(fd, 0, 1, 0x83, buff, sizeof (buff), 1)) {
169 sprint_wwid(str, &buff[8]);
175 /* White list switch */
177 get_unique_id(int fd, struct path * mypath)
179 if (strncmp(mypath->product_id, "HSV110 (C)COMPAQ", 16) == 0 ||
180 strncmp(mypath->product_id, "HSG80 ", 16) == 0) {
181 get_storageworks_wwid(fd, mypath->wwid);
189 basename(char * str1, char * str2)
191 char *p = str1 + (strlen(str1) - 1);
199 blacklist (char * dev) {
216 for (i = 0; blist[i].lengh; i++) {
217 if (strncmp(dev, blist[i].headstr, blist[i].lengh) == 0)
224 get_all_paths_sysfs(struct env * conf, struct path * all_paths)
228 struct sysfs_directory * sdir;
229 struct sysfs_directory * devp;
230 struct sysfs_link * linkp;
231 char buff[FILE_NAME_SIZE];
233 char block_path[FILE_NAME_SIZE];
235 sprintf(block_path, "%s/block", conf->sysfs_path);
236 sdir = sysfs_open_directory(block_path);
237 sysfs_read_directory(sdir);
238 dlist_for_each_data(sdir->subdirs, devp, struct sysfs_directory) {
239 if (blacklist(devp->name))
241 sysfs_read_directory(devp);
242 if(devp->links == NULL)
244 dlist_for_each_data(devp->links, linkp, struct sysfs_link) {
245 if (!strncmp(linkp->name, "device", 6))
252 basename(devp->path, buff);
253 sprintf(all_paths[k].sg_dev, "/dev/%s", buff);
254 strcpy(all_paths[k].dev, all_paths[k].sg_dev);
255 if ((sg_fd = open(all_paths[k].sg_dev, O_RDONLY)) < 0) {
257 fprintf(stderr, "can't open %s. mknod ?",
258 all_paths[k].sg_dev);
261 get_lun_strings(sg_fd, &all_paths[k]);
262 get_unique_id(sg_fd, &all_paths[k]);
263 all_paths[k].state = do_tur(sg_fd);
265 basename(linkp->target, buff);
266 sscanf(buff, "%i:%i:%i:%i",
267 &all_paths[k].sg_id.host_no,
268 &all_paths[k].sg_id.channel,
269 &all_paths[k].sg_id.scsi_id,
270 &all_paths[k].sg_id.lun);
273 sysfs_close_directory(sdir);
279 get_all_paths_nosysfs(struct env * conf, struct path * all_paths,
280 struct scsi_dev * all_scsi_ids)
283 char buff[FILE_NAME_SIZE];
284 char file_name[FILE_NAME_SIZE];
286 for (k = 0; k < conf->max_devs; k++) {
287 strcpy(file_name, "/dev/sg");
288 sprintf(buff, "%d", k);
289 strncat(file_name, buff, FILE_NAME_SIZE);
290 strcpy(all_paths[k].sg_dev, file_name);
291 if ((sg_fd = open(file_name, O_RDONLY)) < 0) {
293 fprintf(stderr, "can't open %s. mknod ?",
297 get_lun_strings(sg_fd, &all_paths[k]);
298 get_unique_id(sg_fd, &all_paths[k]);
299 all_paths[k].state = do_tur(sg_fd);
300 if (0 > ioctl(sg_fd, SG_GET_SCSI_ID, &(all_paths[k].sg_id)))
301 printf("device %s failed on sg ioctl, skip\n",
306 for (i = 0; i < conf->max_devs; i++) {
307 if ((all_paths[k].sg_id.host_no ==
308 all_scsi_ids[i].host_no)
309 && (all_paths[k].sg_id.scsi_id ==
310 (all_scsi_ids[i].scsi_id.dev_id & 0xff))
311 && (all_paths[k].sg_id.lun ==
312 ((all_scsi_ids[i].scsi_id.dev_id >> 8) & 0xff))
313 && (all_paths[k].sg_id.channel ==
314 ((all_scsi_ids[i].scsi_id.
315 dev_id >> 16) & 0xff))) {
316 strcpy(all_paths[k].dev, all_scsi_ids[i].dev);
325 get_all_scsi_ids(struct env * conf, struct scsi_dev * all_scsi_ids)
327 int k, big, little, res, host_no, fd;
329 char fname[FILE_NAME_SIZE];
330 struct scsi_idlun my_scsi_id;
332 for (k = 0; k < conf->max_devs; k++) {
333 strcpy(fname, "/dev/sd");
335 buff[0] = 'a' + (char) k;
338 } else if (k <= 255) { /* assumes sequence goes x,y,z,aa,ab,ac etc */
340 little = k - (26 * big);
343 buff[0] = 'a' + (char) big;
344 buff[1] = 'a' + (char) little;
348 strcat(fname, "xxxx");
350 if ((fd = open(fname, O_RDONLY)) < 0) {
352 fprintf(stderr, "can't open %s. mknod ?",
357 res = ioctl(fd, SCSI_IOCTL_GET_IDLUN, &my_scsi_id);
360 printf("Could not get scsi idlun\n");
364 res = ioctl(fd, SCSI_IOCTL_GET_BUS_NUMBER, &host_no);
367 printf("Could not get host_no\n");
373 strcpy(all_scsi_ids[k].dev, fname);
374 all_scsi_ids[k].scsi_id = my_scsi_id;
375 all_scsi_ids[k].host_no = host_no;
380 /* print_path style */
385 print_path(struct path * all_paths, int k, int style)
388 printf("%s ", all_paths[k].wwid);
391 printf("(%i %i %i %i) ",
392 all_paths[k].sg_id.host_no,
393 all_paths[k].sg_id.channel,
394 all_paths[k].sg_id.scsi_id, all_paths[k].sg_id.lun);
395 printf("%s ", all_paths[k].sg_dev);
396 printf("op:%i ", all_paths[k].state);
397 printf("%s ", all_paths[k].dev);
398 printf("[%.16s]\n", all_paths[k].product_id);
402 print_all_path(struct env * conf, struct path * all_paths)
405 char empty_buff[WWID_SIZE];
407 memset(empty_buff, 0, WWID_SIZE);
408 for (k = 0; k < conf->max_devs; k++) {
409 if (memcmp(empty_buff, all_paths[k].wwid, WWID_SIZE) == 0)
411 print_path(all_paths, k, ALL);
416 print_all_mp(struct path * all_paths, struct multipath * mp, int nmp)
420 for (k = 0; k <= nmp; k++) {
421 printf("%s\n", mp[k].wwid);
422 for (i = 0; i <= mp[k].npaths; i++)
423 print_path(all_paths, PINDEX(k,i), NOWWID);
428 coalesce_paths(struct env * conf, struct multipath * mp,
429 struct path * all_paths)
431 int k, i, nmp, np, already_done;
432 char empty_buff[WWID_SIZE];
436 memset(empty_buff, 0, WWID_SIZE);
438 for (k = 0; k < conf->max_devs - 1; k++) {
439 /* skip this path if no unique id has been found */
440 if (memcmp(empty_buff, all_paths[k].wwid, WWID_SIZE) == 0)
444 for (i = 0; i <= nmp; i++) {
445 if (0 == strcmp(mp[i].wwid, all_paths[k].wwid))
455 strcpy(mp[nmp].wwid, all_paths[k].wwid);
458 for (i = k + 1; i < conf->max_devs; i++) {
459 if (0 == strcmp(all_paths[k].wwid, all_paths[i].wwid)) {
470 get_disk_size (struct env * conf, char * dev) {
473 char attr_path[FILE_NAME_SIZE];
474 char buff[FILE_NAME_SIZE];
475 char basedev[FILE_NAME_SIZE];
477 if(conf->with_sysfs) {
478 basename(dev, basedev);
479 sprintf(attr_path, "%s/block/%s/size",
480 conf->sysfs_path, basedev);
481 if (0 > sysfs_read_attribute_value(attr_path, buff,
482 FILE_NAME_SIZE * sizeof(char)))
487 if ((fd = open(dev, O_RDONLY)) < 0)
489 if(!ioctl(fd, BLKGETSIZE, &size))
496 make_dm_node(char * str)
499 char buff[FILE_NAME_SIZE];
500 struct dm_names * names;
504 if (!(dmt = dm_task_create(DM_DEVICE_LIST)))
507 if (!dm_task_run(dmt))
510 if (!(names = dm_task_get_names(dmt)))
519 if (0 == strcmp(names->name, str))
522 names = (void *) names + next;
525 sprintf(buff, "/dev/mapper/%s", str);
527 mknod(buff, 0600 | S_IFBLK, names->dev);
530 dm_task_destroy(dmt);
537 del_map(char * str) {
540 if (!(dmt = dm_task_create(DM_DEVICE_REMOVE)))
542 if (!dm_task_set_name(dmt, str))
544 if (!dm_task_run(dmt))
547 printf("Deleted device map : %s\n", str);
550 dm_task_destroy(dmt);
556 add_map(struct env * conf, struct path * all_paths,
557 struct multipath * mp, int index, int op)
565 /* defaults for multipath target */
566 int dm_nr_path_args = 2;
567 int dm_path_test_int = 10;
568 char * dm_ps_name = "round-robin";
569 int dm_ps_nr_args = 2;
570 int dm_path_failback_int = 10;
571 int dm_path_nr_fail = 2;
573 int dm_ps_min_io = 2;
576 if (!(dmt = dm_task_create(op)))
579 if (!dm_task_set_name(dmt, mp[index].wwid))
581 params_p = ¶ms[0];
584 for (i=0; i<=mp[index].npaths; i++) {
585 if ((1 == all_paths[PINDEX(index,i)].state) &&
586 (0 == all_paths[PINDEX(index,i)].sg_id.scsi_type))
591 /* temporarily disable creation of single path maps */
592 /* Sistina should modify the target limits */
596 params_p += sprintf(params_p, "%i %i %i %s %i",
597 np, dm_nr_path_args, dm_path_test_int,
598 dm_ps_name, dm_ps_nr_args);
600 for (i=0; i<=mp[index].npaths; i++) {
601 if (( 0 == all_paths[PINDEX(index,i)].state) ||
602 (0 != all_paths[PINDEX(index,i)].sg_id.scsi_type))
605 size = get_disk_size(conf, all_paths[PINDEX(index,0)].dev);
606 params_p += sprintf(params_p, " %s %i %i %i %i",
607 all_paths[PINDEX(index,i)].dev,
608 dm_path_failback_int, dm_path_nr_fail,
609 dm_ps_prio, dm_ps_min_io);
616 if (op == DM_DEVICE_RELOAD)
618 if (op == DM_DEVICE_CREATE)
620 printf("%s : 0 %li %s %s\n",
621 mp[index].wwid, size, DM_TARGET, params);
624 if (!dm_task_add_target(dmt, 0, size, DM_TARGET, params))
627 if (!dm_task_run(dmt))
631 make_dm_node(mp[index].wwid);
634 dm_task_destroy(dmt);
640 get_table(const char * str)
645 uint64_t start, length;
646 char *target_type = NULL;
649 if (!(dmt = dm_task_create(DM_DEVICE_TABLE)))
652 if (!dm_task_set_name(dmt, str))
655 if (!dm_task_run(dmt))
659 next = dm_get_next_target(dmt, next, &start, &length,
660 &target_type, ¶ms);
662 printf("%" PRIu64 " %" PRIu64 " %s %s\n",
663 start, length, target_type, params);
670 dm_task_destroy(dmt);
677 map_present(char * str)
681 struct dm_names *names;
684 if (!(dmt = dm_task_create(DM_DEVICE_LIST)))
687 if (!dm_task_run(dmt))
690 if (!(names = dm_task_get_names(dmt)))
698 if (0 == strcmp(names->name, str))
701 names = (void *) names + next;
705 dm_task_destroy(dmt);
710 usage(char * progname)
712 fprintf(stderr, VERSION_STRING);
713 fprintf(stderr, "Usage: %s [-v|-q] [-d] [-m max_devs]\n", progname);
714 fprintf(stderr, "\t-v\t\tverbose, print all paths and multipaths\n");
715 fprintf(stderr, "\t-q\t\tquiet, no output at all\n");
716 fprintf(stderr, "\t-d\t\tdry run, do not create or update devmaps\n");
717 fprintf(stderr, "\t-m max_devs\tscan {max_devs} devices at most\n");
722 filepresent(char * run) {
731 main(int argc, char *argv[])
733 char * run = "/var/run/multipath.run";
734 char * resched = "/var/run/multipath.reschedule";
735 struct multipath * mp;
736 struct path * all_paths;
737 struct scsi_dev * all_scsi_ids;
741 /* Default behaviour */
742 conf.max_devs = MAX_DEVS;
743 conf.dry_run = 0; /* 1 == Do not Create/Update devmaps */
744 conf.verbose = 0; /* 1 == Print all_paths and mp */
745 conf.quiet = 0; /* 1 == Do not even print devmaps */
746 conf.with_sysfs = 0; /* Default to compat / suboptimal behaviour */
748 /* kindly provided by libsysfs */
749 if (0 == sysfs_get_mnt_path(conf.sysfs_path, FILE_NAME_SIZE))
752 for (i = 1; i < argc; ++i) {
753 if (0 == strcmp("-v", argv[i])) {
757 } else if (0 == strcmp("-m", argv[i])) {
758 conf.max_devs = atoi(argv[++i]);
759 if (conf.max_devs < 2)
761 } else if (0 == strcmp("-q", argv[i])) {
762 if (conf.verbose == 1)
765 } else if (0 == strcmp("-d", argv[i]))
767 else if (*argv[i] == '-') {
768 fprintf(stderr, "Unknown switch: %s\n", argv[i]);
770 } else if (*argv[i] != '-') {
771 fprintf(stderr, "Unknown argument\n");
777 if (filepresent(run)) {
779 fprintf(stderr, "Already running.\n");
780 fprintf(stderr, "If you know what you do, please ");
781 fprintf(stderr, "remove %s\n", run);
783 /* leave a trace that we were called while already running */
784 open(resched, O_CREAT);
788 /* dynamic allocations */
789 mp = malloc(conf.max_devs * sizeof(struct multipath));
790 all_paths = malloc(conf.max_devs * sizeof(struct path));
791 all_scsi_ids = malloc(conf.max_devs * sizeof(struct scsi_dev));
792 if (mp == NULL || all_paths == NULL || all_scsi_ids == NULL) {
797 if(!open(run, O_CREAT))
800 if (!conf.with_sysfs) {
801 get_all_scsi_ids(&conf, all_scsi_ids);
802 get_all_paths_nosysfs(&conf, all_paths, all_scsi_ids);
804 get_all_paths_sysfs(&conf, all_paths);
806 nmp = coalesce_paths(&conf, mp, all_paths);
809 print_all_path(&conf, all_paths);
810 fprintf(stdout, "\n");
811 print_all_mp(all_paths, mp, nmp);
812 fprintf(stdout, "\n");
820 for (k=0; k<=nmp; k++) {
821 if (map_present(mp[k].wwid)) {
822 add_map(&conf, all_paths, mp, k, DM_DEVICE_RELOAD);
824 add_map(&conf, all_paths, mp, k, DM_DEVICE_CREATE);
829 /* start again if we were ask to during this process run */
830 /* ie. do not loose an event-asked run */
831 if (filepresent(resched)) {