Create missing /dev files where needed.
[thirdparty/mdadm.git] / mdopen.c
1 /*
2  * mdadm - manage Linux "md" devices aka RAID arrays.
3  *
4  * Copyright (C) 2001-2002 Neil Brown <neilb@cse.unsw.edu.au>
5  *
6  *
7  *    This program is free software; you can redistribute it and/or modify
8  *    it under the terms of the GNU General Public License as published by
9  *    the Free Software Foundation; either version 2 of the License, or
10  *    (at your option) any later version.
11  *
12  *    This program is distributed in the hope that it will be useful,
13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *    GNU General Public License for more details.
16  *
17  *    You should have received a copy of the GNU General Public License
18  *    along with this program; if not, write to the Free Software
19  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  *
21  *    Author: Neil Brown
22  *    Email: <neilb@cse.unsw.edu.au>
23  *    Paper: Neil Brown
24  *           School of Computer Science and Engineering
25  *           The University of New South Wales
26  *           Sydney, 2052
27  *           Australia
28  */
29
30 #include "mdadm.h"
31 #include "md_p.h"
32 #include <ctype.h>
33
34 void make_parts(char *dev, int cnt)
35 {
36         /* make 'cnt' partition devices for 'dev'
37          * We use the major/minor from dev and add 1..cnt
38          * If dev ends with a digit, we add "p%d" else "%d"
39          * If the name exists, we use it's owner/mode,
40          * else that of dev
41          */
42         struct stat stb;
43         int major, minor;
44         int i;
45         int nlen = strlen(dev) + 20;
46         char *name = malloc(nlen);
47         int dig = isdigit(dev[strlen(dev)-1]);
48
49         if (stat(dev, &stb)!= 0)
50                 return;
51         if (!S_ISBLK(stb.st_mode))
52                 return;
53         major = major(stb.st_rdev);
54         minor = minor(stb.st_rdev);
55         for (i=1; i <= cnt ; i++) {
56                 struct stat stb2;
57                 snprintf(name, nlen, "%s%s%d", dev, dig?"p":"", i);
58                 if (stat(name, &stb2)==0) {
59                         if (!S_ISBLK(stb2.st_mode))
60                                 continue;
61                         if (stb2.st_rdev == makedev(major, minor+i))
62                                 continue;
63                         unlink(name);
64                 } else {
65                         stb2 = stb;
66                 }
67                 if (mknod(name, S_IFBLK | 0600, makedev(major, minor+i)))
68                         perror("mknod");
69                 if (chown(name, stb2.st_uid, stb2.st_gid))
70                         perror("chown");
71                 if (chmod(name, stb2.st_mode & 07777))
72                         perror("chmod");
73                 stat(name, &stb2);
74                 add_dev(name, &stb2, 0, NULL);
75         }
76 }
77
78 /*
79  * Open a given md device, and check that it really is one.
80  * If 'autof' is given, then we need to create, or recreate, the md device.
81  * If the name already exists, and is not a block device, we fail.
82  * If it exists and is not an md device, is not the right type (partitioned or not),
83  * or is currently in-use, we remove the device, but remember the owner and mode.
84  * If it now doesn't exist, we find a new md array and create the device.
85  * Default ownership is user=0, group=0 perm=0600
86  */
87 int open_mddev(char *dev, int autof)
88 {
89         int mdfd;
90         struct stat stb;
91         int major = MD_MAJOR;
92         int minor = 0;
93         int must_remove = 0;
94         struct mdstat_ent *mdlist;
95         int num;
96
97         if (autof) {
98                 /* autof is set, so we need to check that the name is ok,
99                  * and possibly create one if not
100                  */
101                 if (autof == -2 && !is_standard(dev, NULL)) {
102                         fprintf(stderr, Name ": --auto=yes requires a 'standard' md device name, not %s\n", dev);
103                         return -1;
104                 }
105                 stb.st_mode = 0;
106                 if (stat(dev, &stb)==0 && ! S_ISBLK(stb.st_mode)) {
107                         fprintf(stderr, Name ": %s is not a block device.\n",
108                                 dev);
109                         return -1;
110                 }
111                 /* check major number is correct */
112                 if (autof>0)
113                         major = get_mdp_major();
114                 if (stb.st_mode && major(stb.st_rdev) != major)
115                         must_remove = 1;
116                 if (stb.st_mode && !must_remove) {
117                         mdu_array_info_t array;
118                         /* looks ok, see if it is available */
119                         mdfd = open(dev, O_RDWR, 0);
120                         if (mdfd < 0) {
121                                 fprintf(stderr, Name ": error opening %s: %s\n",
122                                         dev, strerror(errno));
123                                 return -1;
124                         } else if (md_get_version(mdfd) <= 0) {
125                                 fprintf(stderr, Name ": %s does not appear to be an md device\n",
126                                         dev);
127                                 close(mdfd);
128                                 return -1;
129                         }
130                         if (ioctl(mdfd, GET_ARRAY_INFO, &array)==0) {
131                                 /* already active */
132                                 must_remove = 1;
133                                 close(mdfd);
134                         } else {
135                                 if (autof > 0)
136                                         make_parts(dev, autof);
137                                 return mdfd;
138                         }
139                 }
140                 /* Ok, need to find a minor that is not in use.
141                  * If the device name is in a 'standard' format,
142                  * intuit the minor from that, else
143                  * easiest to read /proc/mdstat, and hunt through for
144                  * an unused number 
145                  */
146                 switch(is_standard(dev, &num)) {
147                 case -1: /* non partitioned */
148                         if (autof > 0) {
149                                 fprintf(stderr, Name ": that --auto option not compatable with device named %s\n", dev);
150                                 return -1;
151                         }
152                         minor = num;
153                         num = -1-num;
154                         break;
155                 case 1: /* partitioned */
156                         if (autof == -1) {
157                                 fprintf(stderr, Name ": that --auto option not compatable with device named %s\n", dev);
158                                 return -1;
159                         }
160                         minor = num <<  MdpMinorShift;
161                         major = get_mdp_major();
162                         break;
163                 case 0: /* not standard, pick an unused number */
164                         mdlist = mdstat_read(0, 0);
165                         for (num= (autof>0)?-1:0 ; ; num+= (autof>2)?-1:1) {
166                                 struct mdstat_ent *me;
167                                 for (me=mdlist; me; me=me->next)
168                                         if (me->devnum == num)
169                                                 break;
170                                 if (!me) {
171                                         /* doesn't exist if mdstat.
172                                          * make sure it is new to /dev too
173                                          */
174                                         char *dn;
175                                         if (autof > 0) 
176                                                 minor = (-1-num) << MdpMinorShift;
177                                         else
178                                                 minor = num;
179                                         dn = map_dev(major,minor, 0);
180                                         if (dn==NULL || is_standard(dn, NULL)) {
181                                                 /* this number only used by a 'standard' name,
182                                                  * so it is safe to use
183                                                  */
184                                                 break;
185                                         }
186                                 }
187                         }
188                 }
189                 /* major and minor have been chosen */
190                 
191                 /* If it was a 'standard' name and it is in-use, then
192                  * the device could already be correct
193                  */
194                 if (stb.st_mode && major(stb.st_rdev) == major &&
195                     minor(stb.st_rdev) == minor)
196                         ;
197                 else {
198                         if (major(makedev(major,minor)) != major ||
199                             minor(makedev(major,minor)) != minor) {
200                                 fprintf(stderr, Name ": Need newer C library to use more than 4 partitionable md devices, sorry\n");
201                                 return -1;
202                         }
203                         if (must_remove)
204                                 unlink(dev);
205
206                         if (mknod(dev, S_IFBLK|0600, makedev(major, minor))!= 0) {
207                                 fprintf(stderr, Name ": failed to create %s\n", dev);
208                                 return -1;
209                         }
210                         if (must_remove) {
211                                 if (chown(dev, stb.st_uid, stb.st_gid))
212                                         perror("chown");
213                                 if (chmod(dev, stb.st_mode & 07777))
214                                         perror("chmod");
215                         }
216                         stat(dev, &stb);
217                         add_dev(dev, &stb, 0, NULL);
218                         make_parts(dev,autof);
219                 }
220         }
221         mdfd = open(dev, O_RDWR, 0);
222         if (mdfd < 0)
223                 fprintf(stderr, Name ": error opening %s: %s\n",
224                         dev, strerror(errno));
225         else if (md_get_version(mdfd) <= 0) {
226                 fprintf(stderr, Name ": %s does not appear to be an md device\n",
227                         dev);
228                 close(mdfd);
229                 mdfd = -1;
230         }
231         return mdfd;
232 }
233