4c2af0b43d9fd2f9a1411f0e22ba02d5c08bbfbe
[dragonfly.git] / sbin / growfs / growfs.c
1 /*
2  * Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz
3  * Copyright (c) 1980, 1989, 1993 The Regents of the University of California.
4  * All rights reserved.
5  * 
6  * This code is derived from software contributed to Berkeley by
7  * Christoph Herrmann and Thomas-Henning von Kamptz, Munich and Frankfurt.
8  * 
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgment:
19  *      This product includes software developed by the University of
20  *      California, Berkeley and its contributors, as well as Christoph
21  *      Herrmann and Thomas-Henning von Kamptz.
22  * 4. Neither the name of the University nor the names of its contributors
23  *    may be used to endorse or promote products derived from this software
24  *    without specific prior written permission.
25  * 
26  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
27  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
29  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
30  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
31  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
32  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
34  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
35  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
36  * SUCH DAMAGE.
37  *
38  * $TSHeader: src/sbin/growfs/growfs.c,v 1.5 2000/12/12 19:31:00 tomsoft Exp $
39  *
40  * @(#) Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz Copyright (c) 1980, 1989, 1993 The Regents of the University of California. All rights reserved.
41  * $FreeBSD: src/sbin/growfs/growfs.c,v 1.4.2.2 2001/08/14 12:45:11 chm Exp $
42  */
43
44 /* ********************************************************** INCLUDES ***** */
45 #include <sys/param.h>
46 #include <sys/diskslice.h>
47 #include <sys/ioctl.h>
48 #include <sys/stat.h>
49
50 #include <stdio.h>
51 #include <paths.h>
52 #include <ctype.h>
53 #include <err.h>
54 #include <fcntl.h>
55 #include <stdlib.h>
56 #include <string.h>
57 #include <unistd.h>
58 #include <vfs/ufs/dinode.h>
59 #include <vfs/ufs/fs.h>
60
61 #include "debug.h"
62
63 /* *************************************************** GLOBALS & TYPES ***** */
64 #ifdef FS_DEBUG
65 int     _dbg_lvl_ = (DL_INFO);  /* DL_TRC */
66 #endif /* FS_DEBUG */
67
68 static union {
69         struct fs       fs;
70         char    pad[SBSIZE];
71 } fsun1, fsun2;
72 #define sblock  fsun1.fs        /* the new superblock */
73 #define osblock fsun2.fs        /* the old superblock */
74
75 static union {
76         struct cg       cg;
77         char    pad[MAXBSIZE];
78 } cgun1, cgun2;
79 #define acg     cgun1.cg        /* a cylinder cgroup (new) */
80 #define aocg    cgun2.cg        /* an old cylinder group */
81
82 static char     ablk[MAXBSIZE];         /* a block */
83 static char     i1blk[MAXBSIZE];        /* some indirect blocks */
84 static char     i2blk[MAXBSIZE];
85 static char     i3blk[MAXBSIZE];
86
87         /* where to write back updated blocks */
88 static daddr_t  in_src, i1_src, i2_src, i3_src;
89
90         /* what object contains the reference */
91 enum pointer_source {
92         GFS_PS_INODE,
93         GFS_PS_IND_BLK_LVL1,
94         GFS_PS_IND_BLK_LVL2,
95         GFS_PS_IND_BLK_LVL3
96 };
97
98 static struct csum      *fscs;          /* cylinder summary */
99
100 static struct ufs1_dinode       zino[MAXBSIZE/sizeof(struct ufs1_dinode)]; /* some inodes */
101
102 /*
103  * An  array of elements of type struct gfs_bpp describes all blocks  to
104  * be relocated in order to free the space needed for the cylinder group
105  * summary for all cylinder groups located in the first cylinder group.
106  */
107 struct gfs_bpp {
108         daddr_t old;            /* old block number */
109         daddr_t new;            /* new block number */
110 #define GFS_FL_FIRST    1
111 #define GFS_FL_LAST     2
112         unsigned int    flags;  /* special handling required */
113         int     found;          /* how many references were updated */
114 };
115
116 /* ******************************************************** PROTOTYPES ***** */
117 static void     growfs(int, int, unsigned int);
118 static void     rdfs(daddr_t, size_t, void *, int);
119 static void     wtfs(daddr_t, size_t, void *, int, unsigned int);
120 static daddr_t  alloc(void);
121 static int      charsperline(void);
122 static void     usage(void);
123 static int      isblock(struct fs *, unsigned char *, int);
124 static void     clrblock(struct fs *, unsigned char *, int);
125 static void     setblock(struct fs *, unsigned char *, int);
126 static void     initcg(int, time_t, int, unsigned int);
127 static void     updjcg(int, time_t, int, int, unsigned int);
128 static void     updcsloc(time_t, int, int, unsigned int);
129 static struct ufs1_dinode       *ginode(ino_t, int, int);
130 static void     frag_adjust(daddr_t, int);
131 static void     cond_bl_upd(ufs_daddr_t *, struct gfs_bpp *,
132     enum pointer_source, int, unsigned int);
133 static void     updclst(int);
134 static void     updrefs(int, ino_t, struct gfs_bpp *, int, int, unsigned int);
135
136 /* ************************************************************ growfs ***** */
137 /*
138  * Here  we actually start growing the filesystem. We basically  read  the
139  * cylinder  summary  from the first cylinder group as we want  to  update
140  * this  on  the fly during our various operations. First  we  handle  the
141  * changes in the former last cylinder group. Afterwards we create all new
142  * cylinder  groups.  Now  we handle the  cylinder  group  containing  the
143  * cylinder  summary  which  might result in a  relocation  of  the  whole
144  * structure.  In the end we write back the updated cylinder summary,  the
145  * new superblock, and slightly patched versions of the super block
146  * copies.
147  */
148 static void
149 growfs(int fsi, int fso, unsigned int Nflag)
150 {
151         DBG_FUNC("growfs")
152         int     i;
153         int     cylno, j;
154         time_t  utime;
155         int     width;
156         char    tmpbuf[100];
157 #ifdef FSIRAND
158         static int      randinit=0;
159
160         DBG_ENTER;
161
162         if (!randinit) {
163                 randinit = 1;
164                 srandomdev();
165         }
166 #else /* not FSIRAND */
167
168         DBG_ENTER;
169
170 #endif /* FSIRAND */
171         time(&utime);
172
173         /*
174          * Get the cylinder summary into the memory.
175          */
176         fscs = (struct csum *)calloc((size_t)1, (size_t)sblock.fs_cssize);
177         if(fscs == NULL) {
178                 errx(1, "calloc failed");
179         }
180         for (i = 0; i < osblock.fs_cssize; i += osblock.fs_bsize) {
181                 rdfs(fsbtodb(&osblock, osblock.fs_csaddr +
182                     numfrags(&osblock, i)), (size_t)MIN(osblock.fs_cssize - i,
183                     osblock.fs_bsize), (void *)(((char *)fscs)+i), fsi);
184         }
185
186 #ifdef FS_DEBUG
187 {
188         struct csum     *dbg_csp;
189         int     dbg_csc;
190         char    dbg_line[80];
191
192         dbg_csp=fscs;
193         for(dbg_csc=0; dbg_csc<osblock.fs_ncg; dbg_csc++) {
194                 snprintf(dbg_line, sizeof(dbg_line),
195                     "%d. old csum in old location", dbg_csc);
196                 DBG_DUMP_CSUM(&osblock,
197                     dbg_line,
198                     dbg_csp++);
199         }
200 }
201 #endif /* FS_DEBUG */
202         DBG_PRINT0("fscs read\n");
203
204         /*
205          * Do all needed changes in the former last cylinder group.
206          */
207         updjcg(osblock.fs_ncg-1, utime, fsi, fso, Nflag);
208
209         /*
210          * Dump out summary information about file system.
211          */
212         printf("growfs:\t%d sectors in %d %s of %d tracks, %d sectors\n",
213             sblock.fs_size * NSPF(&sblock), sblock.fs_ncyl,
214             "cylinders", sblock.fs_ntrak, sblock.fs_nsect);
215 #define B2MBFACTOR (1 / (1024.0 * 1024.0))
216         printf("\t%.1fMB in %d cyl groups (%d c/g, %.2fMB/g, %d i/g)\n",
217             (float)sblock.fs_size * sblock.fs_fsize * B2MBFACTOR,
218             sblock.fs_ncg, sblock.fs_cpg,
219             (float)sblock.fs_fpg * sblock.fs_fsize * B2MBFACTOR,
220             sblock.fs_ipg);
221 #undef B2MBFACTOR
222
223         /*
224          * Now build the cylinders group blocks and
225          * then print out indices of cylinder groups.
226          */
227         printf("super-block backups (for fsck -b #) at:\n");
228         i = 0;
229         width = charsperline();
230
231         /*
232          * Iterate for only the new cylinder groups.
233          */
234         for (cylno = osblock.fs_ncg; cylno < sblock.fs_ncg; cylno++) {
235                 initcg(cylno, utime, fso, Nflag);
236                 j = sprintf(tmpbuf, " %d%s",
237                     (int)fsbtodb(&sblock, cgsblock(&sblock, cylno)),
238                     cylno < (sblock.fs_ncg-1) ? "," : "" );
239                 if (i + j >= width) {
240                         printf("\n");
241                         i = 0;
242                 }
243                 i += j;
244                 printf("%s", tmpbuf);
245                 fflush(stdout);
246         }
247         printf("\n");
248
249         /*
250          * Do all needed changes in the first cylinder group.
251          * allocate blocks in new location
252          */
253         updcsloc(utime, fsi, fso, Nflag);
254
255         /*
256          * Now write the cylinder summary back to disk.
257          */
258         for (i = 0; i < sblock.fs_cssize; i += sblock.fs_bsize) {
259                 wtfs(fsbtodb(&sblock, sblock.fs_csaddr + numfrags(&sblock, i)),
260                     (size_t)MIN(sblock.fs_cssize - i, sblock.fs_bsize),
261                     (void *)(((char *)fscs) + i), fso, Nflag);
262         }
263         DBG_PRINT0("fscs written\n");
264
265 #ifdef FS_DEBUG
266 {
267         struct csum     *dbg_csp;
268         int     dbg_csc;
269         char    dbg_line[80];
270
271         dbg_csp=fscs;
272         for(dbg_csc=0; dbg_csc<sblock.fs_ncg; dbg_csc++) {
273                 snprintf(dbg_line, sizeof(dbg_line),
274                     "%d. new csum in new location", dbg_csc);
275                 DBG_DUMP_CSUM(&sblock,
276                     dbg_line,
277                     dbg_csp++);
278         }
279 }
280 #endif /* FS_DEBUG */
281
282         /*
283          * Now write the new superblock back to disk.
284          */
285         sblock.fs_time = utime;
286         wtfs((daddr_t)(SBOFF / DEV_BSIZE), (size_t)SBSIZE, &sblock,
287             fso, Nflag);
288         DBG_PRINT0("sblock written\n");
289         DBG_DUMP_FS(&sblock,
290             "new initial sblock");
291
292         /*
293          * Clean up the dynamic fields in our superblock copies.
294          */
295         sblock.fs_fmod = 0;
296         sblock.fs_clean = 1;
297         sblock.fs_ronly = 0;
298         sblock.fs_cgrotor = 0;
299         sblock.fs_state = 0;
300         memset((void *)&sblock.fs_fsmnt, 0, sizeof(sblock.fs_fsmnt));
301         sblock.fs_flags &= FS_DOSOFTDEP;
302
303         /*
304          * XXX
305          * The following fields are currently distributed from the  superblock
306          * to the copies:
307          *     fs_minfree
308          *     fs_rotdelay
309          *     fs_maxcontig
310          *     fs_maxbpg
311          *     fs_minfree,
312          *     fs_optim
313          *     fs_flags regarding SOFTPDATES
314          *
315          * We probably should rather change the summary for the cylinder group
316          * statistics here to the value of what would be in there, if the file
317          * system were created initially with the new size. Therefor we  still
318          * need to find an easy way of calculating that.
319          * Possibly we can try to read the first superblock copy and apply the
320          * "diffed" stats between the old and new superblock by still  copying
321          * certain parameters onto that.
322          */
323
324         /*
325          * Write out the duplicate super blocks.
326          */
327         for (cylno = 0; cylno < sblock.fs_ncg; cylno++) {
328                 wtfs(fsbtodb(&sblock, cgsblock(&sblock, cylno)),
329                     (size_t)SBSIZE, &sblock, fso, Nflag);
330         }
331         DBG_PRINT0("sblock copies written\n");
332         DBG_DUMP_FS(&sblock,
333             "new other sblocks");
334
335         DBG_LEAVE;
336         return;
337 }
338
339 /* ************************************************************ initcg ***** */
340 /*
341  * This creates a new cylinder group structure, for more details please  see
342  * the  source of newfs(8), as this function is taken over almost unchanged.
343  * As  this  is  never called for the  first  cylinder  group,  the  special
344  * provisions for that case are removed here.
345  */
346 static void
347 initcg(int cylno, time_t utime, int fso, unsigned int Nflag)
348 {
349         DBG_FUNC("initcg")
350         daddr_t cbase, d, dlower, dupper, dmax, blkno;
351         int i;
352         struct csum *cs;
353 #ifdef FSIRAND
354         int j;
355 #endif
356
357         DBG_ENTER;
358
359         /*
360          * Determine block bounds for cylinder group.
361          */
362         cbase = cgbase(&sblock, cylno);
363         dmax = cbase + sblock.fs_fpg;
364         if (dmax > sblock.fs_size) {
365                 dmax = sblock.fs_size;
366         }
367         dlower = cgsblock(&sblock, cylno) - cbase;
368         dupper = cgdmin(&sblock, cylno) - cbase;
369         if (cylno == 0) { /* XXX fscs may be relocated */
370                 dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
371         }
372         cs = fscs + cylno;
373         memset(&acg, 0, (size_t)sblock.fs_cgsize);
374         acg.cg_time = utime;
375         acg.cg_magic = CG_MAGIC;
376         acg.cg_cgx = cylno;
377         if (cylno == sblock.fs_ncg - 1) {
378                 acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
379         } else {
380                 acg.cg_ncyl = sblock.fs_cpg;
381         }
382         acg.cg_niblk = sblock.fs_ipg;
383         acg.cg_ndblk = dmax - cbase;
384         if (sblock.fs_contigsumsize > 0) {
385                 acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
386         }
387         acg.cg_btotoff = &acg.cg_space[0] - (u_char *)(&acg.cg_firstfield);
388         acg.cg_boff = acg.cg_btotoff + sblock.fs_cpg * sizeof(int32_t);
389         acg.cg_iusedoff = acg.cg_boff +
390             sblock.fs_cpg * sblock.fs_nrpos * sizeof(u_int16_t);
391         acg.cg_freeoff = acg.cg_iusedoff + howmany(sblock.fs_ipg, NBBY);
392         if (sblock.fs_contigsumsize <= 0) {
393                 acg.cg_nextfreeoff = acg.cg_freeoff +
394                     howmany(sblock.fs_cpg* sblock.fs_spc/ NSPF(&sblock), NBBY);
395         } else {
396                 acg.cg_clustersumoff = acg.cg_freeoff + howmany
397                     (sblock.fs_cpg * sblock.fs_spc / NSPF(&sblock), NBBY) -
398                     sizeof(u_int32_t);
399                 acg.cg_clustersumoff =
400                     roundup(acg.cg_clustersumoff, sizeof(u_int32_t));
401                 acg.cg_clusteroff = acg.cg_clustersumoff +
402                     (sblock.fs_contigsumsize + 1) * sizeof(u_int32_t);
403                 acg.cg_nextfreeoff = acg.cg_clusteroff + howmany
404                     (sblock.fs_cpg * sblock.fs_spc / NSPB(&sblock), NBBY);
405         }
406         if (acg.cg_nextfreeoff-(intptr_t)(&acg.cg_firstfield) > sblock.fs_cgsize) {
407                 /*
408                  * XXX This should never happen as we would have had that panic
409                  *     already on filesystem creation
410                  */
411                 errx(37, "panic: cylinder group too big");
412         }
413         acg.cg_cs.cs_nifree += sblock.fs_ipg;
414         if (cylno == 0)
415                 for (i = 0; (size_t)i < ROOTINO; i++) {
416                         setbit(cg_inosused(&acg), i);
417                         acg.cg_cs.cs_nifree--;
418                 }
419         for (i = 0; i < sblock.fs_ipg / INOPF(&sblock); i += sblock.fs_frag) {
420 #ifdef FSIRAND
421                 for (j = 0; j < sblock.fs_bsize / sizeof(struct ufs1_dinode); j++) {
422                         zino[j].di_gen = random();
423                 }
424 #endif
425                 wtfs(fsbtodb(&sblock, cgimin(&sblock, cylno) + i),
426                     (size_t)sblock.fs_bsize, (void *)zino, fso, Nflag);
427         }
428         for (d = 0; d < dlower; d += sblock.fs_frag) {
429                 blkno = d / sblock.fs_frag;
430                 setblock(&sblock, cg_blksfree(&acg), blkno);
431                 if (sblock.fs_contigsumsize > 0) {
432                         setbit(cg_clustersfree(&acg), blkno);
433                 }
434                 acg.cg_cs.cs_nbfree++;
435                 cg_blktot(&acg)[cbtocylno(&sblock, d)]++;
436                 cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
437                     [cbtorpos(&sblock, d)]++;
438         }
439         sblock.fs_dsize += dlower;
440         sblock.fs_dsize += acg.cg_ndblk - dupper;
441         if ((i = dupper % sblock.fs_frag)) {
442                 acg.cg_frsum[sblock.fs_frag - i]++;
443                 for (d = dupper + sblock.fs_frag - i; dupper < d; dupper++) {
444                         setbit(cg_blksfree(&acg), dupper);
445                         acg.cg_cs.cs_nffree++;
446                 }
447         }
448         for (d = dupper; d + sblock.fs_frag <= dmax - cbase; ) {
449                 blkno = d / sblock.fs_frag;
450                 setblock(&sblock, cg_blksfree(&acg), blkno);
451                 if (sblock.fs_contigsumsize > 0) {
452                         setbit(cg_clustersfree(&acg), blkno);
453                 }
454                 acg.cg_cs.cs_nbfree++;
455                 cg_blktot(&acg)[cbtocylno(&sblock, d)]++;
456                 cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
457                     [cbtorpos(&sblock, d)]++;
458                 d += sblock.fs_frag;
459         }
460         if (d < dmax - cbase) {
461                 acg.cg_frsum[dmax - cbase - d]++;
462                 for (; d < dmax - cbase; d++) {
463                         setbit(cg_blksfree(&acg), d);
464                         acg.cg_cs.cs_nffree++;
465                 }
466         }
467         if (sblock.fs_contigsumsize > 0) {
468                 int32_t *sump = cg_clustersum(&acg);
469                 u_char  *mapp = cg_clustersfree(&acg);
470                 int     map = *mapp++;
471                 int     bit = 1;
472                 int     run = 0;
473
474                 for (i = 0; i < acg.cg_nclusterblks; i++) {
475                         if ((map & bit) != 0) {
476                                 run++;
477                         } else if (run != 0) {
478                                 if (run > sblock.fs_contigsumsize) {
479                                         run = sblock.fs_contigsumsize;
480                                 }
481                                 sump[run]++;
482                                 run = 0;
483                         }
484                         if ((i & (NBBY - 1)) != (NBBY - 1)) {
485                                 bit <<= 1;
486                         } else {
487                                 map = *mapp++;
488                                 bit = 1;
489                         }
490                 }
491                 if (run != 0) {
492                         if (run > sblock.fs_contigsumsize) {
493                                 run = sblock.fs_contigsumsize;
494                         }
495                         sump[run]++;
496                 }
497         }
498         sblock.fs_cstotal.cs_ndir += acg.cg_cs.cs_ndir;
499         sblock.fs_cstotal.cs_nffree += acg.cg_cs.cs_nffree;
500         sblock.fs_cstotal.cs_nbfree += acg.cg_cs.cs_nbfree;
501         sblock.fs_cstotal.cs_nifree += acg.cg_cs.cs_nifree;
502         *cs = acg.cg_cs;
503         wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
504             (size_t)sblock.fs_bsize, &acg, fso, Nflag);
505         DBG_DUMP_CG(&sblock,
506             "new cg",
507             &acg);
508
509         DBG_LEAVE;
510         return;
511 }
512
513 /* ******************************************************* frag_adjust ***** */
514 /*
515  * Here  we add or subtract (sign +1/-1) the available fragments in  a  given
516  * block to or from the fragment statistics. By subtracting before and adding
517  * after  an operation on the free frag map we can easy update  the  fragment
518  * statistic, which seems to be otherwise an rather complex operation.
519  */
520 static void
521 frag_adjust(daddr_t frag, int sign)
522 {
523         DBG_FUNC("frag_adjust")
524         int fragsize;
525         int f;
526
527         DBG_ENTER;
528
529         fragsize=0;
530         /*
531          * Here frag only needs to point to any fragment in the block we want
532          * to examine.
533          */
534         for(f=rounddown(frag, sblock.fs_frag); 
535             f<roundup(frag+1, sblock.fs_frag);
536             f++) {
537                 /*
538                  * Count contiguos free fragments.
539                  */
540                 if(isset(cg_blksfree(&acg), f)) {
541                         fragsize++;
542                 } else {
543                         if(fragsize && fragsize<sblock.fs_frag) {
544                                 /*
545                                  * We found something in between.
546                                  */
547                                 acg.cg_frsum[fragsize]+=sign;
548                                 DBG_PRINT2("frag_adjust [%d]+=%d\n",
549                                     fragsize,
550                                     sign);
551                         }
552                         fragsize=0;
553                 }
554         }
555         if(fragsize && fragsize<sblock.fs_frag) {
556                 /*
557                  * We found something.
558                  */
559                 acg.cg_frsum[fragsize]+=sign;
560                 DBG_PRINT2("frag_adjust [%d]+=%d\n",
561                     fragsize,
562                     sign);
563         }
564         DBG_PRINT2("frag_adjust [[%d]]+=%d\n",
565             fragsize,
566             sign);
567
568         DBG_LEAVE;
569         return;
570 }
571
572 /* ******************************************************* cond_bl_upd ***** */
573 /*
574  * Here we conditionally update a pointer to a fragment. We check for all
575  * relocated blocks if any of it's fragments is referenced by the current
576  * field,  and update the pointer to the respective fragment in  our  new
577  * block.  If  we find a reference we write back the  block  immediately,
578  * as there is no easy way for our general block reading engine to figure
579  * out if a write back operation is needed.
580  */
581 static void
582 cond_bl_upd(ufs_daddr_t *block, struct gfs_bpp *field,
583     enum pointer_source source, int fso, unsigned int Nflag)
584 {
585         DBG_FUNC("cond_bl_upd")
586         struct gfs_bpp  *f;
587         char *src;
588         daddr_t dst=0;
589
590         DBG_ENTER;
591
592         f=field;
593         while(f->old) { /* for all old blocks */
594                 if(*block/sblock.fs_frag == f->old) {
595                         /*
596                          * The fragment is part of the block, so update.
597                          */
598                         *block=(f->new*sblock.fs_frag+(*block%sblock.fs_frag));
599                         f->found++;
600                         DBG_PRINT3("scg (%d->%d)[%d] reference updated\n",
601                             f->old,
602                             f->new,
603                             *block%sblock.fs_frag);
604
605                         /* Write the block back to disk immediately */
606                         switch (source) {
607                         case GFS_PS_INODE:
608                                 src=ablk;
609                                 dst=in_src;
610                                 break;
611                         case GFS_PS_IND_BLK_LVL1:
612                                 src=i1blk;
613                                 dst=i1_src;
614                                 break;
615                         case GFS_PS_IND_BLK_LVL2:
616                                 src=i2blk;
617                                 dst=i2_src;
618                                 break;
619                         case GFS_PS_IND_BLK_LVL3:
620                                 src=i3blk;
621                                 dst=i3_src;
622                                 break;
623                         default:        /* error */
624                                 src=NULL;
625                                 break;
626                         }
627                         if(src) {
628                                 /*
629                                  * XXX  If src is not of type inode we have to
630                                  *      implement  copy on write here in  case
631                                  *      of active snapshots.
632                                  */
633                                 wtfs(dst, (size_t)sblock.fs_bsize, src,
634                                     fso, Nflag);
635                         }
636
637                         /*
638                          * The same block can't be found again in this loop.
639                          */
640                         break;
641                 }
642                 f++;
643         }
644
645         DBG_LEAVE;
646         return;
647 }
648
649 /* ************************************************************ updjcg ***** */
650 /*
651  * Here we do all needed work for the former last cylinder group. It has to be
652  * changed  in  any case, even if the filesystem ended exactly on the  end  of
653  * this  group, as there is some slightly inconsistent handling of the  number
654  * of cylinders in the cylinder group. We start again by reading the  cylinder
655  * group from disk. If the last block was not fully available, we first handle
656  * the  missing  fragments, then we handle all new full blocks  in  that  file
657  * system  and  finally we handle the new last fragmented block  in  the  file
658  * system.  We again have to handle the fragment statistics rotational  layout
659  * tables and cluster summary during all those operations.
660  */
661 static void
662 updjcg(int cylno, time_t utime, int fsi, int fso, unsigned int Nflag)
663 {
664         DBG_FUNC("updjcg")
665         daddr_t cbase, dmax, dupper;
666         struct csum     *cs;
667         int     i,k;
668         int     j=0;
669
670         DBG_ENTER;
671
672         /*
673          * Read the former last (joining) cylinder group from disk, and make
674          * a copy.
675          */
676         rdfs(fsbtodb(&osblock, cgtod(&osblock, cylno)),
677             (size_t)osblock.fs_cgsize, &aocg, fsi);
678         DBG_PRINT0("jcg read\n");
679         DBG_DUMP_CG(&sblock,
680             "old joining cg",
681             &aocg);
682
683         memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
684
685         /*
686          * If  the  cylinder  group had already it's  new  final  size  almost
687          * nothing is to be done ... except:
688          * For some reason the value of cg_ncyl in the last cylinder group has
689          * to  be  zero instead of fs_cpg. As this is now no longer  the  last
690          * cylinder group we have to change that value now to fs_cpg.
691          */ 
692
693         if(cgbase(&osblock, cylno+1) == osblock.fs_size) {
694                 acg.cg_ncyl=sblock.fs_cpg;
695
696                 wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)),
697                     (size_t)sblock.fs_cgsize, &acg, fso, Nflag);
698                 DBG_PRINT0("jcg written\n");
699                 DBG_DUMP_CG(&sblock,
700                     "new joining cg",
701                     &acg);
702
703                 DBG_LEAVE;
704                 return;
705         }
706
707         /*
708          * Set up some variables needed later.
709          */
710         cbase = cgbase(&sblock, cylno);
711         dmax = cbase + sblock.fs_fpg;
712         if (dmax > sblock.fs_size)
713                 dmax = sblock.fs_size;
714         dupper = cgdmin(&sblock, cylno) - cbase;
715         if (cylno == 0) { /* XXX fscs may be relocated */
716                 dupper += howmany(sblock.fs_cssize, sblock.fs_fsize);
717         }
718
719         /*
720          * Set pointer to the cylinder summary for our cylinder group.
721          */
722         cs = fscs + cylno;
723
724         /*
725          * Touch the cylinder group, update all fields in the cylinder group as
726          * needed, update the free space in the superblock.
727          */
728         acg.cg_time = utime;
729         if (cylno == sblock.fs_ncg - 1) {
730                 /*
731                  * This is still the last cylinder group.
732                  */
733                 acg.cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg;
734         } else {
735                 acg.cg_ncyl = sblock.fs_cpg;
736         }
737         DBG_PRINT4("jcg dbg: %d %u %d %u\n",
738             cylno,
739             sblock.fs_ncg,
740             acg.cg_ncyl,
741             sblock.fs_cpg);
742         acg.cg_ndblk = dmax - cbase;
743         sblock.fs_dsize += acg.cg_ndblk-aocg.cg_ndblk;
744         if (sblock.fs_contigsumsize > 0) {
745                 acg.cg_nclusterblks = acg.cg_ndblk / sblock.fs_frag;
746         }
747
748         /*
749          * Now  we have to update the free fragment bitmap for our new  free
750          * space.  There again we have to handle the fragmentation and  also
751          * the  rotational  layout tables and the cluster summary.  This  is
752          * also  done per fragment for the first new block if the  old  file
753          * system end was not on a block boundary, per fragment for the  new
754          * last block if the new file system end is not on a block boundary,
755          * and per block for all space in between.
756          *
757          * Handle the first new block here if it was partially available
758          * before.
759          */
760         if(osblock.fs_size % sblock.fs_frag) {
761                 if(roundup(osblock.fs_size, sblock.fs_frag)<=sblock.fs_size) {
762                         /*
763                          * The new space is enough to fill at least this
764                          * block
765                          */
766                         j=0;
767                         for(i=roundup(osblock.fs_size-cbase, sblock.fs_frag)-1;
768                             i>=osblock.fs_size-cbase;
769                             i--) {
770                                 setbit(cg_blksfree(&acg), i);
771                                 acg.cg_cs.cs_nffree++;
772                                 j++;
773                         }
774
775                         /*
776                          * Check  if the fragment just created could join  an
777                          * already existing fragment at the former end of the
778                          * file system.
779                          */
780                         if(isblock(&sblock, cg_blksfree(&acg),
781                             ((osblock.fs_size - cgbase(&sblock, cylno))/
782                             sblock.fs_frag))) {
783                                 /*
784                                  * The block is now completely available
785                                  */
786                                 DBG_PRINT0("block was\n");
787                                 acg.cg_frsum[osblock.fs_size%sblock.fs_frag]--;
788                                 acg.cg_cs.cs_nbfree++;
789                                 acg.cg_cs.cs_nffree-=sblock.fs_frag;
790                                 k=rounddown(osblock.fs_size-cbase,
791                                     sblock.fs_frag);
792                                 cg_blktot(&acg)[cbtocylno(&sblock, k)]++;
793                                 cg_blks(&sblock, &acg, cbtocylno(&sblock, k))
794                                     [cbtorpos(&sblock, k)]++;
795                                 updclst((osblock.fs_size-cbase)/sblock.fs_frag);
796                         } else {
797                                 /*
798                                  * Lets rejoin a possible partially growed
799                                  * fragment.
800                                  */
801                                 k=0;
802                                 while(isset(cg_blksfree(&acg), i) &&
803                                     (i>=rounddown(osblock.fs_size-cbase,
804                                     sblock.fs_frag))) {
805                                         i--;
806                                         k++;
807                                 }
808                                 if(k) {
809                                         acg.cg_frsum[k]--;
810                                 }
811                                 acg.cg_frsum[k+j]++;
812                         }
813                 } else {
814                         /*
815                          * We only grow by some fragments within this last
816                          * block.
817                          */
818                         for(i=sblock.fs_size-cbase-1;
819                                 i>=osblock.fs_size-cbase;
820                                 i--) {
821                                 setbit(cg_blksfree(&acg), i);
822                                 acg.cg_cs.cs_nffree++;
823                                 j++;
824                         }
825                         /*
826                          * Lets rejoin a possible partially growed fragment.
827                          */
828                         k=0;
829                         while(isset(cg_blksfree(&acg), i) &&
830                             (i>=rounddown(osblock.fs_size-cbase,
831                             sblock.fs_frag))) {
832                                 i--;
833                                 k++;
834                         }
835                         if(k) {
836                                 acg.cg_frsum[k]--;
837                         }
838                         acg.cg_frsum[k+j]++;
839                 }
840         }
841
842         /*
843          * Handle all new complete blocks here.
844          */
845         for(i=roundup(osblock.fs_size-cbase, sblock.fs_frag);
846             i+sblock.fs_frag<=dmax-cbase;       /* XXX <= or only < ? */
847             i+=sblock.fs_frag) {
848                 j = i / sblock.fs_frag;
849                 setblock(&sblock, cg_blksfree(&acg), j);
850                 updclst(j);
851                 acg.cg_cs.cs_nbfree++;
852                 cg_blktot(&acg)[cbtocylno(&sblock, i)]++;
853                 cg_blks(&sblock, &acg, cbtocylno(&sblock, i))
854                     [cbtorpos(&sblock, i)]++;
855         }
856
857         /*
858          * Handle the last new block if there are stll some new fragments left.
859          * Here  we don't have to bother about the cluster summary or the  even
860          * the rotational layout table.
861          */
862         if (i < (dmax - cbase)) {
863                 acg.cg_frsum[dmax - cbase - i]++;
864                 for (; i < dmax - cbase; i++) {
865                         setbit(cg_blksfree(&acg), i);
866                         acg.cg_cs.cs_nffree++;
867                 }
868         }
869
870         sblock.fs_cstotal.cs_nffree +=
871             (acg.cg_cs.cs_nffree - aocg.cg_cs.cs_nffree);
872         sblock.fs_cstotal.cs_nbfree +=
873             (acg.cg_cs.cs_nbfree - aocg.cg_cs.cs_nbfree);
874         /*
875          * The following statistics are not changed here:
876          *     sblock.fs_cstotal.cs_ndir
877          *     sblock.fs_cstotal.cs_nifree
878          * As the statistics for this cylinder group are ready, copy it to
879          * the summary information array.
880          */
881         *cs = acg.cg_cs;
882
883         /*
884          * Write the updated "joining" cylinder group back to disk.
885          */
886         wtfs(fsbtodb(&sblock, cgtod(&sblock, cylno)), (size_t)sblock.fs_cgsize,
887             &acg, fso, Nflag);
888         DBG_PRINT0("jcg written\n");
889         DBG_DUMP_CG(&sblock,
890             "new joining cg",
891             &acg);
892
893         DBG_LEAVE;
894         return;
895 }
896
897 /* ********************************************************** updcsloc ***** */
898 /*
899  * Here  we update the location of the cylinder summary. We have  two  possible
900  * ways of growing the cylinder summary.
901  * (1)  We can try to grow the summary in the current location, and  relocate
902  *      possibly used blocks within the current cylinder group.
903  * (2)  Alternatively we can relocate the whole cylinder summary to the first
904  *      new completely empty cylinder group. Once the cylinder summary is  no
905  *      longer in the beginning of the first cylinder group you should  never
906  *      use  a version of fsck which is not aware of the possibility to  have
907  *      this structure in a non standard place.
908  * Option (1) is considered to be less intrusive to the structure of the  file-
909  * system. So we try to stick to that whenever possible. If there is not enough
910  * space  in the cylinder group containing the cylinder summary we have to  use
911  * method  (2). In case of active snapshots in the filesystem we  probably  can
912  * completely avoid implementing copy on write if we stick to method (2) only.
913  */
914 static void
915 updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag)
916 {
917         DBG_FUNC("updcsloc")
918         struct csum     *cs;
919         int     ocscg, ncscg;
920         int     blocks;
921         daddr_t cbase, dupper, odupper, d, f, g;
922         int     ind;
923         int     cylno, inc;
924         struct gfs_bpp  *bp;
925         int     i, l;
926         int     lcs=0;
927         int     block;
928
929         DBG_ENTER;
930
931         if(howmany(sblock.fs_cssize, sblock.fs_fsize) ==
932             howmany(osblock.fs_cssize, osblock.fs_fsize)) {
933                 /*
934                  * No new fragment needed.
935                  */
936                 DBG_LEAVE;
937                 return;
938         }
939         ocscg=dtog(&osblock, osblock.fs_csaddr);
940         cs=fscs+ocscg;
941         blocks = 1+howmany(sblock.fs_cssize, sblock.fs_bsize)-
942             howmany(osblock.fs_cssize, osblock.fs_bsize);
943
944         /*
945          * Read original cylinder group from disk, and make a copy.
946          * XXX  If Nflag is set in some very rare cases we now miss
947          *      some changes done in updjcg by reading the unmodified
948          *      block from disk.
949          */
950         rdfs(fsbtodb(&osblock, cgtod(&osblock, ocscg)),
951             (size_t)osblock.fs_cgsize, &aocg, fsi);
952         DBG_PRINT0("oscg read\n");
953         DBG_DUMP_CG(&sblock,
954             "old summary cg",
955             &aocg);
956
957         memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
958
959         /*
960          * Touch the cylinder group, set up local variables needed later
961          * and update the superblock.
962          */
963         acg.cg_time = utime;
964
965         /*
966          * XXX  In the case of having active snapshots we may need much more
967          *      blocks for the copy on write. We need each block twice,  and
968          *      also  up to 8*3 blocks for indirect blocks for all  possible
969          *      references.
970          */
971         if(/*((int)sblock.fs_time&0x3)>0||*/ cs->cs_nbfree < blocks) {
972                 /*
973                  * There  is  not enough space in the old cylinder  group  to
974                  * relocate  all blocks as needed, so we relocate  the  whole
975                  * cylinder  group summary to a new group. We try to use  the
976                  * first complete new cylinder group just created. Within the
977                  * cylinder  group we allign the area immediately  after  the
978                  * cylinder  group  information location in order  to  be  as
979                  * close as possible to the original implementation of ffs.
980                  *
981                  * First  we have to make sure we'll find enough space in  the
982                  * new  cylinder  group. If not, then we  currently  give  up.
983                  * We  start  with freeing everything which was  used  by  the
984                  * fragments of the old cylinder summary in the current group.
985                  * Now  we write back the group meta data, read in the  needed
986                  * meta data from the new cylinder group, and start allocating
987                  * within  that  group. Here we can assume, the  group  to  be
988                  * completely empty. Which makes the handling of fragments and
989                  * clusters a lot easier.
990                  */
991                 DBG_TRC;
992                 if(sblock.fs_ncg-osblock.fs_ncg < 2) {
993                         errx(2, "panic: not enough space");
994                 }
995
996                 /*
997                  * Point "d" to the first fragment not used by the cylinder
998                  * summary.
999                  */
1000                 d=osblock.fs_csaddr+(osblock.fs_cssize/osblock.fs_fsize);
1001
1002                 /*
1003                  * Set up last cluster size ("lcs") already here. Calculate
1004                  * the size for the trailing cluster just behind where  "d"
1005                  * points to.
1006                  */
1007                 if(sblock.fs_contigsumsize > 0) {
1008                         for(block=howmany(d%sblock.fs_fpg, sblock.fs_frag),
1009                             lcs=0; lcs<sblock.fs_contigsumsize;
1010                             block++, lcs++) {
1011                                 if(isclr(cg_clustersfree(&acg), block)){
1012                                         break;
1013                                 }
1014                         }
1015                 }
1016
1017                 /*
1018                  * Point "d" to the last frag used by the cylinder summary.
1019                  */
1020                 d--;
1021
1022                 DBG_PRINT1("d=%d\n",
1023                     d);
1024                 if((d+1)%sblock.fs_frag) {
1025                         /*
1026                          * The end of the cylinder summary is not a complete
1027                          * block.
1028                          */
1029                         DBG_TRC;
1030                         frag_adjust(d%sblock.fs_fpg, -1);
1031                         for(; (d+1)%sblock.fs_frag; d--) {
1032                                 DBG_PRINT1("d=%d\n",
1033                                     d);
1034                                 setbit(cg_blksfree(&acg), d%sblock.fs_fpg);
1035                                 acg.cg_cs.cs_nffree++;
1036                                 sblock.fs_cstotal.cs_nffree++;
1037                         }
1038                         /*
1039                          * Point  "d" to the last fragment of the  last
1040                          * (incomplete) block of the clinder summary.
1041                          */
1042                         d++;
1043                         frag_adjust(d%sblock.fs_fpg, 1);
1044
1045                         if(isblock(&sblock, cg_blksfree(&acg),
1046                             (d%sblock.fs_fpg)/sblock.fs_frag)) {
1047                                 DBG_PRINT1("d=%d\n",
1048                                     d);
1049                                 acg.cg_cs.cs_nffree-=sblock.fs_frag;
1050                                 acg.cg_cs.cs_nbfree++;
1051                                 sblock.fs_cstotal.cs_nffree-=sblock.fs_frag;
1052                                 sblock.fs_cstotal.cs_nbfree++;
1053                                 cg_blktot(&acg)[cbtocylno(&sblock,
1054                                     d%sblock.fs_fpg)]++;
1055                                 cg_blks(&sblock, &acg, cbtocylno(&sblock,
1056                                     d%sblock.fs_fpg))[cbtorpos(&sblock,
1057                                     d%sblock.fs_fpg)]++;
1058                                 if(sblock.fs_contigsumsize > 0) {
1059                                         setbit(cg_clustersfree(&acg),
1060                                             (d%sblock.fs_fpg)/sblock.fs_frag);
1061                                         if(lcs < sblock.fs_contigsumsize) {
1062                                                 if(lcs) {
1063                                                         cg_clustersum(&acg)
1064                                                             [lcs]--;
1065                                                 }
1066                                                 lcs++;
1067                                                 cg_clustersum(&acg)[lcs]++;
1068                                         }
1069                                 }
1070                         }
1071                         /*
1072                          * Point "d" to the first fragment of the block before
1073                          * the last incomplete block.
1074                          */
1075                         d--;
1076                 }
1077
1078                 DBG_PRINT1("d=%d\n",
1079                     d);
1080                 for(d=rounddown(d, sblock.fs_frag); d >= osblock.fs_csaddr;
1081                     d-=sblock.fs_frag) {
1082                         DBG_TRC;
1083                         DBG_PRINT1("d=%d\n",
1084                             d);
1085                         setblock(&sblock, cg_blksfree(&acg),
1086                             (d%sblock.fs_fpg)/sblock.fs_frag);
1087                         acg.cg_cs.cs_nbfree++;
1088                         sblock.fs_cstotal.cs_nbfree++;
1089                         cg_blktot(&acg)[cbtocylno(&sblock, d%sblock.fs_fpg)]++;
1090                         cg_blks(&sblock, &acg, cbtocylno(&sblock,
1091                             d%sblock.fs_fpg))[cbtorpos(&sblock,
1092                             d%sblock.fs_fpg)]++;
1093                         if(sblock.fs_contigsumsize > 0) {
1094                                 setbit(cg_clustersfree(&acg),
1095                                     (d%sblock.fs_fpg)/sblock.fs_frag);
1096                                 /*
1097                                  * The last cluster size is already set up.
1098                                  */
1099                                 if(lcs < sblock.fs_contigsumsize) {
1100                                         if(lcs) {
1101                                                 cg_clustersum(&acg)[lcs]--;
1102                                         }
1103                                         lcs++;
1104                                         cg_clustersum(&acg)[lcs]++;
1105                                 }
1106                         }
1107                 }
1108                 *cs = acg.cg_cs;
1109
1110                 /*
1111                  * Now write the former cylinder group containing the cylinder
1112                  * summary back to disk.
1113                  */
1114                 wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)),
1115                     (size_t)sblock.fs_cgsize, &acg, fso, Nflag);
1116                 DBG_PRINT0("oscg written\n");
1117                 DBG_DUMP_CG(&sblock,
1118                     "old summary cg",
1119                     &acg);
1120
1121                 /*
1122                  * Find the beginning of the new cylinder group containing the
1123                  * cylinder summary.
1124                  */
1125                 sblock.fs_csaddr=cgdmin(&sblock, osblock.fs_ncg);
1126                 ncscg=dtog(&sblock, sblock.fs_csaddr);
1127                 cs=fscs+ncscg;
1128
1129
1130                 /*
1131                  * If Nflag is specified, we would now read random data instead
1132                  * of an empty cg structure from disk. So we can't simulate that
1133                  * part for now.
1134                  */
1135                 if(Nflag) {
1136                         DBG_PRINT0("nscg update skipped\n");
1137                         DBG_LEAVE;
1138                         return;
1139                 }
1140
1141                 /*
1142                  * Read the future cylinder group containing the cylinder
1143                  * summary from disk, and make a copy.
1144                  */
1145                 rdfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
1146                     (size_t)sblock.fs_cgsize, &aocg, fsi);
1147                 DBG_PRINT0("nscg read\n");
1148                 DBG_DUMP_CG(&sblock,
1149                     "new summary cg",
1150                     &aocg);
1151
1152                 memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2));
1153
1154                 /*
1155                  * Allocate all complete blocks used by the new cylinder
1156                  * summary.
1157                  */
1158                 for(d=sblock.fs_csaddr; d+sblock.fs_frag <=
1159                     sblock.fs_csaddr+(sblock.fs_cssize/sblock.fs_fsize);
1160                     d+=sblock.fs_frag) {
1161                         clrblock(&sblock, cg_blksfree(&acg),
1162                             (d%sblock.fs_fpg)/sblock.fs_frag);
1163                         acg.cg_cs.cs_nbfree--;
1164                         sblock.fs_cstotal.cs_nbfree--;
1165                         cg_blktot(&acg)[cbtocylno(&sblock, d%sblock.fs_fpg)]--;
1166                         cg_blks(&sblock, &acg, cbtocylno(&sblock,
1167                             d%sblock.fs_fpg))[cbtorpos(&sblock,
1168                             d%sblock.fs_fpg)]--;
1169                         if(sblock.fs_contigsumsize > 0) {
1170                                 clrbit(cg_clustersfree(&acg),
1171                                     (d%sblock.fs_fpg)/sblock.fs_frag);
1172                         }
1173                 }
1174
1175                 /*
1176                  * Allocate all fragments used by the cylinder summary in the
1177                  * last block.
1178                  */
1179                 if(d<sblock.fs_csaddr+(sblock.fs_cssize/sblock.fs_fsize)) {
1180                         for(; d-sblock.fs_csaddr<
1181                             sblock.fs_cssize/sblock.fs_fsize;
1182                             d++) {
1183                                 clrbit(cg_blksfree(&acg), d%sblock.fs_fpg);
1184                                 acg.cg_cs.cs_nffree--;
1185                                 sblock.fs_cstotal.cs_nffree--;
1186                         }
1187                         acg.cg_cs.cs_nbfree--;
1188                         acg.cg_cs.cs_nffree+=sblock.fs_frag;
1189                         sblock.fs_cstotal.cs_nbfree--;
1190                         sblock.fs_cstotal.cs_nffree+=sblock.fs_frag;
1191                         cg_blktot(&acg)[cbtocylno(&sblock, d%sblock.fs_fpg)]--;
1192                         cg_blks(&sblock, &acg, cbtocylno(&sblock,
1193                             d%sblock.fs_fpg))[cbtorpos(&sblock,
1194                             d%sblock.fs_fpg)]--;
1195                         if(sblock.fs_contigsumsize > 0) {
1196                                 clrbit(cg_clustersfree(&acg),
1197                                     (d%sblock.fs_fpg)/sblock.fs_frag);
1198                         }
1199
1200                         frag_adjust(d%sblock.fs_fpg, +1);
1201                 }
1202                 /*
1203                  * XXX  Handle the cluster statistics here in the case  this
1204                  *      cylinder group is now almost full, and the remaining
1205                  *      space is less then the maximum cluster size. This is
1206                  *      probably not needed, as you would hardly find a file
1207                  *      system which has only MAXCSBUFS+FS_MAXCONTIG of free
1208                  *      space right behind the cylinder group information in
1209                  *      any new cylinder group.
1210                  */
1211
1212                 /*
1213                  * Update our statistics in the cylinder summary.
1214                  */
1215                 *cs = acg.cg_cs;
1216
1217                 /*
1218                  * Write the new cylinder group containing the cylinder summary
1219                  * back to disk.
1220                  */
1221                 wtfs(fsbtodb(&sblock, cgtod(&sblock, ncscg)),
1222                     (size_t)sblock.fs_cgsize, &acg, fso, Nflag);
1223                 DBG_PRINT0("nscg written\n");
1224                 DBG_DUMP_CG(&sblock,
1225                     "new summary cg",
1226                     &acg);
1227
1228                 DBG_LEAVE;
1229                 return;
1230         }
1231         /*
1232          * We have got enough of space in the current cylinder group, so we
1233          * can relocate just a few blocks, and let the summary  information
1234          * grow in place where it is right now.
1235          */
1236         DBG_TRC;
1237
1238         cbase = cgbase(&osblock, ocscg);        /* old and new are equal */
1239         dupper = sblock.fs_csaddr - cbase +
1240             howmany(sblock.fs_cssize, sblock.fs_fsize);
1241         odupper = osblock.fs_csaddr - cbase +
1242             howmany(osblock.fs_cssize, osblock.fs_fsize);
1243
1244         sblock.fs_dsize -= dupper-odupper;
1245
1246         /*
1247          * Allocate the space for the array of blocks to be relocated.
1248          */
1249         bp=(struct gfs_bpp *)malloc(((dupper-odupper)/sblock.fs_frag+2)*
1250             sizeof(struct gfs_bpp));
1251         if(bp == NULL) {
1252                 errx(1, "malloc failed");
1253         }
1254         memset((char *)bp, 0, ((dupper-odupper)/sblock.fs_frag+2)*
1255             sizeof(struct gfs_bpp));
1256
1257         /*
1258          * Lock all new frags needed for the cylinder group summary. This  is
1259          * done per fragment in the first and last block of the new  required
1260          * area, and per block for all other blocks.
1261          *
1262          * Handle the first new  block here (but only if some fragments where
1263          * already used for the cylinder summary).
1264          */
1265         ind=0;
1266         frag_adjust(odupper, -1);
1267         for(d=odupper; ((d<dupper)&&(d%sblock.fs_frag)); d++) {
1268                 DBG_PRINT1("scg first frag check loop d=%d\n",
1269                     d);
1270                 if(isclr(cg_blksfree(&acg), d)) {
1271                         if (!ind) {
1272                                 bp[ind].old=d/sblock.fs_frag;
1273                                 bp[ind].flags|=GFS_FL_FIRST;
1274                                 if(roundup(d, sblock.fs_frag) >= dupper) {
1275                                         bp[ind].flags|=GFS_FL_LAST;
1276                                 }
1277                                 ind++;
1278                         }
1279                 } else {
1280                         clrbit(cg_blksfree(&acg), d);
1281                         acg.cg_cs.cs_nffree--;
1282                         sblock.fs_cstotal.cs_nffree--;
1283                 }
1284                 /*
1285                  * No cluster handling is needed here, as there was at least
1286                  * one  fragment in use by the cylinder summary in  the  old
1287                  * file system.
1288                  * No block-free counter handling here as this block was not
1289                  * a free block.
1290                  */
1291         }
1292         frag_adjust(odupper, 1);
1293
1294         /*
1295          * Handle all needed complete blocks here.
1296          */
1297         for(; d+sblock.fs_frag<=dupper; d+=sblock.fs_frag) {
1298                 DBG_PRINT1("scg block check loop d=%d\n",
1299                     d);
1300                 if(!isblock(&sblock, cg_blksfree(&acg), d/sblock.fs_frag)) {
1301                         for(f=d; f<d+sblock.fs_frag; f++) {
1302                                 if(isset(cg_blksfree(&aocg), f)) {
1303                                         acg.cg_cs.cs_nffree--;
1304                                         sblock.fs_cstotal.cs_nffree--;
1305                                 }
1306                         }
1307                         clrblock(&sblock, cg_blksfree(&acg), d/sblock.fs_frag);
1308                         bp[ind].old=d/sblock.fs_frag;
1309                         ind++;
1310                 } else {
1311                         clrblock(&sblock, cg_blksfree(&acg), d/sblock.fs_frag);
1312                         acg.cg_cs.cs_nbfree--;
1313                         sblock.fs_cstotal.cs_nbfree--;
1314                         cg_blktot(&acg)[cbtocylno(&sblock, d)]--;
1315                         cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
1316                             [cbtorpos(&sblock, d)]--;
1317                         if(sblock.fs_contigsumsize > 0) {
1318                                 clrbit(cg_clustersfree(&acg), d/sblock.fs_frag);
1319                                 for(lcs=0, l=(d/sblock.fs_frag)+1;
1320                                     lcs<sblock.fs_contigsumsize;
1321                                     l++, lcs++ ) {
1322                                         if(isclr(cg_clustersfree(&acg),l)){
1323                                                 break;
1324                                         }
1325                                 }
1326                                 if(lcs < sblock.fs_contigsumsize) {
1327                                         cg_clustersum(&acg)[lcs+1]--;
1328                                         if(lcs) {
1329                                                 cg_clustersum(&acg)[lcs]++;
1330                                         }
1331                                 }
1332                         }
1333                 }
1334                 /*
1335                  * No fragment counter handling is needed here, as this finally
1336                  * doesn't change after the relocation.
1337                  */
1338         }
1339
1340         /*
1341          * Handle all fragments needed in the last new affected block.
1342          */
1343         if(d<dupper) {
1344                 frag_adjust(dupper-1, -1);
1345
1346                 if(isblock(&sblock, cg_blksfree(&acg), d/sblock.fs_frag)) {
1347                         acg.cg_cs.cs_nbfree--;
1348                         sblock.fs_cstotal.cs_nbfree--;
1349                         acg.cg_cs.cs_nffree+=sblock.fs_frag;
1350                         sblock.fs_cstotal.cs_nffree+=sblock.fs_frag;
1351                         cg_blktot(&acg)[cbtocylno(&sblock, d)]--;
1352                         cg_blks(&sblock, &acg, cbtocylno(&sblock, d))
1353                             [cbtorpos(&sblock, d)]--;
1354                         if(sblock.fs_contigsumsize > 0) {
1355                                 clrbit(cg_clustersfree(&acg), d/sblock.fs_frag);
1356                                 for(lcs=0, l=(d/sblock.fs_frag)+1;
1357                                     lcs<sblock.fs_contigsumsize;
1358                                     l++, lcs++ ) {
1359                                         if(isclr(cg_clustersfree(&acg),l)){
1360                                                 break;
1361                                         }
1362                                 }
1363                                 if(lcs < sblock.fs_contigsumsize) {
1364                                         cg_clustersum(&acg)[lcs+1]--;
1365                                         if(lcs) {
1366                                                 cg_clustersum(&acg)[lcs]++;
1367                                         }
1368                                 }
1369                         }
1370                 }
1371
1372                 for(; d<dupper; d++) {
1373                         DBG_PRINT1("scg second frag check loop d=%d\n",
1374                             d);
1375                         if(isclr(cg_blksfree(&acg), d)) {
1376                                 bp[ind].old=d/sblock.fs_frag;
1377                                 bp[ind].flags|=GFS_FL_LAST;
1378                         } else {
1379                                 clrbit(cg_blksfree(&acg), d);
1380                                 acg.cg_cs.cs_nffree--;
1381                                 sblock.fs_cstotal.cs_nffree--;
1382                         }
1383                 }
1384                 if(bp[ind].flags & GFS_FL_LAST) { /* we have to advance here */
1385                         ind++;
1386                 }
1387                 frag_adjust(dupper-1, 1);
1388         }
1389
1390         /*
1391          * If we found a block to relocate just do so.
1392          */
1393         if(ind) {
1394                 for(i=0; i<ind; i++) {
1395                         if(!bp[i].old) { /* no more blocks listed */
1396                                 /*
1397                                  * XXX  A relative blocknumber should not be
1398                                  *      zero,   which  is   not   explicitly
1399                                  *      guaranteed by our code.
1400                                  */
1401                                 break;
1402                         }
1403                         /*
1404                          * Allocate a complete block in the same (current)
1405                          * cylinder group.
1406                          */
1407                         bp[i].new=alloc()/sblock.fs_frag;
1408
1409                         /*
1410                          * There is no frag_adjust() needed for the new block
1411                          * as it will have no fragments yet :-).
1412                          */
1413                         for(f=bp[i].old*sblock.fs_frag,
1414                             g=bp[i].new*sblock.fs_frag;
1415                             f<(bp[i].old+1)*sblock.fs_frag;
1416                             f++, g++) {
1417                                 if(isset(cg_blksfree(&aocg), f)) {
1418                                         setbit(cg_blksfree(&acg), g);
1419                                         acg.cg_cs.cs_nffree++;
1420                                         sblock.fs_cstotal.cs_nffree++;
1421                                 }
1422                         }
1423
1424                         /*
1425                          * Special handling is required if this was the  first
1426                          * block. We have to consider the fragments which were
1427                          * used by the cylinder summary in the original  block
1428                          * which  re to be free in the copy of our  block.  We
1429                          * have  to be careful if this first block happens  to
1430                          * be also the last block to be relocated.
1431                          */
1432                         if(bp[i].flags & GFS_FL_FIRST) {
1433                                 for(f=bp[i].old*sblock.fs_frag,
1434                                     g=bp[i].new*sblock.fs_frag;
1435                                     f<odupper;
1436                                     f++, g++) {
1437                                         setbit(cg_blksfree(&acg), g);
1438                                         acg.cg_cs.cs_nffree++;
1439                                         sblock.fs_cstotal.cs_nffree++;
1440                                 }
1441                                 if(!(bp[i].flags & GFS_FL_LAST)) {
1442                                         frag_adjust(bp[i].new*sblock.fs_frag,1);
1443                                 }
1444                                 
1445                         }
1446
1447                         /*
1448                          * Special handling is required if this is the last
1449                          * block to be relocated.
1450                          */
1451                         if(bp[i].flags & GFS_FL_LAST) {
1452                                 frag_adjust(bp[i].new*sblock.fs_frag, 1);
1453                                 frag_adjust(bp[i].old*sblock.fs_frag, -1);
1454                                 for(f=dupper;
1455                                     f<roundup(dupper, sblock.fs_frag);
1456                                     f++) {
1457                                         if(isclr(cg_blksfree(&acg), f)) {
1458                                                 setbit(cg_blksfree(&acg), f);
1459                                                 acg.cg_cs.cs_nffree++;
1460                                                 sblock.fs_cstotal.cs_nffree++;
1461                                         }
1462                                 }
1463                                 frag_adjust(bp[i].old*sblock.fs_frag, 1);
1464                         }
1465
1466                         /*
1467                          * !!! Attach the cylindergroup offset here. 
1468                          */
1469                         bp[i].old+=cbase/sblock.fs_frag;
1470                         bp[i].new+=cbase/sblock.fs_frag;
1471
1472                         /*
1473                          * Copy the content of the block.
1474                          */
1475                         /*
1476                          * XXX  Here we will have to implement a copy on write
1477                          *      in the case we have any active snapshots.
1478                          */
1479                         rdfs(fsbtodb(&sblock, bp[i].old*sblock.fs_frag),
1480                             (size_t)sblock.fs_bsize, &ablk, fsi);
1481                         wtfs(fsbtodb(&sblock, bp[i].new*sblock.fs_frag),
1482                             (size_t)sblock.fs_bsize, &ablk, fso, Nflag);
1483                         DBG_DUMP_HEX(&sblock,
1484                             "copied full block",
1485                             (unsigned char *)&ablk);
1486
1487                         DBG_PRINT2("scg (%d->%d) block relocated\n",
1488                             bp[i].old,
1489                             bp[i].new);
1490                 }
1491
1492                 /*
1493                  * Now we have to update all references to any fragment which
1494                  * belongs  to any block relocated. We iterate now  over  all
1495                  * cylinder  groups,  within those over all non  zero  length 
1496                  * inodes.
1497                  */
1498                 for(cylno=0; cylno<osblock.fs_ncg; cylno++) {
1499                         DBG_PRINT1("scg doing cg (%d)\n",
1500                             cylno);
1501                         for(inc=osblock.fs_ipg-1 ; inc>=0 ; inc--) {
1502                                 updrefs(cylno, (ino_t)inc, bp, fsi, fso, Nflag);
1503                         }
1504                 }
1505
1506                 /*
1507                  * All inodes are checked, now make sure the number of
1508                  * references found make sense.
1509                  */
1510                 for(i=0; i<ind; i++) {
1511                         if(!bp[i].found || (bp[i].found>sblock.fs_frag)) {
1512                                 warnx("error: %d refs found for block %d.",
1513                                     bp[i].found, bp[i].old);
1514                         }
1515
1516                 }
1517         }
1518         /*
1519          * The following statistics are not changed here:
1520          *     sblock.fs_cstotal.cs_ndir
1521          *     sblock.fs_cstotal.cs_nifree
1522          * The following statistics were already updated on the fly:
1523          *     sblock.fs_cstotal.cs_nffree
1524          *     sblock.fs_cstotal.cs_nbfree
1525          * As the statistics for this cylinder group are ready, copy it to
1526          * the summary information array.
1527          */
1528
1529         *cs = acg.cg_cs;
1530
1531         /*
1532          * Write summary cylinder group back to disk.
1533          */
1534         wtfs(fsbtodb(&sblock, cgtod(&sblock, ocscg)), (size_t)sblock.fs_cgsize,
1535             &acg, fso, Nflag);
1536         DBG_PRINT0("scg written\n");
1537         DBG_DUMP_CG(&sblock,
1538             "new summary cg",
1539             &acg);
1540
1541         DBG_LEAVE;
1542         return;
1543 }
1544
1545 /* ************************************************************** rdfs ***** */
1546 /*
1547  * Here we read some block(s) from disk.
1548  */
1549 static void
1550 rdfs(daddr_t bno, size_t size, void *bf, int fsi)
1551 {
1552         DBG_FUNC("rdfs")
1553         ssize_t n;
1554
1555         DBG_ENTER;
1556
1557         if (lseek(fsi, (off_t)bno * DEV_BSIZE, 0) < 0) {
1558                 err(33, "rdfs: seek error: %ld", (long)bno);
1559         }
1560         n = read(fsi, bf, size);
1561         if (n != (ssize_t)size) {
1562                 err(34, "rdfs: read error: %ld", (long)bno);
1563         }
1564
1565         DBG_LEAVE;
1566         return;
1567 }
1568
1569 /* ************************************************************** wtfs ***** */
1570 /*
1571  * Here we write some block(s) to disk.
1572  */
1573 static void
1574 wtfs(daddr_t bno, size_t size, void *bf, int fso, unsigned int Nflag)
1575 {
1576         DBG_FUNC("wtfs")
1577         ssize_t n;
1578
1579         DBG_ENTER;
1580
1581         if (Nflag) {
1582                 DBG_LEAVE;
1583                 return;
1584         }
1585         if (lseek(fso, (off_t)bno * DEV_BSIZE, SEEK_SET) < 0) {
1586                 err(35, "wtfs: seek error: %ld", (long)bno);
1587         }
1588         n = write(fso, bf, size);
1589         if (n != (ssize_t)size) {
1590                 err(36, "wtfs: write error: %ld", (long)bno);
1591         }
1592
1593         DBG_LEAVE;
1594         return;
1595 }
1596
1597 /* ************************************************************* alloc ***** */
1598 /*
1599  * Here we allocate a free block in the current cylinder group. It is assumed,
1600  * that  acg contains the current cylinder group. As we may take a block  from
1601  * somewhere in the filesystem we have to handle cluster summary here.
1602  */
1603 static daddr_t
1604 alloc(void)
1605 {
1606         DBG_FUNC("alloc")
1607         daddr_t d, blkno;
1608         int     lcs1, lcs2;
1609         int     l;
1610         int     csmin, csmax;
1611         int     dlower, dupper, dmax;
1612
1613         DBG_ENTER;
1614
1615         if (acg.cg_magic != CG_MAGIC) {
1616                 warnx("acg: bad magic number");
1617                 DBG_LEAVE;
1618                 return (0);
1619         }
1620         if (acg.cg_cs.cs_nbfree == 0) {
1621                 warnx("error: cylinder group ran out of space");
1622                 DBG_LEAVE;
1623                 return (0);
1624         }
1625         /*
1626          * We start seeking for free blocks only from the space available after
1627          * the  end of the new grown cylinder summary. Otherwise we allocate  a
1628          * block here which we have to relocate a couple of seconds later again
1629          * again, and we are not prepared to to this anyway.
1630          */
1631         blkno=-1;
1632         dlower=cgsblock(&sblock, acg.cg_cgx)-cgbase(&sblock, acg.cg_cgx);
1633         dupper=cgdmin(&sblock, acg.cg_cgx)-cgbase(&sblock, acg.cg_cgx);
1634         dmax=cgbase(&sblock, acg.cg_cgx)+sblock.fs_fpg;
1635         if (dmax > sblock.fs_size) {
1636                 dmax = sblock.fs_size;
1637         }
1638         dmax-=cgbase(&sblock, acg.cg_cgx); /* retransform into cg */
1639         csmin=sblock.fs_csaddr-cgbase(&sblock, acg.cg_cgx);
1640         csmax=csmin+howmany(sblock.fs_cssize, sblock.fs_fsize);
1641         DBG_PRINT3("seek range: dl=%d, du=%d, dm=%d\n",
1642             dlower,
1643             dupper,
1644             dmax);
1645         DBG_PRINT2("range cont: csmin=%d, csmax=%d\n",
1646             csmin,
1647             csmax);
1648
1649         for(d=0; (d<dlower && blkno==-1); d+=sblock.fs_frag) {
1650                 if(d>=csmin && d<=csmax) {
1651                         continue;
1652                 }
1653                 if(isblock(&sblock, cg_blksfree(&acg), fragstoblks(&sblock,
1654                     d))) {
1655                         blkno = fragstoblks(&sblock, d);/* Yeah found a block */
1656                         break;
1657                 }
1658         }
1659         for(d=dupper; (d<dmax && blkno==-1); d+=sblock.fs_frag) {
1660                 if(d>=csmin && d<=csmax) {
1661                         continue;
1662                 }
1663                 if(isblock(&sblock, cg_blksfree(&acg), fragstoblks(&sblock,
1664                     d))) {
1665                         blkno = fragstoblks(&sblock, d);/* Yeah found a block */
1666                         break;
1667                 }
1668         }
1669         if(blkno==-1) {
1670                 warnx("internal error: couldn't find promised block in cg");
1671                 DBG_LEAVE;
1672                 return (0);
1673         }
1674
1675         /*
1676          * This is needed if the block was found already in the first loop.
1677          */
1678         d=blkstofrags(&sblock, blkno);
1679
1680         clrblock(&sblock, cg_blksfree(&acg), blkno);
1681         if (sblock.fs_contigsumsize > 0) {
1682                 /*
1683                  * Handle the cluster allocation bitmap.
1684                  */
1685                 clrbit(cg_clustersfree(&acg), blkno);
1686                 /*
1687                  * We  possibly have split a cluster here, so we have  to  do
1688                  * recalculate the sizes of the remaining cluster halves now,
1689                  * and use them for updating the cluster summary information.
1690                  *
1691                  * Lets start with the blocks before our allocated block ...
1692                  */
1693                 for(lcs1=0, l=blkno-1; lcs1<sblock.fs_contigsumsize;
1694                     l--, lcs1++ ) {
1695                         if(isclr(cg_clustersfree(&acg),l)){
1696                                 break;
1697                         }
1698                 }
1699                 /*
1700                  * ... and continue with the blocks right after our allocated
1701                  * block.
1702                  */
1703                 for(lcs2=0, l=blkno+1; lcs2<sblock.fs_contigsumsize;
1704                     l++, lcs2++ ) {
1705                         if(isclr(cg_clustersfree(&acg),l)){
1706                                 break;
1707                         }
1708                 }
1709
1710                 /*
1711                  * Now update all counters.
1712                  */
1713                 cg_clustersum(&acg)[MIN(lcs1+lcs2+1,sblock.fs_contigsumsize)]--;
1714                 if(lcs1) {
1715                         cg_clustersum(&acg)[lcs1]++;
1716                 }
1717                 if(lcs2) {
1718                         cg_clustersum(&acg)[lcs2]++;
1719                 }
1720         }
1721         /*
1722          * Update all statistics based on blocks.
1723          */
1724         acg.cg_cs.cs_nbfree--;
1725         sblock.fs_cstotal.cs_nbfree--;
1726         cg_blktot(&acg)[cbtocylno(&sblock, d)]--;
1727         cg_blks(&sblock, &acg, cbtocylno(&sblock, d))[cbtorpos(&sblock, d)]--;
1728
1729         DBG_LEAVE;
1730         return (d);
1731 }
1732
1733 /* *********************************************************** isblock ***** */
1734 /*
1735  * Here  we check if all frags of a block are free. For more details  again
1736  * please see the source of newfs(8), as this function is taken over almost
1737  * unchanged.
1738  */
1739 static int
1740 isblock(struct fs *fs, unsigned char *cp, int h)
1741 {
1742         DBG_FUNC("isblock")
1743         unsigned char   mask;
1744
1745         DBG_ENTER;
1746
1747         switch (fs->fs_frag) {
1748         case 8:
1749                 DBG_LEAVE;
1750                 return (cp[h] == 0xff);
1751         case 4:
1752                 mask = 0x0f << ((h & 0x1) << 2);
1753                 DBG_LEAVE;
1754                 return ((cp[h >> 1] & mask) == mask);
1755         case 2:
1756                 mask = 0x03 << ((h & 0x3) << 1);
1757                 DBG_LEAVE;
1758                 return ((cp[h >> 2] & mask) == mask);
1759         case 1:
1760                 mask = 0x01 << (h & 0x7);
1761                 DBG_LEAVE;
1762                 return ((cp[h >> 3] & mask) == mask);
1763         default:
1764                 fprintf(stderr, "isblock bad fs_frag %d\n", fs->fs_frag);
1765                 DBG_LEAVE;
1766                 return (0);
1767         }
1768 }
1769
1770 /* ********************************************************** clrblock ***** */
1771 /*
1772  * Here we allocate a complete block in the block map. For more details again
1773  * please  see the source of newfs(8), as this function is taken over  almost
1774  * unchanged.
1775  */
1776 static void
1777 clrblock(struct fs *fs, unsigned char *cp, int h)
1778 {
1779         DBG_FUNC("clrblock")
1780
1781         DBG_ENTER;
1782
1783         switch ((fs)->fs_frag) {
1784         case 8:
1785                 cp[h] = 0;
1786                 break;
1787         case 4:
1788                 cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
1789                 break;
1790         case 2:
1791                 cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
1792                 break;
1793         case 1:
1794                 cp[h >> 3] &= ~(0x01 << (h & 0x7));
1795                 break;
1796         default:
1797                 warnx("clrblock bad fs_frag %d", fs->fs_frag);
1798                 break;
1799         }
1800
1801         DBG_LEAVE;
1802         return;
1803 }
1804
1805 /* ********************************************************** setblock ***** */
1806 /*
1807  * Here we free a complete block in the free block map. For more details again
1808  * please  see the source of newfs(8), as this function is taken  over  almost
1809  * unchanged.
1810  */
1811 static void
1812 setblock(struct fs *fs, unsigned char *cp, int h)
1813 {
1814         DBG_FUNC("setblock")
1815
1816         DBG_ENTER;
1817
1818         switch (fs->fs_frag) {
1819         case 8:
1820                 cp[h] = 0xff;
1821                 break;
1822         case 4:
1823                 cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
1824                 break;
1825         case 2:
1826                 cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
1827                 break;
1828         case 1:
1829                 cp[h >> 3] |= (0x01 << (h & 0x7));
1830                 break;
1831         default:
1832                 warnx("setblock bad fs_frag %d", fs->fs_frag);
1833                 break;
1834         }
1835
1836         DBG_LEAVE;
1837         return;
1838 }
1839
1840 /* ************************************************************ ginode ***** */
1841 /*
1842  * This function provides access to an individual inode. We find out in which
1843  * block  the  requested inode is located, read it from disk if  needed,  and
1844  * return  the pointer into that block. We maintain a cache of one  block  to
1845  * not  read the same block again and again if we iterate linearly  over  all
1846  * inodes.
1847  */
1848 static struct ufs1_dinode *
1849 ginode(ino_t inumber, int fsi, int cg)
1850 {
1851         DBG_FUNC("ginode")
1852         ufs_daddr_t     iblk;
1853         static ino_t    startinum=0;    /* first inode in cached block */
1854         struct ufs1_dinode      *pi;
1855
1856         DBG_ENTER;
1857
1858         pi=(struct ufs1_dinode *)(void *)ablk;
1859         inumber+=(cg * sblock.fs_ipg);
1860         if (startinum == 0 || inumber < startinum ||
1861             inumber >= startinum + INOPB(&sblock)) {
1862                 /*
1863                  * The block needed is not cached, so we have to read it from
1864                  * disk now.
1865                  */
1866                 iblk = ino_to_fsba(&sblock, inumber);
1867                 in_src=fsbtodb(&sblock, iblk);
1868                 rdfs(in_src, (size_t)sblock.fs_bsize, &ablk, fsi);
1869                 startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
1870         }
1871
1872         DBG_LEAVE;
1873         return (&(pi[inumber % INOPB(&sblock)]));
1874 }
1875
1876 /* ****************************************************** charsperline ***** */
1877 /*
1878  * Figure out how many lines our current terminal has. For more details again
1879  * please  see the source of newfs(8), as this function is taken over  almost
1880  * unchanged.
1881  */
1882 static int
1883 charsperline(void)
1884 {
1885         DBG_FUNC("charsperline")
1886         int     columns;
1887         char    *cp;
1888         struct winsize  ws;
1889
1890         DBG_ENTER;
1891
1892         columns = 0;
1893         if (ioctl(0, TIOCGWINSZ, &ws) != -1) {
1894                 columns = ws.ws_col;
1895         }
1896         if (columns == 0 && (cp = getenv("COLUMNS"))) {
1897                 columns = atoi(cp);
1898         }
1899         if (columns == 0) {
1900                 columns = 80;   /* last resort */
1901         }
1902
1903         DBG_LEAVE;
1904         return columns;
1905 }
1906
1907 /* ************************************************************** main ***** */
1908 /*
1909  * growfs(8)  is a utility which allows to increase the size of  an  existing
1910  * ufs filesystem. Currently this can only be done on unmounted file  system.
1911  * It  recognizes some command line options to specify the new desired  size,
1912  * and  it does some basic checkings. The old file system size is  determined
1913  * and  after some more checks like we can really access the new  last  block
1914  * on the disk etc. we calculate the new parameters for the superblock. After
1915  * having  done  this we just call growfs() which will do  the  work.  Before
1916  * we finish the only thing left is to update the disklabel.
1917  * We still have to provide support for snapshots. Therefore we first have to
1918  * understand  what data structures are always replicated in the snapshot  on
1919  * creation,  for all other blocks we touch during our procedure, we have  to
1920  * keep the old blocks unchanged somewhere available for the snapshots. If we
1921  * are lucky, then we only have to handle our blocks to be relocated in  that
1922  * way.
1923  * Also  we  have to consider in what order we actually update  the  critical
1924  * data structures of the filesystem to make sure, that in case of a disaster
1925  * fsck(8) is still able to restore any lost data.
1926  * The  foreseen last step then will be to provide for growing  even  mounted
1927  * file  systems. There we have to extend the mount() system call to  provide
1928  * userland access to the file system locking facility.
1929  */
1930 int
1931 main(int argc, char **argv)
1932 {
1933         DBG_FUNC("main")
1934         struct partinfo pinfo;
1935         char    *device, *special, *cp;
1936         char    ch;
1937         unsigned int    size=0;
1938         size_t  len;
1939         unsigned int    Nflag=0;
1940         int     ExpertFlag=0;
1941         struct stat     st;
1942         int     fsi,fso;
1943         char    reply[5];
1944 #ifdef FSMAXSNAP
1945         int     j;
1946 #endif /* FSMAXSNAP */
1947
1948         DBG_ENTER;
1949
1950         while((ch=getopt(argc, argv, "Ns:vy")) != -1) {
1951                 switch(ch) {
1952                 case 'N':
1953                         Nflag=1;
1954                         break;
1955                 case 's':
1956                         size=(size_t)atol(optarg);
1957                         if(size<1) {
1958                                 usage();
1959                         }
1960                         break;
1961                 case 'v': /* for compatibility to newfs */
1962                         break;
1963                 case 'y':
1964                         ExpertFlag=1;
1965                         break;
1966                 case '?':
1967                         /* FALLTHROUGH */
1968                 default:
1969                         usage();
1970                 }
1971         }
1972         argc -= optind;
1973         argv += optind;
1974
1975         if(argc != 1) {
1976                 usage();
1977         }
1978         device=*argv;
1979
1980         /*
1981          * Now try to guess the (raw)device name.
1982          */
1983         if (0 == strrchr(device, '/')) {
1984                 /*
1985                  * No path prefix was given, so try in that order:
1986                  *     /dev/r%s
1987                  *     /dev/%s
1988                  *     /dev/vinum/r%s
1989                  *     /dev/vinum/%s.
1990                  * 
1991                  * FreeBSD now doesn't distinguish between raw and  block
1992                  * devices any longer, but it should still work this way.
1993                  */
1994                 len=strlen(device)+strlen(_PATH_DEV)+2+strlen("vinum/");
1995                 special=(char *)malloc(len);
1996                 if(special == NULL) {
1997                         errx(1, "malloc failed");
1998                 }
1999                 snprintf(special, len, "%sr%s", _PATH_DEV, device);
2000                 if (stat(special, &st) == -1) {
2001                         snprintf(special, len, "%s%s", _PATH_DEV, device);
2002                         if (stat(special, &st) == -1) {
2003                                 snprintf(special, len, "%svinum/r%s",
2004                                     _PATH_DEV, device);
2005                                 if (stat(special, &st) == -1) {
2006                                         /* For now this is the 'last resort' */
2007                                         snprintf(special, len, "%svinum/%s",
2008                                             _PATH_DEV, device);
2009                                 }
2010                         }
2011                 }
2012                 device = special;
2013         }
2014
2015         /*
2016          * Try to access our devices for writing ...
2017          */
2018         if (Nflag) {
2019                 fso = -1;
2020         } else {
2021                 fso = open(device, O_WRONLY);
2022                 if (fso < 0) {
2023                         err(1, "%s", device);
2024                 }
2025         }
2026
2027         /*
2028          * ... and reading.
2029          */
2030         fsi = open(device, O_RDONLY);
2031         if (fsi < 0) {
2032                 err(1, "%s", device);
2033         }
2034
2035         /*
2036          * Try  to read a label and gess the slice if not  specified.  This
2037          * code  should guess the right thing and avaid to bother the  user
2038          * user with the task of specifying the option -v on vinum volumes.
2039          */
2040         cp=device+strlen(device)-1;
2041
2042         if (ioctl(fsi, DIOCGPART, &pinfo) < 0) {
2043                 if (fstat(fsi, &st) < 0)
2044                         err(1, "unable to figure out the partition size");
2045                 pinfo.media_blocks  = st.st_size / DEV_BSIZE;
2046                 pinfo.media_blksize = DEV_BSIZE;
2047         }
2048
2049         /*
2050          * Check if that partition looks suited for growing a file system.
2051          */
2052         if (pinfo.media_blocks < 1) {
2053                 errx(1, "partition is unavailable");
2054         }
2055
2056         /*
2057          * Read the current superblock, and take a backup.
2058          */
2059         rdfs((daddr_t)(SBOFF/DEV_BSIZE), (size_t)SBSIZE, &osblock, fsi);
2060         if (osblock.fs_magic != FS_MAGIC) {
2061                 errx(1, "superblock not recognized");
2062         }
2063         memcpy((void *)&fsun1, (void *)&fsun2, sizeof(fsun2));
2064
2065         DBG_OPEN("/tmp/growfs.debug"); /* already here we need a superblock */
2066         DBG_DUMP_FS(&sblock,
2067             "old sblock");
2068
2069         /*
2070          * Determine size to grow to. Default to the full size specified in
2071          * the disk label.
2072          */
2073         sblock.fs_size = dbtofsb(&osblock, pinfo.media_blocks);
2074         if (size != 0) {
2075                 if (size > pinfo.media_blocks){
2076                         errx(1, "There is not enough space (%ju < %d)",
2077                              (intmax_t)pinfo.media_blocks, size);
2078                 }
2079                 sblock.fs_size = dbtofsb(&osblock, size);       
2080         }
2081
2082         /*
2083          * Are we really growing ?
2084          */
2085         if(osblock.fs_size >= sblock.fs_size) {
2086                 errx(1, "we are not growing (%d->%d)", osblock.fs_size,
2087                     sblock.fs_size);
2088         }
2089
2090
2091 #ifdef FSMAXSNAP
2092         /*
2093          * Check if we find an active snapshot.
2094          */
2095         if(ExpertFlag == 0) {
2096                 for(j=0; j<FSMAXSNAP; j++) {
2097                         if(sblock.fs_snapinum[j]) {
2098                                 errx(1, "active snapshot found in filesystem\n"
2099                                     "   please remove all snapshots before "
2100                                     "using growfs\n");
2101                         }
2102                         if(!sblock.fs_snapinum[j]) { /* list is dense */
2103                                 break;
2104                         }
2105                 }
2106         }
2107 #endif
2108
2109         if (ExpertFlag == 0 && Nflag == 0) {
2110                 printf("We strongly recommend you to make a backup "
2111                     "before growing the Filesystem\n\n"
2112                     " Did you backup your data (Yes/No) ? ");
2113                 fgets(reply, (int)sizeof(reply), stdin);
2114                 if (strcmp(reply, "Yes\n")){
2115                         printf("\n Nothing done \n");
2116                         exit (0);
2117                 }               
2118         }
2119
2120         printf("new filesystemsize is: %d frags\n", sblock.fs_size);
2121
2122         /*
2123          * Try to access our new last block in the filesystem. Even if we
2124          * later on realize we have to abort our operation, on that block
2125          * there should be no data, so we can't destroy something yet.
2126          */
2127         wtfs((daddr_t)pinfo.media_blocks-1, (size_t)DEV_BSIZE, &sblock, fso,
2128             Nflag);
2129
2130         /*
2131          * Now calculate new superblock values and check for reasonable
2132          * bound for new file system size:
2133          *     fs_size:    is derived from label or user input
2134          *     fs_dsize:   should get updated in the routines creating or
2135          *                 updating the cylinder groups on the fly
2136          *     fs_cstotal: should get updated in the routines creating or
2137          *                 updating the cylinder groups
2138          */
2139
2140         /*
2141          * Update the number of cylinders in the filesystem.
2142          */
2143         sblock.fs_ncyl = sblock.fs_size * NSPF(&sblock) / sblock.fs_spc;
2144         if (sblock.fs_size * NSPF(&sblock) > sblock.fs_ncyl * sblock.fs_spc) {
2145                 sblock.fs_ncyl++;
2146         }
2147
2148         /*
2149          * Update the number of cylinder groups in the filesystem.
2150          */
2151         sblock.fs_ncg = sblock.fs_ncyl / sblock.fs_cpg;
2152         if (sblock.fs_ncyl % sblock.fs_cpg) {
2153                 sblock.fs_ncg++;
2154         }
2155
2156         if ((sblock.fs_size - (sblock.fs_ncg-1) * sblock.fs_fpg) <
2157             sblock.fs_fpg && cgdmin(&sblock, (sblock.fs_ncg-1))-
2158             cgbase(&sblock, (sblock.fs_ncg-1)) > (sblock.fs_size -
2159             (sblock.fs_ncg-1) * sblock.fs_fpg )) {
2160                 /*
2161                  * The space in the new last cylinder group is too small,
2162                  * so revert back.
2163                  */
2164                 sblock.fs_ncg--;
2165 #if 1 /* this is a bit more safe */
2166                 sblock.fs_ncyl = sblock.fs_ncg * sblock.fs_cpg;
2167 #else
2168                 sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;
2169 #endif
2170                 sblock.fs_ncyl -= sblock.fs_ncyl % sblock.fs_cpg;
2171                 printf( "Warning: %d sector(s) cannot be allocated.\n",
2172                     (sblock.fs_size-(sblock.fs_ncg)*sblock.fs_fpg) *
2173                     NSPF(&sblock));
2174                 sblock.fs_size = sblock.fs_ncyl * sblock.fs_spc / NSPF(&sblock);
2175         }
2176
2177         /*
2178          * Update the space for the cylinder group summary information in the
2179          * respective cylinder group data area.
2180          */
2181         sblock.fs_cssize =
2182             fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum));
2183         
2184         if(osblock.fs_size >= sblock.fs_size) {
2185                 errx(1, "not enough new space");
2186         }
2187
2188         DBG_PRINT0("sblock calculated\n");
2189
2190         /*
2191          * Ok, everything prepared, so now let's do the tricks.
2192          */
2193         growfs(fsi, fso, Nflag);
2194
2195         close(fsi);
2196         if(fso>-1) close(fso);
2197
2198         DBG_CLOSE;
2199
2200         DBG_LEAVE;
2201         return 0;
2202 }
2203
2204 /* ************************************************************* usage ***** */
2205 /*
2206  * Dump a line of usage.
2207  */
2208 static void
2209 usage(void)
2210 {       
2211         DBG_FUNC("usage")
2212
2213         DBG_ENTER;
2214
2215         fprintf(stderr, "usage: growfs [-Ny] [-s size] special\n");
2216
2217         DBG_LEAVE;
2218         exit(1);
2219 }
2220
2221 /* *********************************************************** updclst ***** */
2222 /*
2223  * This updates most paramters and the bitmap related to cluster. We have to
2224  * assume, that sblock, osblock, acg are set up.
2225  */
2226 static void
2227 updclst(int block)
2228 {       
2229         DBG_FUNC("updclst")
2230         static int      lcs=0;
2231
2232         DBG_ENTER;
2233
2234         if(sblock.fs_contigsumsize < 1) { /* no clustering */
2235                 return;
2236         }
2237         /*
2238          * update cluster allocation map
2239          */
2240         setbit(cg_clustersfree(&acg), block);
2241
2242         /*
2243          * update cluster summary table
2244          */
2245         if(!lcs) {
2246                 /*
2247                  * calculate size for the trailing cluster
2248                  */
2249                 for(block--; lcs<sblock.fs_contigsumsize; block--, lcs++ ) {
2250                         if(isclr(cg_clustersfree(&acg), block)){
2251                                 break;
2252                         }
2253                 }
2254         } 
2255         if(lcs < sblock.fs_contigsumsize) {
2256                 if(lcs) {
2257                         cg_clustersum(&acg)[lcs]--;
2258                 }
2259                 lcs++;
2260                 cg_clustersum(&acg)[lcs]++;
2261         }
2262
2263         DBG_LEAVE;
2264         return;
2265 }
2266
2267 /* *********************************************************** updrefs ***** */
2268 /*
2269  * This updates all references to relocated blocks for the given inode.  The
2270  * inode is given as number within the cylinder group, and the number of the
2271  * cylinder group.
2272  */
2273 static void
2274 updrefs(int cg, ino_t in, struct gfs_bpp *bp, int fsi, int fso, unsigned int
2275     Nflag)
2276 {       
2277         DBG_FUNC("updrefs")
2278         unsigned int    ictr, ind2ctr, ind3ctr;
2279         ufs_daddr_t     *iptr, *ind2ptr, *ind3ptr;
2280         struct ufs1_dinode      *ino;
2281         int     remaining_blocks;
2282
2283         DBG_ENTER;
2284
2285         /*
2286          * XXX We should skip unused inodes even from beeing read from disk
2287          *     here by using the bitmap.
2288          */
2289         ino=ginode(in, fsi, cg);
2290         if(!((ino->di_mode & IFMT)==IFDIR || (ino->di_mode & IFMT)==IFREG ||
2291             (ino->di_mode & IFMT)==IFLNK)) {
2292                 DBG_LEAVE;
2293                 return; /* only check DIR, FILE, LINK */
2294         }
2295         if(((ino->di_mode & IFMT)==IFLNK) && (ino->di_size<MAXSYMLINKLEN)) {
2296                 DBG_LEAVE;
2297                 return; /* skip short symlinks */
2298         }
2299         if(!ino->di_size) {
2300                 DBG_LEAVE;
2301                 return; /* skip empty file */
2302         }
2303         if(!ino->di_blocks) {
2304                 DBG_LEAVE;
2305                 return; /* skip empty swiss cheesy file or old fastlink */
2306         }
2307         DBG_PRINT2("scg checking inode (%d in %d)\n",
2308             in,
2309             cg);
2310
2311         /*
2312          * Start checking all direct blocks.
2313          */
2314         remaining_blocks=howmany(ino->di_size, sblock.fs_bsize);
2315         for(ictr=0; ictr < MIN(NDADDR, (unsigned int)remaining_blocks);
2316             ictr++) {
2317                 iptr=&(ino->di_db[ictr]);
2318                 if(*iptr) {
2319                         cond_bl_upd(iptr, bp, GFS_PS_INODE, fso, Nflag);
2320                 }
2321         }
2322         DBG_PRINT0("~~scg direct blocks checked\n");
2323
2324         remaining_blocks-=NDADDR;
2325         if(remaining_blocks<0) {
2326                 DBG_LEAVE;
2327                 return;
2328         }
2329         if(ino->di_ib[0]) {
2330                 /*
2331                  * Start checking first indirect block
2332                  */
2333                 cond_bl_upd(&(ino->di_ib[0]), bp, GFS_PS_INODE, fso, Nflag);
2334                 i1_src=fsbtodb(&sblock, ino->di_ib[0]);
2335                 rdfs(i1_src, (size_t)sblock.fs_bsize, &i1blk, fsi);
2336                 for(ictr=0; ictr < MIN(howmany(sblock.fs_bsize,
2337                     sizeof(ufs_daddr_t)), (unsigned int)remaining_blocks);
2338                     ictr++) {
2339                         iptr=&((ufs_daddr_t *)(void *)&i1blk)[ictr];
2340                         if(*iptr) {
2341                                 cond_bl_upd(iptr, bp, GFS_PS_IND_BLK_LVL1,
2342                                     fso, Nflag);
2343                         }
2344                 }
2345         }
2346         DBG_PRINT0("scg indirect_1 blocks checked\n");
2347
2348         remaining_blocks-= howmany(sblock.fs_bsize, sizeof(ufs_daddr_t));
2349         if(remaining_blocks<0) {
2350                 DBG_LEAVE;
2351                 return;
2352         }
2353         if(ino->di_ib[1]) {
2354                 /*
2355                  * Start checking second indirect block
2356                  */
2357                 cond_bl_upd(&(ino->di_ib[1]), bp, GFS_PS_INODE, fso, Nflag);
2358                 i2_src=fsbtodb(&sblock, ino->di_ib[1]);
2359                 rdfs(i2_src, (size_t)sblock.fs_bsize, &i2blk, fsi);
2360                 for(ind2ctr=0; ind2ctr < howmany(sblock.fs_bsize,
2361                     sizeof(ufs_daddr_t)); ind2ctr++) {
2362                         ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)[ind2ctr];
2363                         if(!*ind2ptr) {
2364                                 continue;
2365                         }
2366                         cond_bl_upd(ind2ptr, bp, GFS_PS_IND_BLK_LVL2, fso,
2367                             Nflag);
2368                         i1_src=fsbtodb(&sblock, *ind2ptr);
2369                         rdfs(i1_src, (size_t)sblock.fs_bsize, &i1blk,
2370                             fsi);
2371                         for(ictr=0; ictr<MIN(howmany((unsigned int)
2372                             sblock.fs_bsize, sizeof(ufs_daddr_t)),
2373                             (unsigned int)remaining_blocks); ictr++) {
2374                                 iptr=&((ufs_daddr_t *)(void *)&i1blk)[ictr];
2375                                 if(*iptr) {
2376                                         cond_bl_upd(iptr, bp,
2377                                             GFS_PS_IND_BLK_LVL1, fso, Nflag);
2378                                 }
2379                         }
2380                 }
2381         }
2382         DBG_PRINT0("scg indirect_2 blocks checked\n");
2383
2384 #define SQUARE(a) ((a)*(a))
2385         remaining_blocks-=SQUARE(howmany(sblock.fs_bsize, sizeof(ufs_daddr_t)));
2386 #undef SQUARE
2387         if(remaining_blocks<0) {
2388                 DBG_LEAVE;
2389                 return;
2390         }
2391                         
2392         if(ino->di_ib[2]) {
2393                 /*
2394                  * Start checking third indirect block
2395                  */
2396                 cond_bl_upd(&(ino->di_ib[2]), bp, GFS_PS_INODE, fso, Nflag);
2397                 i3_src=fsbtodb(&sblock, ino->di_ib[2]);
2398                 rdfs(i3_src, (size_t)sblock.fs_bsize, &i3blk, fsi);
2399                 for(ind3ctr=0; ind3ctr < howmany(sblock.fs_bsize,
2400                     sizeof(ufs_daddr_t)); ind3ctr ++) {
2401                         ind3ptr=&((ufs_daddr_t *)(void *)&i3blk)[ind3ctr];
2402                         if(!*ind3ptr) {
2403                                 continue;
2404                         }
2405                         cond_bl_upd(ind3ptr, bp, GFS_PS_IND_BLK_LVL3, fso,
2406                             Nflag);
2407                         i2_src=fsbtodb(&sblock, *ind3ptr);
2408                         rdfs(i2_src, (size_t)sblock.fs_bsize, &i2blk,
2409                             fsi);
2410                         for(ind2ctr=0; ind2ctr < howmany(sblock.fs_bsize,
2411                             sizeof(ufs_daddr_t)); ind2ctr ++) {
2412                                 ind2ptr=&((ufs_daddr_t *)(void *)&i2blk)
2413                                     [ind2ctr];
2414                                 if(!*ind2ptr) {
2415                                         continue;
2416                                 }
2417                                 cond_bl_upd(ind2ptr, bp, GFS_PS_IND_BLK_LVL2,
2418                                     fso, Nflag);
2419                                 i1_src=fsbtodb(&sblock, *ind2ptr);
2420                                 rdfs(i1_src, (size_t)sblock.fs_bsize,
2421                                     &i1blk, fsi);
2422                                 for(ictr=0; ictr < MIN(howmany(sblock.fs_bsize,
2423                                     sizeof(ufs_daddr_t)),
2424                                     (unsigned int)remaining_blocks); ictr++) {
2425                                         iptr=&((ufs_daddr_t *)(void *)&i1blk)
2426                                             [ictr];
2427                                         if(*iptr) {
2428                                                 cond_bl_upd(iptr, bp,
2429                                                     GFS_PS_IND_BLK_LVL1, fso,
2430                                                     Nflag);
2431                                         }
2432                                 }
2433                         }
2434                 }
2435         }
2436
2437         DBG_PRINT0("scg indirect_3 blocks checked\n");
2438
2439         DBG_LEAVE;
2440         return;
2441 }
2442