File: rescan-scsi-bus.sh

package info (click to toggle)
sg3-utils 1.44-1
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 7,056 kB
  • sloc: ansic: 93,218; sh: 7,607; cpp: 2,947; makefile: 447
file content (1359 lines) | stat: -rwxr-xr-x 39,064 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
#!/bin/bash
# Script to rescan SCSI bus, using the scsi add-single-device mechanism.
# (c) 1998--2010 Kurt Garloff <kurt@garloff.de>, GNU GPL v2 or v3
# (c) 2006--2018 Hannes Reinecke, GNU GPL v2 or later
# $Id: rescan-scsi-bus.sh,v 1.57 2012/03/31 14:08:48 garloff Exp $

VERSION="20180615"
SCAN_WILD_CARD=4294967295

setcolor ()
{
  red="\e[0;31m"
  green="\e[0;32m"
  yellow="\e[0;33m"
  bold="\e[0;1m"
  norm="\e[0;0m"
}

unsetcolor () 
{
  red=""; green=""
  yellow=""; norm=""
}

echo_debug()
{
  if [ $debug -eq 1 ] ; then
     echo "$1"
  fi
}

# Output some text and return cursor to previous position
# (only works for simple strings)
# Stores length of string in LN and returns it
print_and_scroll_back ()
{
  STRG="$1"
  LN=${#STRG}
  BK=""
  declare -i cntr=0
  while test $cntr -lt $LN; do BK="$BK\e[D"; let cntr+=1; done
  echo -en "$STRG$BK"
  return $LN
}

# Overwrite a text of length $LN with whitespace
white_out ()
{
  BK=""; WH=""
  declare -i cntr=0
  while test $cntr -lt $LN; do BK="$BK\e[D"; WH="$WH "; let cntr+=1; done
  echo -en "$WH$BK"
}

# Return hosts. sysfs must be mounted
findhosts_26 ()
{
  hosts=`find /sys/class/scsi_host/host* -maxdepth 4 -type d -o -type l 2> /dev/null | awk -F'/' '{print $5}' | sed -e 's~host~~' | sort -nu` 
  scsi_host_data=`echo "$hosts" | sed -e 's~^~/sys/class/scsi_host/host~'` 
  for hostdir in $scsi_host_data; do 
    hostno=${hostdir#/sys/class/scsi_host/host}
    if [ -f $hostdir/isp_name ] ; then
      hostname="qla2xxx"
    elif [ -f $hostdir/lpfc_drvr_version ] ; then
      hostname="lpfc"
    else
      hostname=`cat $hostdir/proc_name`
    fi
    #hosts="$hosts $hostno"
    echo_debug "Host adapter $hostno ($hostname) found."
  done  
  if [ -z "$hosts" ] ; then
    echo "No SCSI host adapters found in sysfs"
    exit 1;
  fi
  # Not necessary just use double quotes around variable to preserve new lines
  #hosts=`echo $hosts | tr ' ' '\n'`
}

# Return hosts. /proc/scsi/HOSTADAPTER/? must exist
findhosts ()
{
  hosts=
  for driverdir in /proc/scsi/*; do
    driver=${driverdir#/proc/scsi/}
    if test $driver = scsi -o $driver = sg -o $driver = dummy -o $driver = device_info; then continue; fi
    for hostdir in $driverdir/*; do
      name=${hostdir#/proc/scsi/*/}
      if test $name = add_map -o $name = map -o $name = mod_parm; then continue; fi
      num=$name
      driverinfo=$driver
      if test -r "$hostdir/status"; then
        num=$(printf '%d\n' "$(sed -n 's/SCSI host number://p' "$hostdir/status")")
        driverinfo="$driver:$name"
      fi
      hosts="$hosts $num"
      echo "Host adapter $num ($driverinfo) found."
    done
  done
}

printtype ()
{
  local type=$1

  case "$type" in
    0) echo "Direct-Access" ;;
    1) echo "Sequential-Access" ;;
    2) echo "Printer" ;;
    3) echo "Processor" ;;
    4) echo "WORM" ;;
    5) echo "CD-ROM" ;;
    6) echo "Scanner" ;;
    7) echo "Optical-Device" ;;
    8) echo "Medium-Changer" ;;
    9) echo "Communications" ;;
    10) echo "Unknown" ;;
    11) echo "Unknown" ;;
    12) echo "RAID" ;;
    13) echo "Enclosure" ;;
    14) echo "Direct-Access-RBC" ;;
    *) echo "Unknown" ;;
  esac
}

print02i()
{
    if [ "$1" = "*" ] ; then 
        echo "00"
    else
        printf "%02i" "$1"
    fi
}

# Get /proc/scsi/scsi info for device $host:$channel:$id:$lun
# Optional parameter: Number of lines after first (default = 2), 
# result in SCSISTR, return code 1 means empty.
procscsiscsi ()
{  
  if test -z "$1"; then LN=2; else LN=$1; fi
  CHANNEL=`print02i "$channel"`
  ID=`print02i "$id"`
  LUN=`print02i "$lun"`
  if [ -d /sys/class/scsi_device ]; then
    SCSIPATH="/sys/class/scsi_device/${host}:${channel}:${id}:${lun}"
    if [ -d  "$SCSIPATH" ] ; then
      SCSISTR="Host: scsi${host} Channel: $CHANNEL Id: $ID Lun: $LUN"
      if [ "$LN" -gt 0 ] ; then
        IVEND=$(cat ${SCSIPATH}/device/vendor)
        IPROD=$(cat ${SCSIPATH}/device/model)
        IPREV=$(cat ${SCSIPATH}/device/rev)
        SCSIDEV=$(printf '  Vendor: %-08s Model: %-16s Rev: %-4s' "$IVEND" "$IPROD" "$IPREV")
        SCSISTR="$SCSISTR
$SCSIDEV"
      fi
      if [ "$LN" -gt 1 ] ; then
        ILVL=$(cat ${SCSIPATH}/device/scsi_level)
        type=$(cat ${SCSIPATH}/device/type)
        ITYPE=$(printtype $type)
        SCSITMP=$(printf '  Type:   %-17s                ANSI SCSI revision: %02d' "$ITYPE" "$((ILVL - 1))")
        SCSISTR="$SCSISTR
$SCSITMP"
      fi
    else
      return 1
    fi
  else
    grepstr="scsi$host Channel: $CHANNEL Id: $ID Lun: $LUN"
    SCSISTR=$(grep -A "$LN" -e "$grepstr" /proc/scsi/scsi)
  fi
  if test -z "$SCSISTR"; then return 1; else return 0; fi
}

# Find sg device with 2.6 sysfs support
sgdevice26 ()
{
  local gendev

  gendev=/sys/class/scsi_device/${host}:${channel}:${id}:${lun}/device/generic
  if test -e "$gendev"; then
    SGDEV=$(basename "$(readlink "$gendev")")
  else
    for SGDEV in /sys/class/scsi_generic/sg*; do
      DEV=`readlink $SGDEV/device`
      if test "${DEV##*/}" = "$host:$channel:$id:$lun"; then
        SGDEV=`basename $SGDEV`; return
      fi
    done
    SGDEV=""
  fi  
}

# Find sg device with 2.4 report-devs extensions
sgdevice24 ()
{
  if procscsiscsi 3; then
    SGDEV=`echo "$SCSISTR" | grep 'Attached drivers:' | sed 's/^ *Attached drivers: \(sg[0-9]*\).*/\1/'`
  fi
}

# Find sg device that belongs to SCSI device $host $channel $id $lun
# and return in SGDEV
sgdevice ()
{
  SGDEV=
  if test -d /sys/class/scsi_device; then
    sgdevice26
  else  
    DRV=`grep 'Attached drivers:' /proc/scsi/scsi 2>/dev/null`
    repdevstat=$((1-$?))
    if [ $repdevstat = 0 ]; then
      echo "scsi report-devs 1" >/proc/scsi/scsi
      DRV=`grep 'Attached drivers:' /proc/scsi/scsi 2>/dev/null`
      if [ $? = 1 ]; then return; fi
    fi
    if ! echo "$DRV" | grep -q 'drivers: sg'; then
      modprobe sg
    fi
    sgdevice24
    if [ $repdevstat = 0 ]; then
      echo "scsi report-devs 0" >/proc/scsi/scsi
    fi
  fi
}

# Whether or not the RMB (removable) bit has been set in the INQUIRY response.
# Uses ${host}, ${channel}, ${id} and ${lun}. Assumes that sg_device() has
# already been called. How to test this function: copy/paste this function
# in a shell and run
# (cd /sys/class/scsi_device && for d in *; do set ${d//:/ }; echo -n "$d $(</sys/class/scsi_device/${d}/device/block/*/removable) <> "; SGDEV=bsg/$d host=$1 channel=$2 id=$3 lun=$4 is_removable; done)
is_removable ()
{
  local b p

  p=/sys/class/scsi_device/${host}:${channel}:${id}:${lun}/device/inquiry
  # Extract the second byte of the INQUIRY response and check bit 7 (mask 0x80).
  b=$(od -tx1 -j1 -N1 "$p" 2>/dev/null |
           { read -r offset byte rest; echo -n "$byte"; })
  if [ -n "$b" ]; then
    echo $(((0x$b & 0x80) != 0))
  else
    sg_inq /dev/$SGDEV 2>/dev/null | sed -n 's/^.*RMB=\([0-9]*\).*$/\1/p'
  fi
}

# Test if SCSI device is still responding to commands
# Return values:
#   0 device is present
#   1 device has changed
#   2 device has been removed
testonline ()
{
  local ctr RC RMB

  : testonline
  ctr=0
  RC=0
  # Set default values
  IPTYPE=31
  IPQUAL=3
  if test ! -x /usr/bin/sg_turs; then return 0; fi
  sgdevice
  if test -z "$SGDEV"; then return 0; fi
  sg_turs /dev/$SGDEV >/dev/null 2>&1
  RC=$?

  # Handle in progress of becoming ready and unit attention
  while test $RC = 2 -o $RC = 6 && test $ctr -le 30; do
    if test $RC = 2 -a "$RMB" != "1"; then echo -n "."; let LN+=1; sleep 1
    else sleep 0.02; fi
    let ctr+=1
    sg_turs /dev/$SGDEV >/dev/null 2>&1
    RC=$?
    # Check for removable device; TEST UNIT READY obviously will
    # fail for a removable device with no medium
    RMB=$(is_removable)
    print_and_scroll_back "$host:$channel:$id:$lun $SGDEV ($RMB) "
    test $RC = 2 -a "$RMB" = "1" && break
  done
  if test $ctr != 0; then white_out; fi
  # echo -e "\e[A\e[A\e[A${yellow}Test existence of $SGDEV = $RC ${norm} \n\n\n"
  if test $RC = 1; then return $RC; fi
  # Reset RC (might be !=0 for passive paths)
  RC=0
  # OK, device online, compare INQUIRY string
  INQ=`sg_inq $sg_len_arg /dev/$SGDEV 2>/dev/null`
  if [ -z "$INQ" ] ; then
    echo -e "\e[A\e[A\e[A\e[A${red}$SGDEV changed: ${bold}INQUIRY failed${norm}    \n\n\n"
    return 2
  fi
  IVEND=`echo "$INQ" | grep 'Vendor identification:' | sed 's/^[^:]*: \(.*\)$/\1/'`
  IPROD=`echo "$INQ" | grep 'Product identification:' | sed 's/^[^:]*: \(.*\)$/\1/'`
  IPREV=`echo "$INQ" | grep 'Product revision level:' | sed 's/^[^:]*: \(.*\)$/\1/'`
  STR=`printf "  Vendor: %-08s Model: %-16s Rev: %-4s" "$IVEND" "$IPROD" "$IPREV"`
  IPTYPE=`echo "$INQ" | sed -n 's/.* Device_type=\([0-9]*\) .*/\1/p'`
  IPQUAL=`echo "$INQ" | sed -n 's/ *PQual=\([0-9]*\)  Device.*/\1/p'`
  if [ "$IPQUAL" != 0 ] ; then
    [ -z "$IPQUAL" ] && IPQUAL=3
    [ -z "$IPTYPE" ] && IPTYPE=31
    echo -e "\e[A\e[A\e[A\e[A${red}$SGDEV changed: ${bold}LU not available (PQual $IPQUAL)${norm}    \n\n\n"
    return 2
  fi

  TYPE=$(printtype $IPTYPE)
  if ! procscsiscsi ; then
    echo -e "\e[A\e[A\e[A\e[A${red}$SGDEV removed.\n\n\n"
    return 2
  fi
  TMPSTR=`echo "$SCSISTR" | grep 'Vendor:'`
  if test $ignore_rev -eq 0 ; then
      if [ "$TMPSTR" != "$STR" ]; then
        echo -e "\e[A\e[A\e[A\e[A${red}$SGDEV changed: ${bold}\nfrom:${SCSISTR#* } \nto: $STR ${norm} \n\n\n"
        return 1
      fi
  else
      # Ignore disk revision change
      local old_str_no_rev=`echo "$TMPSTR" | sed -e 's/.\{4\}$//'`
      local new_str_no_rev=`echo "$STR" | sed -e 's/.\{4\}$//'`
      if [ "$old_str_no_rev" != "$new_str_no_rev" ]; then
        echo -e "\e[A\e[A\e[A\e[A${red}$SGDEV changed: ${bold}\nfrom:${SCSISTR#* } \nto: $STR ${norm} \n\n\n"
        return 1
      fi
  fi
  TMPSTR=`echo "$SCSISTR" | sed -n 's/.*Type: *\(.*\) *ANSI.*/\1/p' | sed 's/ *$//g'`
  if [ "$TMPSTR" != "$TYPE" ] ; then
    echo -e "\e[A\e[A\e[A\e[A${red}$SGDEV changed: ${bold}\nfrom:${TMPSTR} \nto: $TYPE ${norm} \n\n\n"
    return 1
  fi
  return $RC
}

# Test if SCSI device $host $channel $id $lun exists
# Outputs description from /proc/scsi/scsi (unless arg passed)
# Returns SCSISTR (empty if no dev)
testexist ()
{
  : testexist
  SCSISTR=
  if procscsiscsi && test -z "$1"; then
    echo "$SCSISTR" | head -n1
    echo "$SCSISTR" | tail -n2 | pr -o4 -l1
  fi
}

# Returns the list of existing channels per host
chanlist ()
{
  local hcil
  local cil
  local chan
  local tmpchan

  for dev in /sys/class/scsi_device/${host}:* ; do
    [ -d $dev ] || continue;
    hcil=${dev##*/}
    cil=${hcil#*:}
    chan=${cil%%:*}
    for tmpchan in $channelsearch ; do
      if test "$chan" -eq $tmpchan ; then
        chan=
      fi
    done
    if test -n "$chan" ; then
      channelsearch="$channelsearch $chan"
    fi
  done
  if test -z "$channelsearch"; then channelsearch="0"; fi
}

# Returns the list of existing targets per host
idlist ()
{
  local tmpid
  local newid
  local oldid

  oldlist=$(ls /sys/class/scsi_device/ | sed -n "s/${host}:${channel}:\([0-9]*:[0-9]*\)/\1/p" | uniq)
  # Rescan LUN 0 to check if we found new targets
  echo "${channel} - 0" > /sys/class/scsi_host/host${host}/scan
  newlist=$(ls /sys/class/scsi_device/ | sed -n "s/${host}:${channel}:\([0-9]*:[0-9]*\)/\1/p" | uniq)
  for newid in $newlist ; do
    oldid=$newid
    for tmpid in $oldlist ; do
      if test $newid = $tmpid ; then
        oldid=
        break
      fi
    done
    if test -n "$oldid" ; then
      id=${oldid%%:*}
      lun=${oldid##*:}
      dev=/sys/class/scsi_device/${host}:${channel}:${id}:${lun}
      if [ -d $dev ] ; then
	hcil=${dev##*/}
        printf "\r${green}NEW: $norm"
        testexist
        if test "$SCSISTR" ; then
          incrfound "$hcil"
        fi
      fi
    fi
  done
  idsearch=$(ls /sys/class/scsi_device/ | sed -n "s/${host}:${channel}:\([0-9]*\):[0-9]*/\1/p" | uniq)
}

# Returns the list of existing LUNs from device $host $channel $id $lun
# and returns list to stdout
getluns()
{
  sgdevice
  if test -z "$SGDEV"; then return 1; fi
  if test ! -x /usr/bin/sg_luns; then echo 0; return 1; fi
  LLUN=`sg_luns /dev/$SGDEV 2>/dev/null | sed -n 's/    \(.*\)/\1/p'`
  # Added -z $LLUN condition because $? gets the RC from sed, not sg_luns
  if test $? != 0 -o -z "$LLUN"; then echo 0; return 1; fi
  for lun in $LLUN ; do
      # Swap LUN number
      l0=0x$lun
      l1=$(( ($l0 >> 48) & 0xffff ))
      l2=$(( ($l0 >> 32) & 0xffff )) 
      l3=$(( ($l0 >> 16) & 0xffff ))
      l4=$(( $l0 & 0xffff ))
      l0=$(( ( ( ($l4 * 0xffff) + $l3 ) * 0xffff + $l2 ) * 0xffff + $l1 ))
      printf "%u\n" $l0
  done
  return 0
}

# Wait for udev to settle (create device nodes etc.)
udevadm_settle()
{
  local tmo=60
  if test -x /bin/udevadm; then 
    print_and_scroll_back " Calling udevadm settle (can take a while) "
    # Loop for up to 60 seconds if sd devices still are settling..
    # This allows us to continue if udev events are stuck on multipaths in recovery mode
    while [ $tmo -gt 0 ] ; do
      if ! /bin/udevadm settle --timeout=1 | egrep -q sd[a-z]+ ; then
        break;
      fi
      let tmo=$tmo-1
    done
    white_out
  elif test -x /sbin/udevsettle; then
    print_and_scroll_back " Calling udevsettle (can take a while) "
    /sbin/udevsettle
    white_out
  else
    sleep 0.02
  fi
}

# Perform scan on a single lun $host $channel $id $lun
dolunscan()
{
  local remappedlun0=
  SCSISTR=
  devnr="$host $channel $id $lun"
  echo -e " Scanning for device $devnr ... "
  printf "${yellow}OLD: $norm"
  testexist
  # Device exists: Test whether it's still online
  # (testonline returns 2 if it's gone and 1 if it has changed)
  if test "$SCSISTR" ; then
    testonline
    RC=$?
    # Well known lun transition case. Only for Direct-Access devs (type 0)
    # If block directory exists && and PQUAL != 0, we unmapped lun0 and just have a well-known lun
    # If block directory doesn't exist && PQUAL == 0, we mapped a real lun0
    if test $lun -eq 0 -a $IPTYPE -eq 0 ; then
      if test $RC = 2 ; then
        if test -e /sys/class/scsi_device/${host}:${channel}:${id}:${lun}/device; then
          if test -d /sys/class/scsi_device/${host}:${channel}:${id}:${lun}/device/block ; then
            remappedlun0=2  # Transition from real lun 0 to well-known
          else
            RC=0   # Set this so the system leaves the existing well known lun alone. This is a lun 0 with no block directory
          fi
        fi
      elif test $RC = 0 -a $IPTYPE -eq 0; then
        if test -e /sys/class/scsi_device/${host}:${channel}:${id}:${lun}/device; then
          if test ! -d /sys/class/scsi_device/${host}:${channel}:${id}:${lun}/device/block ; then
            remappedlun0=1  # Transition from well-known to real lun 0
          fi
        fi
      fi
    fi
  fi

  # Special case: lun 0 just got added (for reportlunscan),
  # so make sure we correctly treat it as new
  if test "$lun" = "0" -a "$1" = "1" -a -z "$remappedlun0"; then
    SCSISTR=""
    printf "\r\e[A\e[A\e[A"
  fi

  : f $remove s $SCSISTR
  if test "$remove" -a "$SCSISTR" -o "$remappedlun0" = "1"; then
    if test $RC != 0 -o ! -z "$forceremove" -o -n "$remappedlun0"; then
      if test "$remappedlun0" != "1" ; then
        echo -en "\r\e[A\e[A\e[A${red}REM: "
        echo "$SCSISTR" | head -n1
        echo -e "${norm}\e[B\e[B"
      fi
      if test -e /sys/class/scsi_device/${host}:${channel}:${id}:${lun}/device; then
        # have to preemptively do this so we can figure out the mpath device
        # Don't do this if we're deleting a well known lun to replace it
        if test "$remappedlun0" != "1" ; then
          incrrmvd "$host:$channel:$id:$lun"
        fi
        echo 1 > /sys/class/scsi_device/${host}:${channel}:${id}:${lun}/device/delete
        sleep 0.02
      else
        echo "scsi remove-single-device $devnr" > /proc/scsi/scsi
        if test $RC -eq 1 -o $lun -eq 0 ; then
          # Try readding, should fail if device is gone
          echo "scsi add-single-device $devnr" > /proc/scsi/scsi
        fi
      fi
    fi
    if test $RC = 0 -o "$forcerescan" ; then
      if test -e /sys/class/scsi_device/${host}:${channel}:${id}:${lun}/device; then
        echo 1 > /sys/class/scsi_device/${host}:${channel}:${id}:${lun}/device/rescan
      fi
    fi
    printf "\r\e[A\e[A\e[A${yellow}OLD: $norm"
    testexist
    if test -z "$SCSISTR" -a $RC != 1 -a "$remappedlun0" != "1"; then
      printf "\r${red}DEL: $norm\r\n\n"
      # In the event we're replacing with a well known node, we need to let it continue, to create the replacement node
      test "$remappedlun0" != "2" && return 1
    fi
  fi
  if test -z "$SCSISTR" -o -n "$remappedlun0"; then
    if test "$remappedlun0" != "2" ; then
      # Device does not exist, try to add
      printf "\r${green}NEW: $norm"
    fi
    if test -e /sys/class/scsi_host/host${host}/scan; then
      echo "$channel $id $lun" > /sys/class/scsi_host/host${host}/scan 2> /dev/null
    else
      echo "scsi add-single-device $devnr" > /proc/scsi/scsi
    fi
    testexist
    if test -z "$SCSISTR"; then
      # Device not present
      printf "\r\e[A";
      # Optimization: if lun==0, stop here (only if in non-remove mode)
      if test $lun = 0 -a -z "$remove" -a $optscan = 1; then 
        break;
      fi
    else 
      if test "$remappedlun0" != "2" ; then
        incrfound "$host:$channel:$id:$lun"
      fi
    fi
  fi
}

# Perform report lun scan on $host $channel $id using REPORT_LUNS
doreportlun()
{
  lun=0
  SCSISTR=
  devnr="$host $channel $id $lun"
  echo -en " Scanning for device $devnr ...\r"
  lun0added=
  #printf "${yellow}OLD: $norm"
  # Phase one: If LUN0 does not exist, try to add
  testexist -q
  if test -z "$SCSISTR"; then
    # Device does not exist, try to add
    #printf "\r${green}NEW: $norm"
    if test -e /sys/class/scsi_host/host${host}/scan; then
      echo "$channel $id $lun" > /sys/class/scsi_host/host${host}/scan 2> /dev/null
      udevadm_settle
    else
      echo "scsi add-single-device $devnr" > /proc/scsi/scsi
    fi
    testexist -q
    if test -n "$SCSISTR"; then
      lun0added=1
      #testonline
    else
      # Device not present
      # return
      # Find alternative LUN to send getluns to
      for dev in /sys/class/scsi_device/${host}:${channel}:${id}:*; do
        [ -d "$dev" ] || continue
        lun=${dev##*:}
        break
      done
    fi
  fi
  targetluns=`getluns`
  REPLUNSTAT=$?
  lunremove=
  #echo "getluns reports " $targetluns
  olddev=`find /sys/class/scsi_device/ -name "$host:$channel:$id:*" 2>/dev/null | sort -t: -k4 -n`
  oldtargets="$targetluns"
  # OK -- if we don't have a LUN to send a REPORT_LUNS to, we could
  # fall back to wildcard scanning. Same thing if the device does not
  # support REPORT_LUNS
  # TODO: We might be better off to ALWAYS use wildcard scanning if 
  # it works
  if test "$REPLUNSTAT" = "1"; then
    if test -e /sys/class/scsi_host/host${host}/scan; then
      echo "$channel $id -" > /sys/class/scsi_host/host${host}/scan 2> /dev/null
      udevadm_settle
    else
      echo "scsi add-single-device $host $channel $id $SCAN_WILD_CARD" > /proc/scsi/scsi
    fi
    targetluns=`find /sys/class/scsi_device/ -name "$host:$channel:$id:*" 2>/dev/null | awk -F'/' '{print $5}' | awk -F':' '{print $4}' | sort -n`
    let found+=`echo "$targetluns" | wc -l`
    let found-=`echo "$olddev" | wc -l`
  fi
  if test -z "$targetluns"; then targetluns="$oldtargets"; fi
  # Check existing luns
  for dev in $olddev; do
    [ -d "$dev" ] || continue
    lun=${dev##*:}
    newsearch=
    inlist=
    # OK, is existing $lun (still) in reported list
    for tmplun in $targetluns; do
      if test $tmplun -eq $lun ; then
        inlist=1
        dolunscan $lun0added
      else
        newsearch="$newsearch $tmplun"
      fi
    done
    # OK, we have now done a lunscan on $lun and 
    # $newsearch is the old $targetluns without $lun
    if [ -z "$inlist" ]; then
      # Stale lun
      lunremove="$lunremove $lun"
    fi
    # $lun removed from $lunsearch (echo for whitespace cleanup)
    targetluns=`echo $newsearch`
  done
  # Add new ones and check stale ones
  for lun in $targetluns $lunremove; do
    dolunscan $lun0added
  done
}

# Perform search (scan $host)
dosearch ()
{
  if test -z "$channelsearch" ; then
    chanlist
  fi
  for channel in $channelsearch; do
    if test -z "$idsearch" ; then
      if test -z "$lunsearch" ; then
	idlist
      else
	idsearch=$(ls /sys/class/scsi_device/ | sed -n "s/${host}:${channel}:\([0-9]*\):[0-9]*/\1/p" | uniq)
      fi
    fi
    for id in $idsearch; do
      if test -z "$lunsearch" ; then
        doreportlun
      else
        for lun in $lunsearch; do
          dolunscan
        done
      fi
    done
  done
}
 
expandlist ()
{
  list=$1
  result=""
  first=${list%%,*}
  rest=${list#*,}
  while test ! -z "$first"; do 
    beg=${first%%-*};
    if test "$beg" = "$first"; then
      result="$result $beg";
    else
      end=${first#*-}
      result="$result `seq $beg $end`"
    fi
    test "$rest" = "$first" && rest=""
    first=${rest%%,*}
    rest=${rest#*,}
  done
  echo $result
}

searchexisting()
{
  local tmpch;
  local tmpid
  local match=0
  local targets=`ls -d /sys/class/scsi_device/$host:* 2> /dev/null | egrep -o $host:[0-9]+:[0-9]+ | sort | uniq`

  # Nothing came back on this host, so we should skip it
  test -z "$targets" && return

  local target=;
  for target in $targets ; do
    channel=`echo $target | cut -d":" -f2`
    id=`echo $target | cut -d":" -f 3`
    if [ -n "$channelsearch" ] ; then
      for tmpch in $channelsearch ; do
        test $tmpch -eq $channel && match=1
      done
    else
      match=1
    fi

    test $match -eq 0 && continue
    match=0

    if [ $filter_ids -eq 1 ] ; then
      for tmpid in $idsearch ; do
        if [ $tmpid -eq $id ] ; then
          match=1
        fi
      done
    else
      match=1
    fi

    test $match -eq 0 && continue

    if [ -z "$lunsearch" ] ; then
      doreportlun
    else
      for lun in $lunsearch ; do
        dolunscan
      done
    fi
  done
}

# Go through all of the existing devices and figure out any that have been remapped
findremapped()
{
  local hctl=;
  local devs=`ls /sys/class/scsi_device/`
  local sddev=
  local id_serial=
  local id_serial_old=
  local remapped=
  mpaths=""
  local tmpfile=$(mktemp /tmp/rescan-scsi-bus.XXXXXXXX 2> /dev/null)

  if [ -z "$tmpfile" ] ; then
    tmpfile="/tmp/rescan-scsi-bus.$$"
    rm -f $tmpfile
  fi

  # Get all of the ID_SERIAL attributes, after finding their sd node
  for hctl in $devs ; do
    if [ -d /sys/class/scsi_device/$hctl/device/block ] ; then
      sddev=`ls /sys/class/scsi_device/$hctl/device/block`
      id_serial_old=`udevadm info -q all -n $sddev | grep "ID_SERIAL=" | cut -d"=" -f2`
      [ -z "$id_serial_old" ] && id_serial_old="none"
      echo "$hctl $sddev $id_serial_old" >> $tmpfile
    fi
  done

  # Trigger udev to update the info
  echo -n "Triggering udev to update device information... "
  /bin/udevadm trigger
  udevadm_settle 2>&1 /dev/null
  echo "Done"

  # See what changed and reload the respective multipath device if applicable
  while read hctl sddev id_serial_old ; do
    remapped=0
    id_serial=`udevadm info -q all -n $sddev | grep "ID_SERIAL=" | cut -d"=" -f2`
    [ -z "$id_serial" ] && id_serial="none"
    if [ "$id_serial_old" != "$id_serial" ] ; then
      remapped=1
    fi
    # If udev events updated the disks already, but the multipath device isn't update
    # check for old devices to make sure we found remapped luns
    if [ -n "$mp_enable" ] && [ $remapped -eq 0 ]; then
      findmultipath $sddev $id_serial
      if [ $? -eq 1 ] ; then
        remapped=1
      fi
    fi

    # if uuid is 1, it's unmapped, so we don't want to treat it as a remap
    # if remapped flag is 0, just skip the rest of the logic
    if [ "$id_serial" = "1" ] || [ $remapped -eq 0 ] ; then
      continue
    fi
    printf "${yellow}REMAPPED: $norm"
    host=`echo $hctl | cut -d":" -f1`
    channel=`echo $hctl | cut -d":" -f2`
    id=`echo $hctl | cut -d":" -f3`
    lun=`echo $hctl | cut -d":" -f4`
    procscsiscsi
    echo "$SCSISTR"
    incrchgd "$hctl"
  done < $tmpfile
  rm -f $tmpfile

  if test -n "$mp_enable" -a -n "$mpaths" ; then
    echo "Updating multipath device mappings"
    flushmpaths
    $MULTIPATH | grep "create:" 2> /dev/null
  fi
}

incrfound()
{
  local hctl="$1"
  if test -n "$hctl" ; then
    let found+=1
    FOUNDDEVS="$FOUNDDEVS\t[$hctl]\n"
  else
    return
  fi
}

incrchgd()
{
  local hctl="$1"
  if test -n "$hctl" ; then
    if ! echo $CHGDEVS | grep -q "\[$hctl\]"; then
      let updated+=1
      CHGDEVS="$CHGDEVS\t[$hctl]\n"
    fi
  else
    return
  fi

  if test -n "$mp_enable" ; then
    local sdev="`findsddev \"$hctl\"`"
    if test -n "$sdev" ; then
      findmultipath "$sdev"
    fi
  fi
}

incrrmvd()
{
  local hctl="$1"
  if test -n "$hctl" ; then
    let rmvd+=1;
    RMVDDEVS="$RMVDDEVS\t[$hctl]\n"
  else
    return
  fi

  if test -n "$mp_enable" ; then
    local sdev="`findsddev \"$hctl\"`"
    if test -n "$sdev" ; then
      findmultipath "$sdev"
    fi
  fi
}

findsddev()
{
  local hctl="$1"
  local sddev=  

  if test ! -e /sys/class/scsi_device/$hctl/device/block ; then
    return 1
  fi 

  sddev=`ls /sys/class/scsi_device/$hctl/device/block`
  echo $sddev

  return 0
}

addmpathtolist()
{
  local mp="$1"
  local mp2=

  for mp2 in $mpaths ; do
    # The multipath device is already in the list
    if [ "$mp2" = "$mp" ] ; then
      return
    fi
  done
  mpaths="$mpaths $mp"
}

findmultipath()
{
  local dev="$1"
  local find_mismatch="$2"
  local mp=
  local mp2=
  local found_dup=0

  # Need a sdev, and executable multipath and dmsetup command here
  if [ -z "$dev" ] || [ ! -x $DMSETUP ] || [ ! -x "$MULTIPATH" ] ; then
    return 1
  fi

  local maj_min=`cat /sys/block/$dev/dev`
  for mp in $($DMSETUP ls --target=multipath | cut -f 1) ; do
    [ "$mp" = "No" ] && break;
    if $DMSETUP status $mp | grep -q " $maj_min "; then
      # With two arguments, look up current uuid from sysfs
      # if it doesn't match what was passed, this multipath
      # device is not updated, so this is a remapped LUN
      if [ -n "$find_mismatch" ] ; then
        mp2=$($MULTIPATH -l "$mp" | egrep -o "dm-[0-9]+")
        mp2=$(cut -f2 -d- "/sys/block/$mp2/dm/uuid")
        if [ "$find_mismatch" != "$mp2" ] ; then
          addmpathtolist $mp
          found_dup=1
        fi
        continue
      fi
      # Normal mode: Find the first multipath with the sdev
      # and add it to the list
      addmpathtolist $mp
      return
    fi
  done

  # Return 1 to signal that a duplicate was found to the calling function
  if [ $found_dup -eq 1 ] ; then
    return 1
  else
    return 0
  fi
}

reloadmpaths()
{
  local mpath
  if [ ! -x "$MULTIPATH" ] ; then
    echo "no -x multipath"
    return
  fi

  # Pass 1 as the argument to reload all mpaths
  if [ "$1" = "1" ] ; then
    echo "Reloading all multipath devices"
    $MULTIPATH -r > /dev/null 2>&1
    return
  fi

  # Reload the multipath devices
  for mpath in $mpaths ; do
    echo -n "Reloading multipath device $mpath... "
    $MULTIPATH -r $mpath > /dev/null 2>&1
    if test "$?" = "0" ; then
      echo "Done"
    else
      echo "Fail"
    fi
  done
}

resizempaths()
{
  local mpath

  for mpath in $mpaths ; do
    echo -n "Resizing multipath map $mpath ..."
    multipathd -k"resize map $mpath"
    let updated+=1
  done
}

flushmpaths()
{
  local mpath
  local remove=""
  local i
  local flush_retries=5

  if test -n "$1" ; then
    for mpath in $($DMSETUP ls --target=multipath | cut -f 1) ; do
      [ "$mpath" = "No" ] && break
      num=$($DMSETUP status $mpath | awk 'BEGIN{RS=" ";active=0}/[0-9]+:[0-9]+/{dev=1}/A/{if (dev == 1) active++; dev=0} END{ print active }')
      if [ $num -eq 0 ] ; then
        remove="$remove $mpath"
      fi
    done
  else
    remove="$mpaths"
  fi

  for mpath in $remove ; do
    i=0
    echo -n "Flushing multipath device $mpath... "
    while [ $i -lt $flush_retries ] ; do
      $DMSETUP message $mpath 0 fail_if_no_path > /dev/null 2>&1
      $MULTIPATH -f $mpath > /dev/null 2>&1
      if test "$?" = "0" ; then
        echo "Done ($i retries)"
        break
      elif test $i -eq $flush_retries ; then
        echo "Fail"
      fi
      sleep 0.02
      let i=$i+1
    done
  done
}


# Find resized luns
findresized()
{
  local devs=
  local size=
  local new_size=
  local sysfs_path=
  local sddev=
  local i=
  local m=
  local mpathsize=
  declare -a mpathsizes

  if [ -z "$lunsearch" ] ; then
    devs=`ls /sys/class/scsi_device/`
  else
    for lun in $lunsearch ; do
      devs="$devs `(cd /sys/class/scsi_device/ && ls -d *:${lun})`"
    done
  fi

  for hctl in $devs ; do
    sysfs_path="/sys/class/scsi_device/$hctl/device"
    if [ -d "$sysfs_path/block" ] ; then
      sddev=`ls $sysfs_path/block`
      size=`cat $sysfs_path/block/$sddev/size`

      echo 1 > $sysfs_path/rescan
      new_size=`cat $sysfs_path/block/$sddev/size`

      if [ "$size" != "$new_size" ] && [ "$size" != "0" ] && [ "$new_size" != "0" ] ; then
        printf "${yellow}RESIZED: $norm"
        host=`echo $hctl | cut -d":" -f1`
        channel=`echo $hctl | cut -d":" -f2`
        id=`echo $hctl | cut -d":" -f3`
        lun=`echo $hctl | cut -d":" -f4`

        procscsiscsi
        echo "$SCSISTR"
        incrchgd "$hctl"
      fi
    fi
  done

  if test -n "$mp_enable" -a -n "$mpaths" ; then
    i=0
    for m in $mpaths ; do
      mpathsizes[$i]="`$MULTIPATH -l $m | egrep -o [0-9]+.[0-9]+[KMGT]`"
      let i=$i+1
    done
    resizempaths
    i=0
    for m in $mpaths ; do
      mpathsize="`$MULTIPATH -l $m | egrep -o [0-9\.]+[KMGT]`"
      echo "$m ${mpathsizes[$i]} => $mpathsize"
      let i=$i+1
    done
  fi
}

FOUNDDEVS=""
CHGDEVS=""
RMVDDEVS=""

# main
if test @$1 = @--help -o @$1 = @-h -o @$1 = @-?; then
    echo "Usage: rescan-scsi-bus.sh [options] [host [host ...]]"
    echo "Options:"
    echo " -a      scan all targets, not just currently existing [default: disabled]"
    echo " -c      enables scanning of channels 0 1   [default: 0 / all detected ones]"
    echo " -d      enable debug                       [default: 0]"
    echo " -f      flush failed multipath devices     [default: disabled]"
    echo " -h      help: print this usage message then exit"
    echo " -i      issue a FibreChannel LIP reset     [default: disabled]"
    echo " -I SECS issue a FibreChannel LIP reset and wait for SECS seconds [default: disabled]"
    echo " -l      activates scanning for LUNs 0--7   [default: 0]"
    echo " -L NUM  activates scanning for LUNs 0--NUM [default: 0]"
    echo " -m      update multipath devices           [default: disabled]"
    echo " -r      enables removing of devices        [default: disabled]"
    echo " -s      look for resized disks and reload associated multipath devices, if applicable"
    echo " -u      look for existing disks that have been remapped"
    echo " -V      print version date then exit"
    echo " -w      scan for target device IDs 0--15   [default: 0--7]"
    echo "--alltargets:    same as -a"
    echo "--attachpq3:     Tell kernel to attach sg to LUN 0 that reports PQ=3"
    echo "--channels=LIST: Scan only channel(s) in LIST"
    echo "--color:         use coloured prefixes OLD/NEW/DEL"
    echo "--flush:         same as -f"
    echo "--forceremove:   Remove stale devices (DANGEROUS)"
    echo "--forcerescan:   Remove and readd existing devices (DANGEROUS)"
    echo "--help:          print this usage message then exit"
    echo "--hosts=LIST:    Scan only host(s) in LIST"
    echo "--ids=LIST:      Scan only target ID(s) in LIST"
    echo "--ignore-rev:    Ignore the revision change"
    echo "--issue-lip:     same as -i"
    echo "--issue-lip-wait=SECS:     same as -I"
    echo "--largelun:      Tell kernel to support LUNs > 7 even on SCSI2 devs"
    echo "--luns=LIST:     Scan only lun(s) in LIST"  
    echo "--multipath:     same as -m"
    echo "--nooptscan:     don't stop looking for LUNs is 0 is not found"
    echo "--remove:        same as -r"
    echo "--reportlun2:    Tell kernel to try REPORT_LUN even on SCSI2 devices"
    echo "--resize:        same as -s"
    echo "--sparselun:     Tell kernel to support sparse LUN numbering"
    echo "--sync/nosync:   Issue a sync / no sync [default: sync if remove]"
    echo "--update:        same as -u"
    echo "--version:       same as -V"
    echo "--wide:          same as -w"
    echo ""
    echo "Host numbers may thus be specified either directly on cmd line (deprecated)"
    echo "or with the --hosts=LIST parameter (recommended)."
    echo "LIST: A[-B][,C[-D]]... is a comma separated list of single values and ranges"
    echo "(No spaces allowed.)"
    exit 0
fi

if test @$1 = @--version -o @$1 = @-V ; then
    echo ${VERSION}
    exit 0
fi

if test ! -d /sys/class/scsi_host/ -a ! -d /proc/scsi/; then
  echo "Error: SCSI subsystem not active"
  exit 1
fi

# Make sure sg is there
modprobe sg >/dev/null 2>&1

if test -x /usr/bin/sg_inq; then
  sg_version=$(sg_inq -V 2>&1 | cut -d " " -f 3)
  if test -n "$sg_version"; then
    sg_ver_maj=${sg_version:0:1}
    sg_version=${sg_version##?.}
    let sg_version+=$((100*$sg_ver_maj))
  fi
  sg_version=${sg_version##0.}
  #echo "\"$sg_version\""
  if [ -z "$sg_version" -o "$sg_version" -lt 70 ] ; then
    sg_len_arg="-36"
  else
    sg_len_arg="--len=36"
  fi
else
  echo "WARN: /usr/bin/sg_inq not present -- please install sg3_utils"
  echo " or rescan-scsi-bus.sh might not fully work."     
fi    

# defaults
unsetcolor
debug=0
lunsearch=
opt_idsearch=`seq 0 7`
filter_ids=0
opt_channelsearch=
remove=
updated=0
update=0
resize=0
forceremove=
optscan=1
sync=1
existing_targets=1
mp_enable=
lipreset=-1
declare -i scan_flags=0
ignore_rev=0

# Scan options
opt="$1"
while test ! -z "$opt" -a -z "${opt##-*}"; do
  opt=${opt#-}
  case "$opt" in
    a) existing_targets=;;  #Scan ALL targets when specified
    c) opt_channelsearch="0 1" ;;
    d) debug=1 ;;
    f) flush=1 ;;
    i) lipreset=0 ;;
    I) shift; lipreset=$opt ;;
    l) lunsearch=`seq 0 7` ;;
    L) lunsearch=`seq 0 $2`; shift ;;
    m) mp_enable=1 ;;
    r) remove=1 ;;
    s) resize=1; mp_enable=1 ;;
    u) update=1 ;;
    w) opt_idsearch=`seq 0 15` ;;
    -alltargets)  existing_targets=;;
    -attachpq3) scan_flags=$(($scan_flags|0x1000000)) ;;
    -channels=*)  arg=${opt#-channels=};opt_channelsearch=`expandlist $arg` ;; 
    -color) setcolor ;;
    -flush)       flush=1 ;;
    -forceremove) remove=1; forceremove=1 ;;
    -forcerescan) remove=1; forcerescan=1 ;;
    -hosts=*)     arg=${opt#-hosts=};   hosts=`expandlist $arg` ;;
    -ids=*)   arg=${opt#-ids=};         opt_idsearch=`expandlist $arg` ; filter_ids=1;;
    -ignore-rev) ignore_rev=1;;
    -issue-lip) lipreset=0 ;;
    -issue-lip-wait) lipreset=${opt#-issue-lip-wait=};;
    -largelun) scan_flags=$(($scan_flags|0x200)) ;;
    -luns=*)  arg=${opt#-luns=};        lunsearch=`expandlist $arg` ;; 
    -multipath) mp_enable=1 ;;
    -nooptscan) optscan=0 ;;
    -nosync) sync=0 ;;
    -remove)      remove=1 ;;
    -reportlun2) scan_flags=$(($scan_flags|0x20000)) ;;
    -resize) resize=1;;
    -sparselun) scan_flags=$((scan_flags|0x40)) ;;
    -sync) sync=2 ;;
    -update) update=1;;
    -wide) opt_idsearch=`seq 0 15` ;;
    *) echo "Unknown option -$opt !" ;;
  esac
  shift
  opt="$1"
done    

if [ -z "$hosts" ] ; then
  if test -d /sys/class/scsi_host; then 
    findhosts_26
  else  
    findhosts
  fi  
fi

if [ -d /sys/class/scsi_host -a ! -w /sys/class/scsi_host ]; then
  echo "You need to run scsi-rescan-bus.sh as root"
  exit 2
fi  
if test "$sync" = 1 -a "$remove" = 1; then sync=2; fi
if test "$sync" = 2; then echo "Syncing file systems"; sync; fi
if test -w /sys/module/scsi_mod/parameters/default_dev_flags -a $scan_flags != 0; then
  OLD_SCANFLAGS=`cat /sys/module/scsi_mod/parameters/default_dev_flags`
  NEW_SCANFLAGS=$(($OLD_SCANFLAGS|$scan_flags))
  if test "$OLD_SCANFLAGS" != "$NEW_SCANFLAGS"; then
    echo -n "Temporarily setting kernel scanning flags from "
    printf "0x%08x to 0x%08x\n" $OLD_SCANFLAGS $NEW_SCANFLAGS
    echo $NEW_SCANFLAGS > /sys/module/scsi_mod/parameters/default_dev_flags
  else
    unset OLD_SCANFLAGS
  fi
fi  
DMSETUP=$(which dmsetup)
[ -z "$DMSETUP" ] && flush= && mp_enable=
MULTIPATH=$(which multipath)
[ -z "$MULTIPATH" ] && flush= && mp_enable=

echo -n "Scanning SCSI subsystem for new devices"
test -z "$flush" || echo -n ", flush failed multipath devices,"
test -z "$remove" || echo -n " and remove devices that have disappeared"
echo
declare -i found=0
declare -i updated=0
declare -i rmvd=0

if [ -n "$flush" ] ; then
  if [ -x "$MULTIPATH" ] ; then
    flushmpaths 1
  fi
fi

# Update existing mappings
if [ $update -eq 1 ] ; then
  echo "Searching for remapped LUNs"
  findremapped
  # If you've changed the mapping, there's a chance it's a different size
  mpaths=""
  findresized
# Search for resized LUNs
elif [ $resize -eq 1 ] ; then
  echo "Searching for resized LUNs"
  findresized
# Normal rescan mode
else
  for host in $hosts; do
  echo -n "Scanning host $host "
  if test -e /sys/class/fc_host/host$host ; then
    # It's pointless to do a target scan on FC
    issue_lip=/sys/class/fc_host/host$host/issue_lip
    if test -e $issue_lip -a $lipreset -ge 0 ; then
      echo 1 > $issue_lip 2> /dev/null;
      udevadm_settle
      [ $lipreset -gt 0 ] && sleep $lipreset
    fi
    channelsearch=
    idsearch=
  else
    channelsearch=$opt_channelsearch
    idsearch=$opt_idsearch
  fi
  [ -n "$channelsearch" ] && echo -n "channels $channelsearch "
  echo -n "for "
  if [ -n "$idsearch" ] ; then
    echo -n " SCSI target IDs " $idsearch
  else
    echo -n " all SCSI target IDs"
  fi
  if [ -n "$lunsearch" ] ; then
    echo ", LUNs " $lunsearch
  else
    echo ", all LUNs"
  fi

  if [ -n "$existing_targets" ] ; then
    searchexisting
  else
    dosearch
  fi
  done
  if test -n "$OLD_SCANFLAGS"; then
    echo $OLD_SCANFLAGS > /sys/module/scsi_mod/parameters/default_dev_flags
  fi
fi

let rmvd_found=$rmvd+$found
if test -n "$mp_enable" -a $rmvd_found -gt 0 ; then
  echo "Attempting to update multipath devices..."
  if test $rmvd -gt 0 ; then
    udevadm_settle
    echo "Removing multipath mappings for removed devices if all paths are now failed... "
    flushmpaths 1
  fi
  if test $found -gt 0 ; then
    /bin/udevadm trigger --sysname-match=sd*
    udevadm_settle
    if [ -x "$MULTIPATH" ] ; then
      echo "Trying to discover new multipath mappings for newly discovered devices... "
      $MULTIPATH | grep "create:" 2> /dev/null
    fi
  fi 
fi

echo "$found new or changed device(s) found.          "
if test ! -z "$FOUNDDEVS" ; then
  printf "$FOUNDDEVS"
fi
echo "$updated remapped or resized device(s) found."
if test ! -z "$CHGDEVS" ; then
  printf "$CHGDEVS"
fi
echo "$rmvd device(s) removed.                 "
if test ! -z "$RMVDDEVS" ; then
  printf "$RMVDDEVS"
fi

# Local Variables:
# sh-basic-offset: 2
# End: