d4767e29d15007038b3e4910438c24184aec63ed
[thirdparty/mdadm.git] / Kill.c
1 /*
2  * mdadm - manage Linux "md" devices aka RAID arrays.
3  *
4  * Copyright (C) 2001-2009 Neil Brown <neilb@suse.de>
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@suse.de>
23  *
24  *    Added by Dale Stephenson
25  *    steph@snapserver.com
26  */
27
28 #include        "mdadm.h"
29 #include        "md_u.h"
30 #include        "md_p.h"
31
32 int Kill(char *dev, struct supertype *st, int force, int verbose, int noexcl)
33 {
34         /*
35          * Nothing fancy about Kill.  It just zeroes out a superblock
36          * Definitely not safe.
37          * Returns:
38          *  0 - a zero superblock was successfully written out
39          *  1 - failed to write the zero superblock
40          *  2 - failed to open the device.
41          *  4 - failed to find a superblock.
42          */
43
44         int fd, rv = 0;
45
46         if (force)
47                 noexcl = 1;
48         fd = open(dev, O_RDWR|(noexcl ? 0 : O_EXCL));
49         if (fd < 0) {
50                 if (verbose >= 0)
51                         pr_err("Couldn't open %s for write - not zeroing\n",
52                                 dev);
53                 return 2;
54         }
55         if (st == NULL)
56                 st = guess_super(fd);
57         if (st == NULL || st->ss->init_super == NULL) {
58                 if (verbose >= 0)
59                         pr_err("Unrecognised md component device - %s\n", dev);
60                 close(fd);
61                 return 4;
62         }
63         st->ignore_hw_compat = 1;
64         rv = st->ss->load_super(st, fd, dev);
65         if (rv == 0 || (force && rv >= 2)) {
66                 st->ss->free_super(st);
67                 st->ss->init_super(st, NULL, NULL, "", NULL, NULL,
68                                    INVALID_SECTORS);
69                 if (st->ss->store_super(st, fd)) {
70                         if (verbose >= 0)
71                                 pr_err("Could not zero superblock on %s\n",
72                                         dev);
73                         rv = 1;
74                 } else if (rv) {
75                         if (verbose >= 0)
76                                 pr_err("superblock zeroed anyway\n");
77                         rv = 0;
78                 }
79         }
80         close(fd);
81         return rv;
82 }
83
84 int Kill_subarray(char *dev, char *subarray, int verbose)
85 {
86         /* Delete a subarray out of a container, the subarry must be
87          * inactive.  The subarray string must be a subarray index
88          * number.
89          *
90          * 0 = successfully deleted subarray from all container members
91          * 1 = failed to sync metadata to one or more devices
92          * 2 = failed to find the container, subarray, or other resource
93          *     issue
94          */
95         struct supertype supertype, *st = &supertype;
96         int fd, rv = 2;
97
98         memset(st, 0, sizeof(*st));
99
100         fd = open_subarray(dev, subarray, st, verbose < 0);
101         if (fd < 0)
102                 return 2;
103
104         if (!st->ss->kill_subarray) {
105                 if (verbose >= 0)
106                         pr_err("Operation not supported for %s metadata\n",
107                                st->ss->name);
108                 goto free_super;
109         }
110
111         if (is_subarray_active(subarray, st->devnm)) {
112                 if (verbose >= 0)
113                         pr_err("Subarray-%s still active, aborting\n",
114                                subarray);
115                 goto free_super;
116         }
117
118         if (mdmon_running(st->devnm))
119                 st->update_tail = &st->updates;
120
121         /* ok we've found our victim, drop the axe */
122         rv = st->ss->kill_subarray(st);
123         if (rv) {
124                 if (verbose >= 0)
125                         pr_err("Failed to delete subarray-%s from %s\n",
126                                subarray, dev);
127                 goto free_super;
128         }
129
130         /* FIXME these routines do not report success/failure */
131         if (st->update_tail)
132                 flush_metadata_updates(st);
133         else
134                 st->ss->sync_metadata(st);
135
136         if (verbose >= 0)
137                 pr_err("Deleted subarray-%s from %s, UUIDs may have changed\n",
138                        subarray, dev);
139
140         rv = 0;
141
142  free_super:
143         st->ss->free_super(st);
144         close(fd);
145
146         return rv;
147 }