fix-indent-bug-with-lock-macros-part-two-20040818
[openafs.git] / src / vol / nuke.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #include <afsconfig.h>
11 #include <afs/param.h>
12
13 RCSID
14     ("$Header$");
15
16 #include <rx/xdr.h>
17 #include <afs/afsint.h>
18 #include <stdio.h>
19 #ifdef AFS_PTHREAD_ENV
20 #include <assert.h>
21 #else /* AFS_PTHREAD_ENV */
22 #include <afs/assert.h>
23 #endif /* AFS_PTHREAD_ENV */
24 #include <sys/stat.h>
25 #include <fcntl.h>
26 #include <errno.h>
27 #if defined(AFS_SUN5_ENV) || defined(AFS_NT40_ENV)
28 #include <string.h>
29 #else
30 #include <strings.h>
31 #endif
32
33 #include <afs/assert.h>
34 #include "nfs.h"
35 #include "lwp.h"
36 #include "lock.h"
37 #include <afs/afssyscalls.h>
38 #include "ihandle.h"
39 #include "vnode.h"
40 #include "volume.h"
41 #include "partition.h"
42 #include "viceinode.h"
43 #include "salvage.h"
44 #include "fssync.h"
45
46 #ifdef O_LARGEFILE
47 #define afs_stat        stat64
48 #else /* !O_LARGEFILE */
49 #define afs_stat        stat
50 #endif /* !O_LARGEFILE */
51
52 /*@printflike@*/ extern void Log(const char *format, ...);
53
54
55 struct Lock localLock;
56 char *vol_DevName();
57
58 #define MAXATONCE       100
59 /* structure containing neatly packed set of inodes and the # of times we'll have
60  * to idec them in order to reclaim their storage.  NukeProc, called by ListViceInodes,
61  * builds this list for us.
62  */
63 struct ilist {
64     struct ilist *next;
65     afs_int32 freePtr;          /* first free index in this table */
66     Inode inode[MAXATONCE];     /* inode # */
67     afs_int32 count[MAXATONCE]; /* link count */
68 } *allInodes = 0;
69
70 /* called with a structure specifying info about the inode, and our rock (which
71  * is the volume ID.  Returns true if we should keep this inode, otherwise false.
72  * Note that ainfo->u.param[0] is always the volume ID, for any vice inode.
73  */
74 static int
75 NukeProc(struct ViceInodeInfo *ainfo, afs_int32 avolid)
76 {
77     struct ilist *ti;
78     register afs_int32 i;
79
80 #ifndef AFS_PTHREAD_ENV
81     IOMGR_Poll();               /* poll so we don't kill the RPC connection */
82 #endif /* !AFS_PTHREAD_ENV */
83
84     /* check if this is the volume we're looking for */
85     if (ainfo->u.param[0] != avolid)
86         return 0;               /* don't want this one */
87     /* record the info */
88     if (!allInodes || allInodes->freePtr >= MAXATONCE) {
89         ti = (struct ilist *)malloc(sizeof(struct ilist));
90         memset(ti, 0, sizeof(*ti));
91         ti->next = allInodes;
92         allInodes = ti;
93     } else
94         ti = allInodes;         /* use the one with space */
95     i = ti->freePtr++;          /* find our slot in this mess */
96     ti->inode[i] = ainfo->inodeNumber;
97     ti->count[i] = ainfo->linkCount;
98     return 0;                   /* don't care if anything's written out, actually */
99 }
100
101 /* function called with partition name and volid ID, and which removes all
102  * inodes marked with the specified volume ID.  If the volume is a read-only
103  * clone, we'll only remove the header inodes, since they're the only inodes
104  * marked with that volume ID.  If you want to reclaim all the data, you should
105  * nuke the read-write volume ID.
106  *
107  * Note also that nuking a read-write volume effectively nukes all RO volumes
108  * cloned from that RW volume ID, too, since everything except for their
109  * indices will be gone.
110  */
111 int
112 nuke(char *aname, afs_int32 avolid)
113 {
114     /* first process the partition containing this junk */
115     struct afs_stat tstat;
116     struct ilist *ti, *ni;
117     register afs_int32 code;
118     int i, forceSal;
119     char devName[64], wpath[100];
120     char *lastDevComp;
121 #ifdef AFS_NAMEI_ENV
122 #ifdef AFS_NT40_ENV
123     char path[MAX_PATH];
124 #else
125     char *path;
126     namei_t ufs_name;
127 #endif
128 #endif /* AFS_NAMEI_ENV */
129     IHandle_t *fileH;
130
131     if (avolid == 0)
132         return EINVAL;
133     code = afs_stat(aname, &tstat);
134     if (code) {
135         printf("volnuke: partition %s does not exist.\n", aname);
136         return code;
137     }
138     /* get the device name for the partition */
139 #if defined(AFS_NAMEI_ENV) && !defined(AFS_NT40_ENV)
140     lastDevComp = aname;
141 #else
142 #ifdef AFS_NT40_ENV
143     lastDevComp = &aname[strlen(aname) - 1];
144     *lastDevComp = toupper(*lastDevComp);
145 #else
146     {
147         char *tfile = vol_DevName(tstat.st_dev, wpath);
148         if (!tfile) {
149             printf("volnuke: can't find %s's device.\n", aname);
150             return 1;
151         }
152         strcpy(devName, tfile); /* save this from the static buffer */
153     }
154     /* aim lastDevComp at the 'foo' of '/dev/foo' */
155     lastDevComp = strrchr(devName, '/');
156     /* either points at slash, or there is no slash; adjust appropriately */
157     if (lastDevComp)
158         lastDevComp++;
159     else
160         lastDevComp = devName;
161 #endif /* AFS_NT40_ENV */
162 #endif /* AFS_NAMEI_ENV && !AFS_NT40_ENV */
163
164     ObtainWriteLock(&localLock);
165     /* OK, we have the mounted on place, aname, the device name (in devName).
166      * all we need to do to call ListViceInodes is find the inodes for the
167      * volume we're nuking.
168      */
169 #ifdef AFS_NAMEI_ENV
170     code =
171         ListViceInodes(lastDevComp, aname, NULL, NukeProc, avolid, &forceSal,
172                        0, wpath);
173 #else
174     code =
175         ListViceInodes(lastDevComp, aname, "/tmp/vNukeXX", NukeProc, avolid,
176                        &forceSal, 0, wpath);
177     unlink("/tmp/vNukeXX");     /* clean it up now */
178 #endif
179     if (code == 0) {
180         /* actually do the idecs now */
181         for (ti = allInodes; ti; ti = ti->next) {
182             for (i = 0; i < ti->freePtr; i++) {
183 #ifndef AFS_PTHREAD_ENV
184                 IOMGR_Poll();   /* keep RPC running */
185 #endif /* !AFS_PTHREAD_ENV */
186                 /* idec this inode into oblivion */
187 #ifdef AFS_NAMEI_ENV
188 #ifdef AFS_NT40_ENV
189                 IH_INIT(fileH, (int)(*lastDevComp - 'A'), avolid,
190                         ti->inode[i]);
191                 nt_HandleToName(path, fileH);
192 #else
193                 IH_INIT(fileH, (int)volutil_GetPartitionID(aname), avolid,
194                         ti->inode[i]);
195                 namei_HandleToName(&ufs_name, fileH);
196                 path = ufs_name.n_path;
197 #endif /* AFS_NT40_ENV */
198                 IH_RELEASE(fileH);
199                 if (unlink(path) < 0) {
200                     Log("Nuke: Failed to remove %s\n", path);
201                 }
202 #else /* AFS_NAMEI_ENV */
203                 IH_INIT(fileH, (int)tstat.st_dev, avolid, ti->inode[i]);
204                 {
205                     int j;
206                     for (j = 0; j < ti->count[i]; j++) {
207                         code = IH_DEC(fileH, ti->inode[i], avolid);
208                     }
209                 }
210                 IH_RELEASE(fileH);
211 #endif /* AFS_NAMEI_ENV */
212             }
213             ni = ti->next;
214             free(ti);
215         }
216         code = 0;               /* we really don't care about it except for debugging */
217         allInodes = NULL;
218
219         /* at this point, we should try to remove the volume header file itself.
220          * the volume header file is the file named VNNNNN.vol in the UFS file
221          * system, and is a normal file.  As such, it is not stamped with the
222          * volume's ID in its inode, and has to be removed explicitly.
223          */
224         /* reuse devName buffer now */
225 #ifdef AFS_NT40_ENV
226         afs_snprintf(devName, sizeof devName, "%c:\\%s", *lastDevComp,
227                      VolumeExternalName(avolid));
228 #else
229         afs_snprintf(devName, sizeof devName, "%s/%s", aname,
230                      VolumeExternalName(avolid));
231 #endif /* AFS_NT40_ENV */
232         code = unlink(devName);
233         if (code)
234             code = errno;
235     } else {
236         /* just free things */
237         for (ti = allInodes; ti; ti = ni) {
238             ni = ti->next;
239             free(ti);
240         }
241         allInodes = NULL;
242     }
243     ReleaseWriteLock(&localLock);
244     return code;
245 }