sysfs: Avoid if and return on the same line
[thirdparty/mdadm.git] / sysfs.c
1 /*
2  * sysfs - extract md related information from sysfs.  Part of:
3  * mdadm - manage Linux "md" devices aka RAID arrays.
4  *
5  * Copyright (C) 2006-2009 Neil Brown <neilb@suse.de>
6  *
7  *
8  *    This program is free software; you can redistribute it and/or modify
9  *    it under the terms of the GNU General Public License as published by
10  *    the Free Software Foundation; either version 2 of the License, or
11  *    (at your option) any later version.
12  *
13  *    This program is distributed in the hope that it will be useful,
14  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
15  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  *    GNU General Public License for more details.
17  *
18  *    You should have received a copy of the GNU General Public License
19  *    along with this program; if not, write to the Free Software
20  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  *
22  *    Author: Neil Brown
23  *    Email: <neilb@suse.de>
24  */
25
26 #include        "mdadm.h"
27 #include        <dirent.h>
28 #include        <ctype.h>
29
30 int load_sys(char *path, char *buf, int len)
31 {
32         int fd = open(path, O_RDONLY);
33         int n;
34         if (fd < 0)
35                 return -1;
36         n = read(fd, buf, len);
37         close(fd);
38         if (n <0 || n >= len)
39                 return -1;
40         buf[n] = 0;
41         if (n && buf[n-1] == '\n')
42                 buf[n-1] = 0;
43         return 0;
44 }
45
46 void sysfs_free(struct mdinfo *sra)
47 {
48         while (sra) {
49                 struct mdinfo *sra2 = sra->next;
50                 while (sra->devs) {
51                         struct mdinfo *d = sra->devs;
52                         sra->devs = d->next;
53                         free(d);
54                 }
55                 free(sra);
56                 sra = sra2;
57         }
58 }
59
60 int sysfs_open(char *devnm, char *devname, char *attr)
61 {
62         char fname[50];
63         int fd;
64
65         sprintf(fname, "/sys/block/%s/md/", devnm);
66         if (devname) {
67                 strcat(fname, devname);
68                 strcat(fname, "/");
69         }
70         strcat(fname, attr);
71         fd = open(fname, O_RDWR);
72         if (fd < 0 && errno == EACCES)
73                 fd = open(fname, O_RDONLY);
74         return fd;
75 }
76
77 void sysfs_init_dev(struct mdinfo *mdi, unsigned long devid)
78 {
79         snprintf(mdi->sys_name,
80                  sizeof(mdi->sys_name), "dev-%s", devid2kname(devid));
81 }
82
83 void sysfs_init(struct mdinfo *mdi, int fd, char *devnm)
84 {
85         mdi->sys_name[0] = 0;
86         if (fd >= 0) {
87                 mdu_version_t vers;
88                 if (ioctl(fd, RAID_VERSION, &vers) != 0)
89                         return;
90                 devnm = fd2devnm(fd);
91         }
92         if (devnm == NULL)
93                 return;
94         strcpy(mdi->sys_name, devnm);
95 }
96
97 struct mdinfo *sysfs_read(int fd, char *devnm, unsigned long options)
98 {
99         char fname[PATH_MAX];
100         char buf[PATH_MAX];
101         char *base;
102         char *dbase;
103         struct mdinfo *sra;
104         struct mdinfo *dev, **devp;
105         DIR *dir = NULL;
106         struct dirent *de;
107
108         sra = xcalloc(1, sizeof(*sra));
109         sysfs_init(sra, fd, devnm);
110         if (sra->sys_name[0] == 0) {
111                 free(sra);
112                 return NULL;
113         }
114
115         sprintf(fname, "/sys/block/%s/md/", sra->sys_name);
116         base = fname + strlen(fname);
117
118         sra->devs = NULL;
119         if (options & GET_VERSION) {
120                 strcpy(base, "metadata_version");
121                 if (load_sys(fname, buf, sizeof(buf)))
122                         goto abort;
123                 if (strncmp(buf, "none", 4) == 0) {
124                         sra->array.major_version =
125                                 sra->array.minor_version = -1;
126                         strcpy(sra->text_version, "");
127                 } else if (strncmp(buf, "external:", 9) == 0) {
128                         sra->array.major_version = -1;
129                         sra->array.minor_version = -2;
130                         strcpy(sra->text_version, buf+9);
131                 } else {
132                         sscanf(buf, "%d.%d",
133                                &sra->array.major_version,
134                                &sra->array.minor_version);
135                         strcpy(sra->text_version, buf);
136                 }
137         }
138         if (options & GET_LEVEL) {
139                 strcpy(base, "level");
140                 if (load_sys(fname, buf, sizeof(buf)))
141                         goto abort;
142                 sra->array.level = map_name(pers, buf);
143         }
144         if (options & GET_LAYOUT) {
145                 strcpy(base, "layout");
146                 if (load_sys(fname, buf, sizeof(buf)))
147                         goto abort;
148                 sra->array.layout = strtoul(buf, NULL, 0);
149         }
150         if (options & GET_DISKS) {
151                 strcpy(base, "raid_disks");
152                 if (load_sys(fname, buf, sizeof(buf)))
153                         goto abort;
154                 sra->array.raid_disks = strtoul(buf, NULL, 0);
155         }
156         if (options & GET_DEGRADED) {
157                 strcpy(base, "degraded");
158                 if (load_sys(fname, buf, sizeof(buf)))
159                         goto abort;
160                 sra->array.failed_disks = strtoul(buf, NULL, 0);
161         }
162         if (options & GET_COMPONENT) {
163                 strcpy(base, "component_size");
164                 if (load_sys(fname, buf, sizeof(buf)))
165                         goto abort;
166                 sra->component_size = strtoull(buf, NULL, 0);
167                 /* sysfs reports "K", but we want sectors */
168                 sra->component_size *= 2;
169         }
170         if (options & GET_CHUNK) {
171                 strcpy(base, "chunk_size");
172                 if (load_sys(fname, buf, sizeof(buf)))
173                         goto abort;
174                 sra->array.chunk_size = strtoul(buf, NULL, 0);
175         }
176         if (options & GET_CACHE) {
177                 strcpy(base, "stripe_cache_size");
178                 if (load_sys(fname, buf, sizeof(buf)))
179                         /* Probably level doesn't support it */
180                         sra->cache_size = 0;
181                 else
182                         sra->cache_size = strtoul(buf, NULL, 0);
183         }
184         if (options & GET_MISMATCH) {
185                 strcpy(base, "mismatch_cnt");
186                 if (load_sys(fname, buf, sizeof(buf)))
187                         goto abort;
188                 sra->mismatch_cnt = strtoul(buf, NULL, 0);
189         }
190         if (options & GET_SAFEMODE) {
191                 int scale = 1;
192                 int dot = 0;
193                 unsigned i;
194                 unsigned long msec;
195                 size_t len;
196
197                 strcpy(base, "safe_mode_delay");
198                 if (load_sys(fname, buf, sizeof(buf)))
199                         goto abort;
200
201                 /* remove a period, and count digits after it */
202                 len = strlen(buf);
203                 for (i = 0; i < len; i++) {
204                         if (dot) {
205                                 if (isdigit(buf[i])) {
206                                         buf[i-1] = buf[i];
207                                         scale *= 10;
208                                 }
209                                 buf[i] = 0;
210                         } else if (buf[i] == '.') {
211                                 dot=1;
212                                 buf[i] = 0;
213                         }
214                 }
215                 msec = strtoul(buf, NULL, 10);
216                 msec = (msec * 1000) / scale;
217                 sra->safe_mode_delay = msec;
218         }
219         if (options & GET_BITMAP_LOCATION) {
220                 strcpy(base, "bitmap/location");
221                 if (load_sys(fname, buf, sizeof(buf)))
222                         goto abort;
223                 if (strncmp(buf, "file", 4) == 0)
224                         sra->bitmap_offset = 1;
225                 else if (strncmp(buf, "none", 4) == 0)
226                         sra->bitmap_offset = 0;
227                 else if (buf[0] == '+')
228                         sra->bitmap_offset = strtol(buf+1, NULL, 10);
229                 else
230                         goto abort;
231         }
232
233         if (options & GET_ARRAY_STATE) {
234                 strcpy(base, "array_state");
235                 if (load_sys(fname, sra->sysfs_array_state,
236                              sizeof(sra->sysfs_array_state)))
237                         goto abort;
238         } else
239                 sra->sysfs_array_state[0] = 0;
240
241         if (! (options & GET_DEVS))
242                 return sra;
243
244         /* Get all the devices as well */
245         *base = 0;
246         dir = opendir(fname);
247         if (!dir)
248                 goto abort;
249         sra->array.spare_disks = 0;
250
251         devp = &sra->devs;
252         sra->devs = NULL;
253         while ((de = readdir(dir)) != NULL) {
254                 char *ep;
255                 if (de->d_ino == 0 ||
256                     strncmp(de->d_name, "dev-", 4) != 0)
257                         continue;
258                 strcpy(base, de->d_name);
259                 dbase = base + strlen(base);
260                 *dbase++ = '/';
261
262                 dev = xmalloc(sizeof(*dev));
263
264                 /* Always get slot, major, minor */
265                 strcpy(dbase, "slot");
266                 if (load_sys(fname, buf, sizeof(buf))) {
267                         /* hmm... unable to read 'slot' maybe the device
268                          * is going away?
269                          */
270                         strcpy(dbase, "block");
271                         if (readlink(fname, buf, sizeof(buf)) < 0 &&
272                             errno != ENAMETOOLONG) {
273                                 /* ...yup device is gone */
274                                 free(dev);
275                                 continue;
276                         } else {
277                                 /* slot is unreadable but 'block' link
278                                  * still intact... something bad is happening
279                                  * so abort
280                                  */
281                                 free(dev);
282                                 goto abort;
283                         }
284
285                 }
286                 strcpy(dev->sys_name, de->d_name);
287                 dev->disk.raid_disk = strtoul(buf, &ep, 10);
288                 if (*ep) dev->disk.raid_disk = -1;
289
290                 strcpy(dbase, "block/dev");
291                 if (load_sys(fname, buf, sizeof(buf))) {
292                         /* assume this is a stale reference to a hot
293                          * removed device
294                          */
295                         free(dev);
296                         continue;
297                 }
298                 sra->array.nr_disks++;
299                 sscanf(buf, "%d:%d", &dev->disk.major, &dev->disk.minor);
300
301                 /* special case check for block devices that can go 'offline' */
302                 strcpy(dbase, "block/device/state");
303                 if (load_sys(fname, buf, sizeof(buf)) == 0 &&
304                     strncmp(buf, "offline", 7) == 0) {
305                         free(dev);
306                         continue;
307                 }
308
309                 /* finally add this disk to the array */
310                 *devp = dev;
311                 devp = & dev->next;
312                 dev->next = NULL;
313
314                 if (options & GET_OFFSET) {
315                         strcpy(dbase, "offset");
316                         if (load_sys(fname, buf, sizeof(buf)))
317                                 goto abort;
318                         dev->data_offset = strtoull(buf, NULL, 0);
319                         strcpy(dbase, "new_offset");
320                         if (load_sys(fname, buf, sizeof(buf)) == 0)
321                                 dev->new_data_offset = strtoull(buf, NULL, 0);
322                         else
323                                 dev->new_data_offset = dev->data_offset;
324                 }
325                 if (options & GET_SIZE) {
326                         strcpy(dbase, "size");
327                         if (load_sys(fname, buf, sizeof(buf)))
328                                 goto abort;
329                         dev->component_size = strtoull(buf, NULL, 0) * 2;
330                 }
331                 if (options & GET_STATE) {
332                         dev->disk.state = 0;
333                         strcpy(dbase, "state");
334                         if (load_sys(fname, buf, sizeof(buf)))
335                                 goto abort;
336                         if (strstr(buf, "in_sync"))
337                                 dev->disk.state |= (1<<MD_DISK_SYNC);
338                         if (strstr(buf, "faulty"))
339                                 dev->disk.state |= (1<<MD_DISK_FAULTY);
340                         if (dev->disk.state == 0)
341                                 sra->array.spare_disks++;
342                 }
343                 if (options & GET_ERROR) {
344                         strcpy(buf, "errors");
345                         if (load_sys(fname, buf, sizeof(buf)))
346                                 goto abort;
347                         dev->errors = strtoul(buf, NULL, 0);
348                 }
349         }
350         closedir(dir);
351         return sra;
352
353  abort:
354         if (dir)
355                 closedir(dir);
356         sysfs_free(sra);
357         return NULL;
358 }
359
360 int sysfs_attr_match(const char *attr, const char *str)
361 {
362         /* See if attr, read from a sysfs file, matches
363          * str.  They must either be the same, or attr can
364          * have a trailing newline or comma
365          */
366         while (*attr && *str && *attr == *str) {
367                 attr++;
368                 str++;
369         }
370
371         if (*str || (*attr && *attr != ',' && *attr != '\n'))
372                 return 0;
373         return 1;
374 }
375
376 int sysfs_match_word(const char *word, char **list)
377 {
378         int n;
379         for (n=0; list[n]; n++)
380                 if (sysfs_attr_match(word, list[n]))
381                         break;
382         return n;
383 }
384
385 unsigned long long get_component_size(int fd)
386 {
387         /* Find out the component size of the array.
388          * We cannot trust GET_ARRAY_INFO ioctl as it's
389          * size field is only 32bits.
390          * So look in /sys/block/mdXXX/md/component_size
391          *
392          * This returns in units of sectors.
393          */
394         struct stat stb;
395         char fname[50];
396         int n;
397         if (fstat(fd, &stb))
398                 return 0;
399         if (major(stb.st_rdev) != (unsigned)get_mdp_major())
400                 sprintf(fname, "/sys/block/md%d/md/component_size",
401                         (int)minor(stb.st_rdev));
402         else
403                 sprintf(fname, "/sys/block/md_d%d/md/component_size",
404                         (int)minor(stb.st_rdev)>>MdpMinorShift);
405         fd = open(fname, O_RDONLY);
406         if (fd < 0)
407                 return 0;
408         n = read(fd, fname, sizeof(fname));
409         close(fd);
410         if (n < 0 || n == sizeof(fname))
411                 return 0;
412         fname[n] = 0;
413         return strtoull(fname, NULL, 10) * 2;
414 }
415
416 int sysfs_set_str(struct mdinfo *sra, struct mdinfo *dev,
417                   char *name, char *val)
418 {
419         char fname[50];
420         unsigned int n;
421         int fd;
422
423         sprintf(fname, "/sys/block/%s/md/%s/%s",
424                 sra->sys_name, dev?dev->sys_name:"", name);
425         fd = open(fname, O_WRONLY);
426         if (fd < 0)
427                 return -1;
428         n = write(fd, val, strlen(val));
429         close(fd);
430         if (n != strlen(val)) {
431                 dprintf("failed to write '%s' to '%s' (%s)\n",
432                         val, fname, strerror(errno));
433                 return -1;
434         }
435         return 0;
436 }
437
438 int sysfs_set_num(struct mdinfo *sra, struct mdinfo *dev,
439                   char *name, unsigned long long val)
440 {
441         char valstr[50];
442         sprintf(valstr, "%llu", val);
443         return sysfs_set_str(sra, dev, name, valstr);
444 }
445
446 int sysfs_set_num_signed(struct mdinfo *sra, struct mdinfo *dev,
447                          char *name, long long val)
448 {
449         char valstr[50];
450         sprintf(valstr, "%lli", val);
451         return sysfs_set_str(sra, dev, name, valstr);
452 }
453
454 int sysfs_uevent(struct mdinfo *sra, char *event)
455 {
456         char fname[50];
457         int n;
458         int fd;
459
460         sprintf(fname, "/sys/block/%s/uevent",
461                 sra->sys_name);
462         fd = open(fname, O_WRONLY);
463         if (fd < 0)
464                 return -1;
465         n = write(fd, event, strlen(event));
466         close(fd);
467         if (n != (int)strlen(event)) {
468                 dprintf("failed to write '%s' to '%s' (%s)\n",
469                         event, fname, strerror(errno));
470                 return -1;
471         }
472         return 0;
473 }
474
475 int sysfs_attribute_available(struct mdinfo *sra, struct mdinfo *dev, char *name)
476 {
477         char fname[50];
478         struct stat st;
479
480         sprintf(fname, "/sys/block/%s/md/%s/%s",
481                 sra->sys_name, dev?dev->sys_name:"", name);
482
483         return stat(fname, &st) == 0;
484 }
485
486 int sysfs_get_fd(struct mdinfo *sra, struct mdinfo *dev,
487                        char *name)
488 {
489         char fname[50];
490         int fd;
491
492         sprintf(fname, "/sys/block/%s/md/%s/%s",
493                 sra->sys_name, dev?dev->sys_name:"", name);
494         fd = open(fname, O_RDWR);
495         if (fd < 0)
496                 fd = open(fname, O_RDONLY);
497         return fd;
498 }
499
500 int sysfs_fd_get_ll(int fd, unsigned long long *val)
501 {
502         char buf[50];
503         int n;
504         char *ep;
505
506         lseek(fd, 0, 0);
507         n = read(fd, buf, sizeof(buf));
508         if (n <= 0 || n == sizeof(buf))
509                 return -2;
510         buf[n] = 0;
511         *val = strtoull(buf, &ep, 0);
512         if (ep == buf || (*ep != 0 && *ep != '\n' && *ep != ' '))
513                 return -1;
514         return 0;
515 }
516
517 int sysfs_get_ll(struct mdinfo *sra, struct mdinfo *dev,
518                        char *name, unsigned long long *val)
519 {
520         int n;
521         int fd;
522
523         fd = sysfs_get_fd(sra, dev, name);
524         if (fd < 0)
525                 return -1;
526         n = sysfs_fd_get_ll(fd, val);
527         close(fd);
528         return n;
529 }
530
531 int sysfs_fd_get_two(int fd, unsigned long long *v1, unsigned long long *v2)
532 {
533         /* two numbers in this sysfs file, either
534          *  NNN (NNN)
535          * or
536          *  NNN / NNN
537          */
538         char buf[80];
539         int n;
540         char *ep, *ep2;
541
542         lseek(fd, 0, 0);
543         n = read(fd, buf, sizeof(buf));
544         if (n <= 0 || n == sizeof(buf))
545                 return -2;
546         buf[n] = 0;
547         *v1 = strtoull(buf, &ep, 0);
548         if (ep == buf || (*ep != 0 && *ep != '\n' && *ep != ' '))
549                 return -1;
550         while (*ep == ' ' || *ep == '/' || *ep == '(')
551                 ep++;
552         *v2 = strtoull(ep, &ep2, 0);
553         if (ep2 == ep || (*ep2 != 0 && *ep2 != '\n' && *ep2 != ' ' && *ep2 != ')')) {
554                 *v2 = *v1;
555                 return 1;
556         }
557         return 2;
558 }
559
560 int sysfs_get_two(struct mdinfo *sra, struct mdinfo *dev,
561                   char *name, unsigned long long *v1, unsigned long long *v2)
562 {
563         int n;
564         int fd;
565
566         fd = sysfs_get_fd(sra, dev, name);
567         if (fd < 0)
568                 return -1;
569         n = sysfs_fd_get_two(fd, v1, v2);
570         close(fd);
571         return n;
572 }
573
574 int sysfs_fd_get_str(int fd, char *val, int size)
575 {
576         int n;
577
578         lseek(fd, 0, 0);
579         n = read(fd, val, size);
580         if (n <= 0 || n == size)
581                 return -1;
582         val[n] = 0;
583         return n;
584 }
585
586 int sysfs_get_str(struct mdinfo *sra, struct mdinfo *dev,
587                        char *name, char *val, int size)
588 {
589         int n;
590         int fd;
591
592         fd = sysfs_get_fd(sra, dev, name);
593         if (fd < 0)
594                 return -1;
595         n = sysfs_fd_get_str(fd, val, size);
596         close(fd);
597         return n;
598 }
599
600 int sysfs_set_safemode(struct mdinfo *sra, unsigned long ms)
601 {
602         unsigned long sec;
603         unsigned long msec;
604         char delay[30];
605
606         sec = ms / 1000;
607         msec = ms % 1000;
608
609         sprintf(delay, "%ld.%03ld\n", sec, msec);
610         /*             this '\n' ^ needed for kernels older than 2.6.28 */
611         return sysfs_set_str(sra, NULL, "safe_mode_delay", delay);
612 }
613
614 int sysfs_set_array(struct mdinfo *info, int vers)
615 {
616         int rv = 0;
617         char ver[100];
618         int raid_disks = info->array.raid_disks;
619
620         ver[0] = 0;
621         if (info->array.major_version == -1 &&
622             info->array.minor_version == -2) {
623                 char buf[1024];
624
625                 strcat(strcpy(ver, "external:"), info->text_version);
626
627                 /* meta version might already be set if we are setting
628                  * new geometry for a reshape.  In that case we don't
629                  * want to over-write the 'readonly' flag that is
630                  * stored in the metadata version.  So read the current
631                  * version first, and preserve the flag
632                  */
633                 if (sysfs_get_str(info, NULL, "metadata_version",
634                                   buf, 1024) > 0)
635                         if (strlen(buf) >= 9 && buf[9] == '-')
636                                 ver[9] = '-';
637
638                 if ((vers % 100) < 2 ||
639                     sysfs_set_str(info, NULL, "metadata_version",
640                                   ver) < 0) {
641                         pr_err("This kernel does not support external metadata.\n");
642                         return 1;
643                 }
644         }
645         if (info->array.level < 0)
646                 return 0; /* FIXME */
647         rv |= sysfs_set_str(info, NULL, "level",
648                             map_num(pers, info->array.level));
649         if (info->reshape_active && info->delta_disks != UnSet)
650                 raid_disks -= info->delta_disks;
651         rv |= sysfs_set_num(info, NULL, "raid_disks", raid_disks);
652         rv |= sysfs_set_num(info, NULL, "chunk_size", info->array.chunk_size);
653         rv |= sysfs_set_num(info, NULL, "layout", info->array.layout);
654         rv |= sysfs_set_num(info, NULL, "component_size", info->component_size/2);
655         if (info->custom_array_size) {
656                 int rc;
657
658                 rc = sysfs_set_num(info, NULL, "array_size",
659                                    info->custom_array_size/2);
660                 if (rc && errno == ENOENT) {
661                         pr_err("This kernel does not have the md/array_size attribute, the array may be larger than expected\n");
662                         rc = 0;
663                 }
664                 rv |= rc;
665         }
666
667         if (info->array.level > 0)
668                 rv |= sysfs_set_num(info, NULL, "resync_start", info->resync_start);
669
670         if (info->reshape_active) {
671                 rv |= sysfs_set_num(info, NULL, "reshape_position",
672                                     info->reshape_progress);
673                 rv |= sysfs_set_num(info, NULL, "chunk_size", info->new_chunk);
674                 rv |= sysfs_set_num(info, NULL, "layout", info->new_layout);
675                 rv |= sysfs_set_num(info, NULL, "raid_disks",
676                                     info->array.raid_disks);
677                 /* We don't set 'new_level' here.  That can only happen
678                  * once the reshape completes.
679                  */
680         }
681         return rv;
682 }
683
684 int sysfs_add_disk(struct mdinfo *sra, struct mdinfo *sd, int resume)
685 {
686         char dv[PATH_MAX];
687         char nm[PATH_MAX];
688         char *dname;
689         int rv;
690
691         sprintf(dv, "%d:%d", sd->disk.major, sd->disk.minor);
692         rv = sysfs_set_str(sra, NULL, "new_dev", dv);
693         if (rv)
694                 return rv;
695
696         memset(nm, 0, sizeof(nm));
697         dname = devid2kname(makedev(sd->disk.major, sd->disk.minor));
698         strcpy(sd->sys_name, "dev-");
699         strcpy(sd->sys_name+4, dname);
700
701         /* test write to see if 'recovery_start' is available */
702         if (resume && sd->recovery_start < MaxSector &&
703             sysfs_set_num(sra, sd, "recovery_start", 0)) {
704                 sysfs_set_str(sra, sd, "state", "remove");
705                 return -1;
706         }
707
708         rv = sysfs_set_num(sra, sd, "offset", sd->data_offset);
709         rv |= sysfs_set_num(sra, sd, "size", (sd->component_size+1) / 2);
710         if (sra->array.level != LEVEL_CONTAINER) {
711                 if (sd->recovery_start == MaxSector)
712                         /* This can correctly fail if array isn't started,
713                          * yet, so just ignore status for now.
714                          */
715                         sysfs_set_str(sra, sd, "state", "insync");
716                 if (sd->disk.raid_disk >= 0)
717                         rv |= sysfs_set_num(sra, sd, "slot", sd->disk.raid_disk);
718                 if (resume)
719                         sysfs_set_num(sra, sd, "recovery_start", sd->recovery_start);
720         }
721         return rv;
722 }
723
724 #if 0
725 int sysfs_disk_to_sg(int fd)
726 {
727         /* from an open block device, try find and open its corresponding
728          * scsi_generic interface
729          */
730         struct stat st;
731         char path[256];
732         char sg_path[256];
733         char sg_major_minor[10];
734         char *c;
735         DIR *dir;
736         struct dirent *de;
737         int major, minor, rv;
738
739         if (fstat(fd, &st))
740                 return -1;
741
742         snprintf(path, sizeof(path), "/sys/dev/block/%d:%d/device",
743                  major(st.st_rdev), minor(st.st_rdev));
744
745         dir = opendir(path);
746         if (!dir)
747                 return -1;
748
749         de = readdir(dir);
750         while (de) {
751                 if (strncmp("scsi_generic:", de->d_name,
752                             strlen("scsi_generic:")) == 0)
753                         break;
754                 de = readdir(dir);
755         }
756         closedir(dir);
757
758         if (!de)
759                 return -1;
760
761         snprintf(sg_path, sizeof(sg_path), "%s/%s/dev", path, de->d_name);
762         fd = open(sg_path, O_RDONLY);
763         if (fd < 0)
764                 return fd;
765
766         rv = read(fd, sg_major_minor, sizeof(sg_major_minor));
767         close(fd);
768         if (rv < 0 || rv == sizeof(sg_major_minor))
769                 return -1;
770         else
771                 sg_major_minor[rv - 1] = '\0';
772
773         c = strchr(sg_major_minor, ':');
774         *c = '\0';
775         c++;
776         major = strtol(sg_major_minor, NULL, 10);
777         minor = strtol(c, NULL, 10);
778         snprintf(path, sizeof(path), "/dev/.tmp.md.%d:%d:%d",
779                  (int) getpid(), major, minor);
780         if (mknod(path, S_IFCHR|0600, makedev(major, minor))==0) {
781                         fd = open(path, O_RDONLY);
782                         unlink(path);
783                         return fd;
784         }
785
786         return -1;
787 }
788 #endif
789
790 int sysfs_disk_to_scsi_id(int fd, __u32 *id)
791 {
792         /* from an open block device, try to retrieve it scsi_id */
793         struct stat st;
794         char path[256];
795         DIR *dir;
796         struct dirent *de;
797         int host, bus, target, lun;
798
799         if (fstat(fd, &st))
800                 return 1;
801
802         snprintf(path, sizeof(path), "/sys/dev/block/%d:%d/device/scsi_device",
803                  major(st.st_rdev), minor(st.st_rdev));
804
805         dir = opendir(path);
806         if (!dir)
807                 return 1;
808
809         for (de = readdir(dir); de; de = readdir(dir)) {
810                 int count;
811
812                 if (de->d_type != DT_DIR)
813                         continue;
814
815                 count = sscanf(de->d_name, "%d:%d:%d:%d", &host, &bus, &target, &lun);
816                 if (count == 4)
817                         break;
818         }
819         closedir(dir);
820
821         if (!de)
822                 return 1;
823
824         *id = (host << 24) | (bus << 16) | (target << 8) | (lun << 0);
825         return 0;
826 }
827
828 int sysfs_unique_holder(char *devnm, long rdev)
829 {
830         /* Check that devnm is a holder of rdev,
831          * and is the only holder.
832          * we should be locked against races by
833          * an O_EXCL on devnm
834          * Return values:
835          *  0 - not unique, not even a holder
836          *  1 - unique, this is the only holder.
837          *  2/3 - not unique, there is another holder
838          * -1 - error, cannot find the holders
839          */
840         DIR *dir;
841         struct dirent *de;
842         char dirname[100];
843         char l;
844         int ret = 0;
845         sprintf(dirname, "/sys/dev/block/%d:%d/holders",
846                 major(rdev), minor(rdev));
847         dir = opendir(dirname);
848         if (!dir)
849                 return -1;
850         l = strlen(dirname);
851         while ((de = readdir(dir)) != NULL) {
852                 char buf[100];
853                 char *sl;
854                 int n;
855
856                 if (de->d_ino == 0)
857                         continue;
858                 if (de->d_name[0] == '.')
859                         continue;
860                 strcpy(dirname+l, "/");
861                 strcat(dirname+l, de->d_name);
862                 n = readlink(dirname, buf, sizeof(buf)-1);
863                 if (n <= 0)
864                         continue;
865                 buf[n] = 0;
866                 sl = strrchr(buf, '/');
867                 if (!sl)
868                         continue;
869                 sl++;
870
871                 if (strcmp(devnm, sl) == 0)
872                         ret |= 1;
873                 else
874                         ret |= 2;
875         }
876         closedir(dir);
877         return ret;
878 }
879
880 int sysfs_freeze_array(struct mdinfo *sra)
881 {
882         /* Try to freeze resync/rebuild on this array/container.
883          * Return -1 if the array is busy,
884          * return 0 if this kernel doesn't support 'frozen'
885          * return 1 if it worked.
886          */
887         char buf[20];
888
889         if (!sysfs_attribute_available(sra, NULL, "sync_action"))
890                 return 1; /* no sync_action == frozen */
891         if (sysfs_get_str(sra, NULL, "sync_action", buf, 20) <= 0)
892                 return 0;
893         if (strcmp(buf, "frozen\n") == 0)
894                 /* Already frozen */
895                 return 0;
896         if (strcmp(buf, "idle\n") != 0 && strcmp(buf, "recover\n") != 0)
897                 return -1;
898         if (sysfs_set_str(sra, NULL, "sync_action", "frozen") < 0)
899                 return 0;
900         return 1;
901 }
902
903 int sysfs_wait(int fd, int *msec)
904 {
905         /* Wait up to '*msec' for fd to have an exception condition.
906          * if msec == NULL, wait indefinitely.
907          */
908         fd_set fds;
909         int n;
910         FD_ZERO(&fds);
911         FD_SET(fd, &fds);
912         if (msec == NULL)
913                 n = select(fd+1, NULL, NULL, &fds, NULL);
914         else if (*msec < 0)
915                 n = 0;
916         else {
917                 struct timeval start, end, tv;
918                 gettimeofday(&start, NULL);
919                 if (*msec < 1000) {
920                         tv.tv_sec = 0;
921                         tv.tv_usec = (*msec)*1000;
922                 } else {
923                         tv.tv_sec = (*msec)/1000;
924                         tv.tv_usec = 0;
925                 }
926                 n = select(fd+1, NULL, NULL, &fds, &tv);
927                 gettimeofday(&end, NULL);
928                 end.tv_sec -= start.tv_sec;
929                 *msec -= (end.tv_sec * 1000 + end.tv_usec/1000
930                           - start.tv_usec/1000) + 1;
931         }
932         return n;
933 }