dir: Prototype and function name cleanup
[openafs.git] / src / volser / vol_split.c
1 /*
2  * Copyright (c) 2007, Hartmut Reuter,
3  * RZG, Max-Planck-Institut f. Plasmaphysik.
4  * All Rights Reserved.
5  *
6  */
7
8 #include <afsconfig.h>
9 #include <afs/param.h>
10
11 #include <roken.h>
12
13 #ifdef HAVE_SYS_FILE_H
14 #include <sys/file.h>
15 #endif
16
17 #if defined(AFS_NAMEI_ENV) && !defined(AFS_NT40_ENV)
18 #include <afs/afs_assert.h>
19 #include <afs/dir.h>
20 #include <rx/xdr.h>
21 #include <afs/afsint.h>
22 #include <afs/nfs.h>
23 #include <lwp.h>
24 #include <lock.h>
25 #include <afs/afssyscalls.h>
26 #include <afs/ihandle.h>
27 #include <afs/vnode.h>
28 #include <afs/volume.h>
29 #include <afs/partition.h>
30 #include <afs/viceinode.h>
31
32 #include "vol.h"
33 #include "volint.h"
34 #include "volser.h"
35 #include "physio.h"
36 #include "volser_internal.h"
37 #ifdef AFS_RXOSD_SUPPORT
38 #include "rxosd.h"
39 #include "vol_osd.h"
40 #include "../vol/vol_osd_prototypes.h"
41 #endif
42
43 #define NEEDED  1
44 #define PARENT  2
45 #define CHANGEPARENT 4
46
47 #define NAMEI_VNODEMASK    0x03ffffff
48 #define NAMEI_TAGMASK      0x7
49 #define NAMEI_TAGSHIFT     26
50 #define NAMEI_UNIQMASK     0xffffffff
51 #define NAMEI_UNIQSHIFT    32
52
53 struct VnodeExtract {
54     afs_uint32 vN;
55     afs_uint32 parent;
56     afs_uint32 flag;
57 };
58
59 struct Msg {
60     struct rx_call * call;
61     int verbose;
62     char line[1024];
63 };
64
65 static afs_int32
66 ExtractVnodes(struct Msg *m, Volume *vol, afs_int32 class,
67               struct VnodeExtract **list,
68               afs_uint32 *length, afs_uint32 where,
69               struct VnodeDiskObject *vd,
70               afs_uint32 *parent, struct VnodeDiskObject *parentvd)
71 {
72     afs_int32 code = 0;
73     char buf[SIZEOF_LARGEDISKVNODE];
74     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)&buf;
75     FdHandle_t *fdP = 0;
76     StreamHandle_t *stream = 0;
77     struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
78     struct VnodeExtract *e;
79     afs_sfsize_t size;
80     afs_foff_t offset;
81
82     *length = 0;
83     if (parent)
84         *parent = 0;
85
86     fdP = IH_OPEN(vol->vnodeIndex[class].handle);
87     if (!fdP) {
88         sprintf(m->line, "Couldn't open %s Index of volume %u\n",
89                 class ? "small":"large", V_id(vol));
90         rx_Write(m->call, m->line, strlen(m->line));
91         code = EIO;
92         goto Bad_Extract;
93     }
94     size = FDH_SIZE(fdP);
95     *list = (struct VnodeExtract *) malloc(size / vcp->diskSize
96                                         * sizeof(struct VnodeExtract));
97     if (!(*list)) {
98         code = ENOMEM;
99         goto Bad_Extract;
100     }
101     memset(*list, 0, size / vcp->diskSize * sizeof(struct VnodeExtract));
102     stream = FDH_FDOPEN(fdP, "r");
103     if (!stream) {
104         sprintf(m->line, "Couldn't stream open %s Index of volume %u\n",
105                 class ? "small":"large", V_id(vol));
106         rx_Write(m->call, m->line, strlen(m->line));
107         code = EIO;
108         goto Bad_Extract;
109     }
110     code = STREAM_ASEEK(stream, vcp->diskSize);
111     if (code)
112         goto Bad_Extract;
113
114     offset = vcp->diskSize;
115     e = *list;
116     while (!STREAM_EOF(stream)) {
117         afs_int32 vN = (offset >> (vcp->logSize -1)) - 1 + class;
118         if (STREAM_READ(vnode, vcp->diskSize, 1, stream) == 1) {
119             if (vnode->type != vNull) {
120                 e->vN = vN;
121                 e->parent = vnode->parent;
122                 if (vN == where && class == vLarge) {
123                     memcpy(vd, vnode, vcp->diskSize);
124                     *parent = vnode->parent;
125                 }
126                 e++;
127             }
128             offset += vcp->diskSize;
129         }
130     }
131     *length = (e - *list);
132     if (class == vLarge) {
133         if (*parent) {
134             offset = (*parent + 1 - class) << (vcp->logSize -1);
135             code = STREAM_ASEEK(stream, offset);
136             if (STREAM_READ(vnode, vcp->diskSize, 1, stream) == 1)
137                 memcpy(parentvd, vnode, vcp->diskSize);
138             else
139                 code = EIO;
140         } else {
141             sprintf(m->line, "SplitVolume: extract didn't see directory %u\n", where);
142             rx_Write(m->call, m->line, strlen(m->line));
143             code = ENOENT;
144         }
145     }
146     if (m->verbose) {
147         sprintf(m->line, "Volume %u has %u %s vnodes in volume %u\n",
148                         V_parentId(vol), *length, class? "small":"large",
149                         V_id(vol));
150         rx_Write(m->call, m->line, strlen(m->line));
151     }
152
153 Bad_Extract:
154     if (stream)
155         STREAM_CLOSE(stream);
156     if (fdP)
157         FDH_CLOSE(fdP);
158     if (code) {
159         free(*list);
160         *list = 0;
161     }
162     return code;
163 }
164
165 static afs_int32
166 FindVnodes(struct Msg *m, afs_uint32 where,
167            struct VnodeExtract *list, afs_int32 length,
168            struct VnodeExtract *dlist, afs_int32 dlength,
169            afs_uint32 *needed, afs_int32 class)
170 {
171     afs_int32 i, j, found = 0;
172     afs_int32 parent = 0;
173
174     *needed = 0;
175     for (i=0; i<length; i++) {
176         if (list[i].vN == where) {        /* dir to be replaced by mount point */
177             list[i].flag |= NEEDED;
178             parent = list[i].parent;
179             found = 1;
180             (*needed)++;
181         }
182         if (list[i].parent == where) {          /* all 1st generation children */
183             list[i].flag |= (NEEDED + CHANGEPARENT);
184             (*needed)++;
185         }
186     }
187     if (list[0].vN & 1) {               /* only for directories */
188         if (!found) {
189             sprintf(m->line,
190                 "SplitVolume: directory %u where to start new volume not found\n",
191                  where);
192             rx_Write(m->call, m->line, strlen(m->line));
193             return ENOENT;
194         }
195         found = 0;
196         for (i=0; i<length; i++) {
197             if (list[i].vN == parent) { /* dir where to create mount point */
198                 list[i].flag |= PARENT;
199                 found = 1;
200                 break;
201             }
202         }
203         if (!found) {
204             sprintf(m->line, "SplitVolume: parent directory %u not found\n",
205                         parent);
206             rx_Write(m->call, m->line, strlen(m->line));
207             return ENOENT;
208         }
209     }
210     found = 1;
211     while (found) {
212         found = 0;
213         for (i=0; i<dlength; i++) {
214             if (!(dlist[i].flag & NEEDED)) /* dirs to remain in old volume */
215                 continue;
216             for (j=0; j<length; j++) {
217                 if (list[j].parent == dlist[i].vN && !(list[j].flag & NEEDED)) {
218                     list[j].flag |= NEEDED;
219                     (*needed)++;
220                     found = 1;
221                 }
222             }
223         }
224     }
225     if (m->verbose) {
226         sprintf(m->line, "%u %s vnodes will go into the new volume\n",
227                         *needed, class ? "small" : "large");
228         rx_Write(m->call, m->line, strlen(m->line));
229     }
230     return 0;
231 }
232
233 static afs_int32
234 copyDir(struct Msg *m, IHandle_t *inh, IHandle_t *outh)
235 {
236     FdHandle_t *infdP, *outfdP;
237     char *tbuf;
238     afs_sfsize_t size;
239     afs_foff_t offset;
240
241     infdP = IH_OPEN(inh);
242     if (!infdP) {
243         sprintf(m->line, "Couldn't open input directory %u.%u.%u\n",
244                     infdP->fd_ih->ih_vid,
245                     (afs_uint32)(infdP->fd_ih->ih_ino & NAMEI_VNODEMASK),
246                     (afs_uint32)(infdP->fd_ih->ih_ino >> NAMEI_UNIQSHIFT));
247         rx_Write(m->call, m->line, strlen(m->line));
248         return EIO;
249     }
250     outfdP = IH_OPEN(outh);
251     if (!outfdP) {
252         sprintf(m->line, "Couldn't open output directory %u.%u.%u\n",
253                     outfdP->fd_ih->ih_vid,
254                     (afs_uint32)(outfdP->fd_ih->ih_ino & NAMEI_VNODEMASK),
255                     (afs_uint32)(outfdP->fd_ih->ih_ino >> NAMEI_UNIQSHIFT));
256         rx_Write(m->call, m->line, strlen(m->line));
257         FDH_REALLYCLOSE(infdP);
258         return EIO;
259     }
260     tbuf = malloc(2048);
261     offset = 0;
262     size = FDH_SIZE(infdP);
263     while (size) {
264         size_t tlen;
265         tlen = size > 2048 ? 2048 : size;
266         if (FDH_PREAD(infdP, tbuf, tlen, offset) != tlen) {
267             sprintf(m->line, "Couldn't read directory %u.%u.%u\n",
268                     infdP->fd_ih->ih_vid,
269                     (afs_uint32)(infdP->fd_ih->ih_ino & NAMEI_VNODEMASK),
270                     (afs_uint32)(infdP->fd_ih->ih_ino >> NAMEI_UNIQSHIFT));
271             rx_Write(m->call, m->line, strlen(m->line));
272             FDH_REALLYCLOSE(infdP);
273             FDH_REALLYCLOSE(outfdP);
274             free(tbuf);
275             return EIO;
276         }
277         if (FDH_PWRITE(outfdP, tbuf, tlen, offset) != tlen) {
278             sprintf(m->line, "Couldn't write directory %u.%u.%u\n",
279                     outfdP->fd_ih->ih_vid,
280                     (afs_uint32)(outfdP->fd_ih->ih_ino & NAMEI_VNODEMASK),
281                     (afs_uint32)(outfdP->fd_ih->ih_ino >> NAMEI_UNIQSHIFT));
282             rx_Write(m->call, m->line, strlen(m->line));
283             FDH_REALLYCLOSE(infdP);
284             FDH_REALLYCLOSE(outfdP);
285             free(tbuf);
286             return EIO;
287         }
288         size -= tlen;
289         offset += tlen;
290     }
291     free(tbuf);
292     FDH_CLOSE(outfdP);
293     FDH_REALLYCLOSE(infdP);
294     return 0;
295 }
296
297 afs_int32 copyVnodes(struct Msg *m, Volume *vol, Volume *newvol,
298                         afs_int32 class,
299                         struct VnodeExtract *list, afs_int32 length,
300                         afs_int32 where, afs_uint64 *blocks,
301                         struct VnodeDiskObject *parVnode)
302 {
303     afs_int32 i, code = 0;
304     char buf[SIZEOF_LARGEDISKVNODE];
305     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)&buf;
306     FdHandle_t *fdP = 0;
307     FdHandle_t *newfdP = 0;
308     struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
309     struct VnodeExtract *e;
310     afs_sfsize_t size;
311     afs_uint64 offset;
312     Inode ino, newino;
313
314     fdP = IH_OPEN(vol->vnodeIndex[class].handle);
315     if (!fdP) {
316         Log("Couldn't open %s Index of volume %u\n",
317                 class ? "small":"large", V_id(vol));
318         code = EIO;
319         goto Bad_Copy;
320     }
321     newfdP = IH_OPEN(newvol->vnodeIndex[class].handle);
322     if (!newfdP) {
323         Log("Couldn't open %s Index of volume %u\n",
324                 class ? "small":"large", V_id(newvol));
325         code = EIO;
326         goto Bad_Copy;
327     }
328     size = FDH_SIZE(fdP);
329
330     for (i=0; i<length; i++) {
331         e = &list[i];
332         if (e->flag) {
333             afs_uint64 size;
334             offset = (e->vN + 1 - class) << (vcp->logSize -1);
335             if (FDH_PREAD(fdP, vnode, vcp->diskSize, offset) != vcp->diskSize) {
336                 Log("Couldn't read in %s Index of volume %u at offset %llu\n",
337                     class ? "small":"large", V_id(vol), offset);
338                 code = EIO;
339                 goto Bad_Copy;
340             }
341             if (e->flag & PARENT) {
342                 /*
343                  *   do a preventive copy on write for later update
344                  */
345                 IHandle_t *newh = 0;
346                 IHandle_t *h = 0;
347 #if defined(NEARINODE_HINT) && !defined(AFS_NAMEI_ENV)
348                 Inode nearInode;
349                 V_pref(vol,nearInode)
350 #endif
351
352                 newino = IH_CREATE(V_linkHandle(vol), V_device(vol),
353                                 VPartitionPath(V_partition(vol)),
354                                 nearInode, V_parentId(vol),
355                                 e->vN, vnode->uniquifier,
356                                 vnode->dataVersion);
357                 IH_INIT(newh, V_device(vol), V_parentId(vol), newino);
358                 ino = VNDISK_GET_INO(vnode);
359                 IH_INIT(h, V_device(vol), V_parentId(vol), ino);
360                 code = copyDir(m, h, newh);
361                 if (code)
362                     goto Bad_Copy;
363                 /* Now update the vnode and write it back to disk */
364                 VNDISK_SET_INO(vnode, newino);
365                 vnode->cloned = 0;
366                 if (FDH_PWRITE(fdP, vnode, vcp->diskSize, offset) != vcp->diskSize) {
367                     Log("Couldn't write in %s Index of volume %u at offset %llu\n",
368                         class ? "small":"large", V_id(vol), offset);
369                     code = EIO;
370                     goto Bad_Copy;
371                 }
372                 memcpy(parVnode, vnode, sizeof(struct VnodeDiskObject));
373             }
374             if (e->flag & NEEDED && e->vN != where) {
375                 VNDISK_GET_LEN(size, vnode);
376                 *blocks += (size + 0x3ff) >> 10;
377                 ino = VNDISK_GET_INO(vnode);
378                 if (ino) {
379                     IHandle_t *h, *newh;
380                     Inode nearInode;
381 #if defined(NEARINODE_HINT) && !defined(AFS_NAMEI_ENV)
382                     V_pref(vol,nearInode)
383 #endif
384                     IH_INIT(h, vol->device, V_parentId(vol), ino);
385                     if (e->parent == where)
386                         vnode->parent = 1;
387                     newino = IH_CREATE(V_linkHandle(newvol), V_device(newvol),
388                                 VPartitionPath(V_partition(newvol)),
389                                 nearInode, V_parentId(newvol),
390                                 e->vN, vnode->uniquifier,
391                                 vnode->dataVersion);
392                     if (!VALID_INO(newino)) {
393                         Log("IH_CREATE failed for %u.%u.%u\n",
394                             V_id(newvol), e->vN, vnode->uniquifier);
395                         code = EIO;
396                         goto Bad_Copy;
397                     }
398                     nearInode = newino;
399                     IH_INIT(newh, newvol->device, V_parentId(newvol), newino);
400                     code = namei_replace_file_by_hardlink(newh, h);
401                     VNDISK_SET_INO(vnode, newino);
402 #ifdef AFS_RXOSD_SUPPORT
403                 } else {
404                     code = osd_split_objects(vol, newvol, vnode, e->vN);
405 #endif /*  AFS_RXOSD_SUPPORT */
406                 }
407                 if (code)
408                     goto Bad_Copy;
409                 if (e->flag & CHANGEPARENT)
410                     vnode->parent = 1; /* in new root-directory */
411                 vnode->cloned = 0;
412                 if (FDH_PWRITE(newfdP, vnode, vcp->diskSize, offset) != vcp->diskSize) {
413                     Log("Couldn't write in %s Index of volume %u to offset %llu\n",
414                         class ? "small":"large", V_id(newvol), offset);
415                     code = EIO;
416                     goto Bad_Copy;
417                 }
418             }
419         }
420     }
421     /*
422      *  Now copy the root directory from old to new volume
423      */
424     if (class == vLarge) {
425         IHandle_t *h, *newh;
426         char buf2[SIZEOF_LARGEDISKVNODE];
427         struct VnodeDiskObject *vnode2 = (struct VnodeDiskObject *)&buf2;
428         afs_uint64 newoffset;
429
430         newoffset = vcp->diskSize;
431         if (FDH_PREAD(newfdP, vnode2, vcp->diskSize, newoffset) != vcp->diskSize) {
432             Log("splitvolume: couldn't read in large Index of new volume %u at offset %u\n",
433                     V_id(newvol), vcp->diskSize);
434             code = EIO;
435             goto Bad_Copy;
436         }
437         offset = (where + 1 - class) << (vcp->logSize -1);
438         if (FDH_PREAD(fdP, vnode, vcp->diskSize, offset) != vcp->diskSize) {
439             Log("Couldn't read in large Index of old volume %u at offset %llu\n",
440                 V_id(vol), offset);
441             code = EIO;
442             goto Bad_Copy;
443         }
444         VNDISK_GET_LEN(size, vnode);
445         *blocks += (size + 0x3ff) >> 10;
446         ino = VNDISK_GET_INO(vnode);
447         IH_INIT(h, vol->device, V_parentId(vol), ino);
448         newino = VNDISK_GET_INO(vnode2);
449         IH_INIT(newh, newvol->device, V_parentId(newvol), newino);
450         code = copyDir(m, h, newh);
451         if (code) {
452             Log("splitvolume: copyDir failed for new root from "
453                 "%u.%u.%u to %u.1.1\n",
454                 V_id(vol), where, vnode->uniquifier, V_id(newvol));
455             code = EIO;
456             goto Bad_Copy;
457         }
458         VNDISK_SET_INO(vnode, newino);
459         vnode->uniquifier = 1;
460         vnode->cloned = 0;
461         vnode->parent = vnode2->parent;
462         vnode->serverModifyTime = vnode2->serverModifyTime;
463         if (FDH_PWRITE(newfdP, vnode, vcp->diskSize, newoffset) != vcp->diskSize) {
464             Log("splitvolume: couldn't write in large Index of %u at offset %u\n",
465                     V_id(newvol), vcp->diskSize);
466             code = EIO;
467         }
468     }
469 Bad_Copy:
470     if (fdP)
471         FDH_CLOSE(fdP);
472     if (newfdP)
473         FDH_CLOSE(newfdP);
474     return code;
475 }
476
477 static afs_int32
478 findName(Volume *vol, struct VnodeDiskObject *vd, afs_uint32 vN,
479          afs_uint32 un, char *name,afs_int32 length)
480 {
481     afs_int32 code;
482     Inode ino;
483     DirHandle dir;
484
485     ino = VNDISK_GET_INO(vd);
486     SetSalvageDirHandle(&dir, V_id(vol), V_device(vol), ino);
487
488     code = afs_dir_InverseLookup(&dir, vN, un, name, length);
489     FidZap(&dir);
490     return code;
491 }
492
493 static afs_int32
494 createMountpoint(Volume *vol, Volume *newvol, struct VnodeDiskObject *parent,
495                 afs_uint32 vN,  struct VnodeDiskObject *vd, char *name)
496 {
497     afs_int32 code;
498     Inode ino, newino;
499     DirHandle dir;
500     IHandle_t *h;
501     struct VnodeDiskObject vnode;
502     FdHandle_t *fdP, *fdP2;
503     afs_uint64 size;
504     afs_foff_t offset;
505     afs_int32 class = vSmall;
506     struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
507 #if defined(NEARINODE_HINT) && !defined(AFS_NAMEI_ENV)
508     Inode nearInode = 0;
509 #endif
510     AFSFid fid;
511     struct timeval now;
512     afs_uint32 newvN;
513     char symlink[32];
514     ssize_t rc;
515
516     FT_GetTimeOfDay(&now, 0);
517     fdP = IH_OPEN(vol->vnodeIndex[vSmall].handle);
518     if (!fdP) {
519         Log("split volume: error opening small vnode index of %u\n", V_id(vol));
520         return EIO;
521     }
522     offset = vcp->diskSize;
523     while (1) {
524         rc = FDH_PREAD(fdP, &vnode, vcp->diskSize, offset);
525         if (rc != vcp->diskSize) {
526             if (rc < 0) {
527                 Log("split volume: error reading small vnode index of %u\n", V_id(vol));
528                 return EIO;
529              }
530              if (rc == 0)
531                  break;
532              if (rc < vcp->diskSize)
533                  break;
534         }
535         if (vnode.type == vNull)
536             break;
537         offset += vcp->diskSize;
538     }
539     memset(&vnode, 0, sizeof(vnode));
540     vnode.type = vSymlink;
541     V_nextVnodeUnique(vol)++;
542     vnode.uniquifier = V_nextVnodeUnique(vol);
543     vnode.author = vd->author;
544     vnode.owner = vd->owner;
545     vnode.group = vd->group;
546     vnode.modeBits = 0644;
547     vnode.unixModifyTime = now.tv_sec;
548     vnode.serverModifyTime = now.tv_sec;
549     vnode.dataVersion = 1;
550     vnode.linkCount = 1;
551     vnode.parent = vN;
552
553     newvN = (offset >> (VnodeClassInfo[class].logSize - 1)) - 1 + class;
554 #if defined(NEARINODE_HINT) && !defined(AFS_NAMEI_ENV)
555     V_pref(vol,nearInode)
556 #endif
557     newino = IH_CREATE(V_linkHandle(vol), V_device(vol),
558                 VPartitionPath(V_partition(vol)), nearInode,
559                 V_parentId(vol), newvN, vnode.uniquifier, 1);
560
561     IH_INIT(h, V_device(vol), V_parentId(vol), newino);
562     fdP2 = IH_OPEN(h);
563     if (!fdP2) {
564         Log("split volume: couldn't open inode for mountpoint %u.%u.%u\n",
565                 V_id(vol), newvN, vnode.uniquifier);
566         return EIO;
567     }
568     sprintf(symlink, "#%s", V_name(newvol));
569     size = strlen(symlink) + 1;
570     if (FDH_PWRITE(fdP2, symlink, size, 0) != size) {
571         Log("split volume: couldn't write mountpoint %u.%u.%u\n",
572                 V_id(vol), newvN, vnode.uniquifier);
573         return EIO;
574     }
575     FDH_REALLYCLOSE(fdP2);
576     IH_RELEASE(h);
577     VNDISK_SET_INO(&vnode, newino);
578     VNDISK_SET_LEN(&vnode, size);
579 #ifndef AFS_RXOSD_SUPPORT
580     vnode.vnodeMagic = SMALLVNODEMAGIC;
581 #endif
582     if (FDH_PWRITE(fdP, &vnode, vcp->diskSize, offset) != vcp->diskSize) {
583         Log("split volume: couldn't write vnode for mountpoint %u.%u.%u\n",
584                 V_id(vol), newvN, vnode.uniquifier);
585         return EIO;
586     }
587     FDH_REALLYCLOSE(fdP);
588
589     fid.Volume = V_id(vol);
590     fid.Vnode = newvN;
591     fid.Unique = vnode.uniquifier;
592
593     /*
594      * Now  update the parent directory.
595      */
596
597     ino = VNDISK_GET_INO(parent);
598     SetSalvageDirHandle(&dir, V_id(vol), V_device(vol), ino);
599
600     code = afs_dir_Delete(&dir, name);
601     if (code) {
602         Log("splitvolume: couldn't delete directory entry for %s in %u.%u.%u, code = %d\n",
603                         name, V_id(vol), vN, parent->uniquifier, code);
604         return code;
605     }
606     code = afs_dir_Create(&dir, name, &fid);
607     FidZap(&dir);
608
609     class = vLarge;
610     vcp = &VnodeClassInfo[class];
611     fdP = IH_OPEN(vol->vnodeIndex[class].handle);
612     offset = (vN + 1 - class) << (vcp->logSize -1);
613     parent->dataVersion++;
614     if (FDH_PWRITE(fdP, parent, vcp->diskSize, offset) != vcp->diskSize) {
615         Log("split volume: couldn't write vnode for parent directory %u.%u.%u\n",
616                 V_id(vol), vN, parent->uniquifier);
617         return EIO;
618     }
619     FDH_REALLYCLOSE(fdP);
620     return code;
621 }
622
623 static afs_int32
624 deleteVnodes(Volume *vol, afs_int32 class,
625              struct VnodeExtract *list, afs_int32 length,
626              afs_uint64 *blocks)
627 {
628     afs_int32 i, code = 0;
629     char buf[SIZEOF_LARGEDISKVNODE];
630     struct VnodeDiskObject *vnode = (struct VnodeDiskObject *)&buf;
631     FdHandle_t *fdP = 0;
632     struct VnodeClassInfo *vcp = &VnodeClassInfo[class];
633     struct VnodeExtract *e;
634     afs_sfsize_t size;
635     afs_uint64 offset;
636     Inode ino;
637
638     fdP = IH_OPEN(vol->vnodeIndex[class].handle);
639     if (!fdP) {
640         Log("Couldn't open %s Index of volume %u\n",
641                 class ? "small":"large", V_id(vol));
642         code = EIO;
643         goto Bad_Delete;
644     }
645
646     for (i=0; i<length; i++) {
647         e = &list[i];
648         if (e->flag & NEEDED) {
649             offset = (e->vN + 1 - class) << (vcp->logSize -1);
650             if (FDH_PREAD(fdP, vnode, vcp->diskSize, offset) != vcp->diskSize) {
651                 Log("Couldn't read in %s Index of volume %u at offset %llu\n",
652                     class ? "small":"large", V_id(vol), offset);
653                 code = EIO;
654                 goto Bad_Delete;
655             }
656             VNDISK_GET_LEN(size, vnode);
657             *blocks += (size + 0x3ff) >> 10;
658             ino = VNDISK_GET_INO(vnode);
659             if (ino) {
660                 IHandle_t *h;
661                 IH_INIT(h, vol->device, V_parentId(vol), ino);
662                     IH_DEC(h, ino, V_parentId(vol));
663 #ifdef AFS_RXOSD_SUPPORT
664             } else {
665                 code = osdRemove(vol, vnode, e->vN);
666 #endif /*  AFS_RXOSD_SUPPORT */
667             }
668             memset(vnode, 0, vcp->diskSize);
669             vnode->type = vNull;
670             if (FDH_PWRITE(fdP, vnode, vcp->diskSize, offset) != vcp->diskSize) {
671                    Log("Couldn't write in %s Index of volume %u to offset %llu\n",
672                        class ? "small":"large", V_id(vol), offset);
673             }
674         }
675     }
676 Bad_Delete:
677     if (fdP)
678         FDH_CLOSE(fdP);
679     return code;
680 }
681
682 afs_int32
683 split_volume(struct rx_call *call, Volume *vol, Volume *newvol,
684              afs_uint32 where, afs_int32 verbose)
685 {
686     Error code = 0;
687     struct VnodeExtract *dirList = 0;
688     struct VnodeExtract *fileList = 0;
689     afs_uint64 blocks = 0;
690     afs_uint32 filesNeeded, dirsNeeded;
691     afs_uint32 dl, fl;
692     char buf[SIZEOF_LARGEDISKVNODE];
693     char buf2[SIZEOF_LARGEDISKVNODE];
694     struct VnodeDiskObject *rootVnode = (struct VnodeDiskObject *)&buf;
695     struct VnodeDiskObject *parVnode = (struct VnodeDiskObject *)&buf2;
696     char name[256];
697     afs_uint32 parent;
698     struct Msg *m;
699
700     m = (struct Msg *) malloc(sizeof(struct Msg));
701     memset(m, 0, sizeof(struct Msg));
702     m->call = call;
703     m->verbose = verbose;
704
705     /*
706      *  First step: planning
707      *
708      *  Find out which directories will belong to the new volume
709      *
710      */
711     if (verbose) {
712         sprintf(m->line,
713                 "1st step: extract vnode essence from large vnode file\n");
714         rx_Write(m->call, m->line, strlen(m->line));
715     }
716
717     code = ExtractVnodes(m, vol, vLarge, &dirList, &dl, where, rootVnode,
718                         &parent, parVnode);
719     if (code) {
720         sprintf(m->line,
721                 "ExtractVnodes failed for %u for directories with code %d\n",
722                 V_id(vol), code);
723         rx_Write(m->call, m->line, strlen(m->line));
724         return code;
725     }
726
727     if (verbose) {
728         sprintf(m->line, "2nd step: look for name of vnode %u in directory %u.%u.%u\n",
729                 where, V_id(vol), parent, parVnode->uniquifier);
730         rx_Write(m->call, m->line, strlen(m->line));
731     }
732     code = findName(vol, parVnode, where, rootVnode->uniquifier,
733                     name,  sizeof(name));
734     if (code) {
735         sprintf(m->line,
736                 "splitvolume: could'nt find name of %u in directory %u.%u.%u.\n",
737                 where, V_id(vol), parent, parVnode->uniquifier);
738         rx_Write(m->call, m->line, strlen(m->line));
739         return code;
740     }
741     if (verbose) {
742         sprintf(m->line, "name of %u is %s\n", where, name);
743         rx_Write(m->call, m->line, strlen(m->line));
744     }
745
746     if (verbose) {
747         sprintf(m->line, "3rd step: find all directory vnodes belonging to the subtree under %u \"%s\"\n",
748                         where, name);
749         rx_Write(m->call, m->line, strlen(m->line));
750     }
751     code = FindVnodes(m, where, dirList, dl, dirList, dl, &dirsNeeded, 1);
752     if (code) {
753         sprintf(m->line,
754                 "FindVnodes for directories failed with code %d\n", code);
755         rx_Write(m->call, m->line, strlen(m->line));
756         return code;
757     }
758
759     if (verbose) {
760         sprintf(m->line, "4th step extract vnode essence from small vnode file\n");
761         rx_Write(m->call, m->line, strlen(m->line));
762     }
763     code = ExtractVnodes(m, vol, vSmall, &fileList, &fl, where, 0, 0, 0);
764     if (code) {
765         sprintf(m->line,
766                 "ExtractVnodes failed for %u for files with code %d\n",
767                 V_id(vol), code);
768         rx_Write(m->call, m->line, strlen(m->line));
769         return code;
770     }
771     if (verbose) {
772         sprintf(m->line, "5th step: find all small vnodes belonging to the subtree under %u \"%s\"\n",
773                         where, name);
774         rx_Write(m->call, m->line, strlen(m->line));
775     }
776     FindVnodes(m, where, fileList, fl, dirList, dl, &filesNeeded, 0);
777
778     /*
779      *  Third step: create hard links for all files needed
780      *
781      */
782
783     V_destroyMe(newvol) = DESTROY_ME;
784     V_inService(newvol) = 0;
785     if (verbose) {
786         sprintf(m->line, "6th step: create hard links in the AFSIDat tree between files of the old and new volume\n");
787         rx_Write(m->call, m->line, strlen(m->line));
788     }
789     code = copyVnodes(m, vol, newvol, 1, fileList, fl, where, &blocks, 0);
790     if (code) {
791         sprintf(m->line, "copyVnodes for files failed with code %d\n", code);
792         rx_Write(m->call, m->line, strlen(m->line));
793         return code;
794     }
795
796     /*
797      *  Forth step: create hard links for all directories and copy
798      *  split directory to new root directory
799      */
800
801     if (verbose) {
802         sprintf(m->line, "7th step: create hard links in the AFSIDat tree between directories of the old and new volume and make dir %u to new volume's root directory.\n",
803                 where);
804         rx_Write(m->call, m->line, strlen(m->line));
805     }
806     code = copyVnodes(m, vol, newvol, 0, dirList, dl, where, &blocks, parVnode);
807     if (code) {
808         sprintf(m->line, "copyVnodes for directories failed with code %d\n", code);
809         rx_Write(m->call, m->line, strlen(m->line));
810         return code;
811     }
812
813     /*
814      *  Finalize new volume
815      *
816      */
817     if (verbose) {
818         sprintf(m->line, "8th step: write new volume's metadata to disk\n");
819         rx_Write(m->call, m->line, strlen(m->line));
820     }
821
822     V_diskused(newvol) = blocks;
823 #ifdef AFS_RXOSD_SUPPORT
824     V_osdFlag(newvol) = V_osdFlag(vol);
825 #endif
826     V_filecount(newvol) = filesNeeded + dirsNeeded;
827     V_destroyMe(newvol) = 0;
828     V_maxquota(newvol) = V_maxquota(vol);
829     V_uniquifier(newvol) = V_uniquifier(vol);
830     V_inService(newvol) = 1;
831     VUpdateVolume(&code, newvol);
832
833     /*
834      *  Sixth step: change directory entry in old volume:
835      *  rename old tree and create mount point for new volume.
836      */
837     if (verbose) {
838         sprintf(m->line, "9th step: create mountpoint \"%s\" for new volume in old volume's directory %u.\n", name, parent);
839         rx_Write(m->call, m->line, strlen(m->line));
840     }
841
842     code = createMountpoint(vol, newvol, parVnode, parent, rootVnode, name);
843     if (code) {
844         sprintf(m->line, "createMountpoint failed with code %d\n", code);
845         rx_Write(m->call, m->line, strlen(m->line));
846         return code;
847     }
848     /*
849      * Now both volumes should be ready and consistent, but the old volume
850      * contains still the vnodes and data we transferred into the new one.
851      * Delete orphaned vnodes and data.
852      */
853
854     blocks = 0;
855     if (verbose) {
856         sprintf(m->line, "10th step: delete large vnodes belonging to subtree in the old volume.\n");
857         rx_Write(m->call, m->line, strlen(m->line));
858     }
859     deleteVnodes(vol, vLarge, dirList, dl, &blocks);
860     if (verbose) {
861         sprintf(m->line, "11th step: delete small vnodes belonging to subtree in the old volume.\n");
862         rx_Write(m->call, m->line, strlen(m->line));
863     }
864     deleteVnodes(vol, vSmall, fileList, fl, &blocks);
865     V_diskused(vol) -= blocks;
866     V_filecount(vol) -= (filesNeeded + dirsNeeded + 1);
867     VUpdateVolume(&code, vol);
868
869     sprintf(m->line, "Finished!\n");
870     rx_Write(m->call, m->line, strlen(m->line));
871     m->line[0] = 0;
872     m->line[1] = 0;
873     m->line[2] = 0;
874     m->line[3] = 0;
875     rx_Write(m->call, m->line, 4);
876     free(m);
877     return code;
878 }
879 #endif