diff options
author | schweikh <schweikh@FreeBSD.org> | 2003-04-26 15:22:29 +0000 |
---|---|---|
committer | schweikh <schweikh@FreeBSD.org> | 2003-04-26 15:22:29 +0000 |
commit | 8515af8eea9ffb6998d2f4b8fd37b1f4e5a55a74 (patch) | |
tree | df0785c3c40cd09311e2395dbe038feab4883989 /sbin/growfs | |
parent | dfd12715213936467a1da6a9d565806bc5253fa6 (diff) | |
download | FreeBSD-src-8515af8eea9ffb6998d2f4b8fd37b1f4e5a55a74.zip FreeBSD-src-8515af8eea9ffb6998d2f4b8fd37b1f4e5a55a74.tar.gz |
Fix typos in comments; some style(9) fixes; no code changes.
PR: misc/50979
Submitted by: Lukas Ertl <l.ertl@univie.ac.at>
Diffstat (limited to 'sbin/growfs')
-rw-r--r-- | sbin/growfs/growfs.c | 238 |
1 files changed, 117 insertions, 121 deletions
diff --git a/sbin/growfs/growfs.c b/sbin/growfs/growfs.c index 3deb47b..0374387 100644 --- a/sbin/growfs/growfs.c +++ b/sbin/growfs/growfs.c @@ -2,10 +2,10 @@ * Copyright (c) 2000 Christoph Herrmann, Thomas-Henning von Kamptz * Copyright (c) 1980, 1989, 1993 The Regents of the University of California. * All rights reserved. - * + * * This code is derived from software contributed to Berkeley by * Christoph Herrmann and Thomas-Henning von Kamptz, Munich and Frankfurt. - * + * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: @@ -22,7 +22,7 @@ * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. - * + * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE @@ -112,7 +112,7 @@ static char inobuf[MAXBSIZE]; /* inode block */ static int maxino; /* last valid inode */ /* - * An array of elements of type struct gfs_bpp describes all blocks to + * An array of elements of type struct gfs_bpp describes all blocks to * be relocated in order to free the space needed for the cylinder group * summary for all cylinder groups located in the first cylinder group. */ @@ -151,13 +151,13 @@ static void indirchk(ufs_lbn_t, ufs_lbn_t, ufs2_daddr_t, ufs_lbn_t, /* ************************************************************ growfs ***** */ /* - * Here we actually start growing the file system. We basically read the - * cylinder summary from the first cylinder group as we want to update - * this on the fly during our various operations. First we handle the + * Here we actually start growing the file system. We basically read the + * cylinder summary from the first cylinder group as we want to update + * this on the fly during our various operations. First we handle the * changes in the former last cylinder group. Afterwards we create all new - * cylinder groups. Now we handle the cylinder group containing the - * cylinder summary which might result in a relocation of the whole - * structure. In the end we write back the updated cylinder summary, the + * cylinder groups. Now we handle the cylinder group containing the + * cylinder summary which might result in a relocation of the whole + * structure. In the end we write back the updated cylinder summary, the * new superblock, and slightly patched versions of the super block * copies. */ @@ -317,7 +317,7 @@ growfs(int fsi, int fso, unsigned int Nflag) /* * XXX - * The following fields are currently distributed from the superblock + * The following fields are currently distributed from the superblock * to the copies: * fs_minfree * fs_rotdelay @@ -329,10 +329,10 @@ growfs(int fsi, int fso, unsigned int Nflag) * * We probably should rather change the summary for the cylinder group * statistics here to the value of what would be in there, if the file - * system were created initially with the new size. Therefor we still + * system were created initially with the new size. Therefor we still * need to find an easy way of calculating that. * Possibly we can try to read the first superblock copy and apply the - * "diffed" stats between the old and new superblock by still copying + * "diffed" stats between the old and new superblock by still copying * certain parameters onto that. */ @@ -353,9 +353,9 @@ growfs(int fsi, int fso, unsigned int Nflag) /* ************************************************************ initcg ***** */ /* - * This creates a new cylinder group structure, for more details please see - * the source of newfs(8), as this function is taken over almost unchanged. - * As this is never called for the first cylinder group, the special + * This creates a new cylinder group structure, for more details please see + * the source of newfs(8), as this function is taken over almost unchanged. + * As this is never called for the first cylinder group, the special * provisions for that case are removed here. */ static void @@ -535,9 +535,9 @@ initcg(int cylno, time_t utime, int fso, unsigned int Nflag) /* ******************************************************* frag_adjust ***** */ /* - * Here we add or subtract (sign +1/-1) the available fragments in a given + * Here we add or subtract (sign +1/-1) the available fragments in a given * block to or from the fragment statistics. By subtracting before and adding - * after an operation on the free frag map we can easy update the fragment + * after an operation on the free frag map we can easy update the fragment * statistic, which seems to be otherwise a rather complex operation. */ static void @@ -554,11 +554,11 @@ frag_adjust(ufs2_daddr_t frag, int sign) * Here frag only needs to point to any fragment in the block we want * to examine. */ - for(f=rounddown(frag, sblock.fs_frag); + for(f=rounddown(frag, sblock.fs_frag); f<roundup(frag+1, sblock.fs_frag); f++) { /* - * Count contiguos free fragments. + * Count contiguous free fragments. */ if(isset(cg_blksfree(&acg), f)) { fragsize++; @@ -595,9 +595,9 @@ frag_adjust(ufs2_daddr_t frag, int sign) /* ******************************************************* cond_bl_upd ***** */ /* * Here we conditionally update a pointer to a fragment. We check for all - * relocated blocks if any of it's fragments is referenced by the current - * field, and update the pointer to the respective fragment in our new - * block. If we find a reference we write back the block immediately, + * relocated blocks if any of its fragments is referenced by the current + * field, and update the pointer to the respective fragment in our new + * block. If we find a reference we write back the block immediately, * as there is no easy way for our general block reading engine to figure * out if a write back operation is needed. */ @@ -657,13 +657,13 @@ cond_bl_upd(ufs2_daddr_t *block, struct gfs_bpp *field, int fsi, int fso, /* ************************************************************ updjcg ***** */ /* * Here we do all needed work for the former last cylinder group. It has to be - * changed in any case, even if the file system ended exactly on the end of - * this group, as there is some slightly inconsistent handling of the number - * of cylinders in the cylinder group. We start again by reading the cylinder + * changed in any case, even if the file system ended exactly on the end of + * this group, as there is some slightly inconsistent handling of the number + * of cylinders in the cylinder group. We start again by reading the cylinder * group from disk. If the last block was not fully available, we first handle - * the missing fragments, then we handle all new full blocks in that file - * system and finally we handle the new last fragmented block in the file - * system. We again have to handle the fragment statistics rotational layout + * the missing fragments, then we handle all new full blocks in that file + * system and finally we handle the new last fragmented block in the file + * system. We again have to handle the fragment statistics rotational layout * tables and cluster summary during all those operations. */ static void @@ -691,12 +691,12 @@ updjcg(int cylno, time_t utime, int fsi, int fso, unsigned int Nflag) memcpy((void *)&cgun1, (void *)&cgun2, sizeof(cgun2)); /* - * If the cylinder group had already it's new final size almost + * If the cylinder group had already its new final size almost * nothing is to be done ... except: * For some reason the value of cg_ncyl in the last cylinder group has - * to be zero instead of fs_cpg. As this is now no longer the last + * to be zero instead of fs_cpg. As this is now no longer the last * cylinder group we have to change that value now to fs_cpg. - */ + */ if(cgbase(&osblock, cylno+1) == osblock.fs_size) { if (sblock.fs_magic == FS_UFS1_MAGIC) @@ -760,11 +760,11 @@ updjcg(int cylno, time_t utime, int fsi, int fso, unsigned int Nflag) } /* - * Now we have to update the free fragment bitmap for our new free - * space. There again we have to handle the fragmentation and also - * the rotational layout tables and the cluster summary. This is - * also done per fragment for the first new block if the old file - * system end was not on a block boundary, per fragment for the new + * Now we have to update the free fragment bitmap for our new free + * space. There again we have to handle the fragmentation and also + * the rotational layout tables and the cluster summary. This is + * also done per fragment for the first new block if the old file + * system end was not on a block boundary, per fragment for the new * last block if the new file system end is not on a block boundary, * and per block for all space in between. * @@ -787,7 +787,7 @@ updjcg(int cylno, time_t utime, int fsi, int fso, unsigned int Nflag) } /* - * Check if the fragment just created could join an + * Check if the fragment just created could join an * already existing fragment at the former end of the * file system. */ @@ -795,7 +795,7 @@ updjcg(int cylno, time_t utime, int fsi, int fso, unsigned int Nflag) ((osblock.fs_size - cgbase(&sblock, cylno))/ sblock.fs_frag))) { /* - * The block is now completely available + * The block is now completely available. */ DBG_PRINT0("block was\n"); acg.cg_frsum[osblock.fs_size%sblock.fs_frag]--; @@ -864,7 +864,7 @@ updjcg(int cylno, time_t utime, int fsi, int fso, unsigned int Nflag) /* * Handle the last new block if there are stll some new fragments left. - * Here we don't have to bother about the cluster summary or the even + * Here we don't have to bother about the cluster summary or the even * the rotational layout table. */ if (i < (dmax - cbase)) { @@ -904,19 +904,19 @@ updjcg(int cylno, time_t utime, int fsi, int fso, unsigned int Nflag) /* ********************************************************** updcsloc ***** */ /* - * Here we update the location of the cylinder summary. We have two possible + * Here we update the location of the cylinder summary. We have two possible * ways of growing the cylinder summary. - * (1) We can try to grow the summary in the current location, and relocate + * (1) We can try to grow the summary in the current location, and relocate * possibly used blocks within the current cylinder group. * (2) Alternatively we can relocate the whole cylinder summary to the first - * new completely empty cylinder group. Once the cylinder summary is no - * longer in the beginning of the first cylinder group you should never - * use a version of fsck which is not aware of the possibility to have + * new completely empty cylinder group. Once the cylinder summary is no + * longer in the beginning of the first cylinder group you should never + * use a version of fsck which is not aware of the possibility to have * this structure in a non standard place. - * Option (1) is considered to be less intrusive to the structure of the file- + * Option (1) is considered to be less intrusive to the structure of the file- * system. So we try to stick to that whenever possible. If there is not enough - * space in the cylinder group containing the cylinder summary we have to use - * method (2). In case of active snapshots in the file system we probably can + * space in the cylinder group containing the cylinder summary we have to use + * method (2). In case of active snapshots in the file system we probably can * completely avoid implementing copy on write if we stick to method (2) only. */ static void @@ -972,27 +972,27 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) /* * XXX In the case of having active snapshots we may need much more - * blocks for the copy on write. We need each block twice, and - * also up to 8*3 blocks for indirect blocks for all possible + * blocks for the copy on write. We need each block twice, and + * also up to 8*3 blocks for indirect blocks for all possible * references. */ if(/*((int)sblock.fs_time&0x3)>0||*/ cs->cs_nbfree < blocks) { /* - * There is not enough space in the old cylinder group to - * relocate all blocks as needed, so we relocate the whole - * cylinder group summary to a new group. We try to use the + * There is not enough space in the old cylinder group to + * relocate all blocks as needed, so we relocate the whole + * cylinder group summary to a new group. We try to use the * first complete new cylinder group just created. Within the - * cylinder group we allign the area immediately after the - * cylinder group information location in order to be as + * cylinder group we align the area immediately after the + * cylinder group information location in order to be as * close as possible to the original implementation of ffs. * - * First we have to make sure we'll find enough space in the - * new cylinder group. If not, then we currently give up. - * We start with freeing everything which was used by the + * First we have to make sure we'll find enough space in the + * new cylinder group. If not, then we currently give up. + * We start with freeing everything which was used by the * fragments of the old cylinder summary in the current group. - * Now we write back the group meta data, read in the needed + * Now we write back the group meta data, read in the needed * meta data from the new cylinder group, and start allocating - * within that group. Here we can assume, the group to be + * within that group. Here we can assume, the group to be * completely empty. Which makes the handling of fragments and * clusters a lot easier. */ @@ -1009,7 +1009,7 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) /* * Set up last cluster size ("lcs") already here. Calculate - * the size for the trailing cluster just behind where "d" + * the size for the trailing cluster just behind where "d" * points to. */ if(sblock.fs_contigsumsize > 0) { @@ -1044,16 +1044,15 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) sblock.fs_cstotal.cs_nffree++; } /* - * Point "d" to the last fragment of the last - * (incomplete) block of the clinder summary. + * Point "d" to the last fragment of the last + * (incomplete) block of the cylinder summary. */ d++; frag_adjust(d%sblock.fs_fpg, 1); if(isblock(&sblock, cg_blksfree(&acg), (d%sblock.fs_fpg)/sblock.fs_frag)) { - DBG_PRINT1("d=%d\n", - d); + DBG_PRINT1("d=%d\n", d); acg.cg_cs.cs_nffree-=sblock.fs_frag; acg.cg_cs.cs_nbfree++; sblock.fs_cstotal.cs_nffree-=sblock.fs_frag; @@ -1078,13 +1077,11 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) d--; } - DBG_PRINT1("d=%d\n", - d); + DBG_PRINT1("d=%d\n", d); for(d=rounddown(d, sblock.fs_frag); d >= osblock.fs_csaddr; d-=sblock.fs_frag) { DBG_TRC; - DBG_PRINT1("d=%d\n", - d); + DBG_PRINT1("d=%d\n", d); setblock(&sblock, cg_blksfree(&acg), (d%sblock.fs_fpg)/sblock.fs_frag); acg.cg_cs.cs_nbfree++; @@ -1191,7 +1188,7 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) frag_adjust(d%sblock.fs_fpg, +1); } /* - * XXX Handle the cluster statistics here in the case this + * XXX Handle the cluster statistics here in the case this * cylinder group is now almost full, and the remaining * space is less then the maximum cluster size. This is * probably not needed, as you would hardly find a file @@ -1221,7 +1218,7 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) } /* * We have got enough of space in the current cylinder group, so we - * can relocate just a few blocks, and let the summary information + * can relocate just a few blocks, and let the summary information * grow in place where it is right now. */ DBG_TRC; @@ -1246,11 +1243,11 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) sizeof(struct gfs_bpp)); /* - * Lock all new frags needed for the cylinder group summary. This is - * done per fragment in the first and last block of the new required + * Lock all new frags needed for the cylinder group summary. This is + * done per fragment in the first and last block of the new required * area, and per block for all other blocks. * - * Handle the first new block here (but only if some fragments where + * Handle the first new block here (but only if some fragments where * already used for the cylinder summary). */ ind=0; @@ -1274,7 +1271,7 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) } /* * No cluster handling is needed here, as there was at least - * one fragment in use by the cylinder summary in the old + * one fragment in use by the cylinder summary in the old * file system. * No block-free counter handling here as this block was not * a free block. @@ -1380,7 +1377,7 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) if(!bp[i].old) { /* no more blocks listed */ /* * XXX A relative blocknumber should not be - * zero, which is not explicitly + * zero, which is not explicitly * guaranteed by our code. */ break; @@ -1407,11 +1404,11 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) } /* - * Special handling is required if this was the first + * Special handling is required if this was the first * block. We have to consider the fragments which were - * used by the cylinder summary in the original block - * which re to be free in the copy of our block. We - * have to be careful if this first block happens to + * used by the cylinder summary in the original block + * which re to be free in the copy of our block. We + * have to be careful if this first block happens to * be also the last block to be relocated. */ if(bp[i].flags & GFS_FL_FIRST) { @@ -1426,7 +1423,6 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) if(!(bp[i].flags & GFS_FL_LAST)) { frag_adjust(bp[i].new*sblock.fs_frag,1); } - } /* @@ -1449,7 +1445,7 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) } /* - * !!! Attach the cylindergroup offset here. + * !!! Attach the cylindergroup offset here. */ bp[i].old+=cbase/sblock.fs_frag; bp[i].new+=cbase/sblock.fs_frag; @@ -1476,8 +1472,8 @@ updcsloc(time_t utime, int fsi, int fso, unsigned int Nflag) /* * Now we have to update all references to any fragment which - * belongs to any block relocated. We iterate now over all - * cylinder groups, within those over all non zero length + * belongs to any block relocated. We iterate now over all + * cylinder groups, within those over all non zero length * inodes. */ for(cylno=0; cylno<osblock.fs_ncg; cylno++) { @@ -1582,7 +1578,7 @@ wtfs(ufs2_daddr_t bno, size_t size, void *bf, int fso, unsigned int Nflag) /* ************************************************************* alloc ***** */ /* * Here we allocate a free block in the current cylinder group. It is assumed, - * that acg contains the current cylinder group. As we may take a block from + * that acg contains the current cylinder group. As we may take a block from * somewhere in the file system we have to handle cluster summary here. */ static ufs2_daddr_t @@ -1609,7 +1605,7 @@ alloc(void) } /* * We start seeking for free blocks only from the space available after - * the end of the new grown cylinder summary. Otherwise we allocate a + * the end of the new grown cylinder summary. Otherwise we allocate a * block here which we have to relocate a couple of seconds later again * again, and we are not prepared to to this anyway. */ @@ -1669,7 +1665,7 @@ alloc(void) */ clrbit(cg_clustersfree(&acg), blkno); /* - * We possibly have split a cluster here, so we have to do + * We possibly have split a cluster here, so we have to do * recalculate the sizes of the remaining cluster halves now, * and use them for updating the cluster summary information. * @@ -1715,7 +1711,7 @@ alloc(void) /* *********************************************************** isblock ***** */ /* - * Here we check if all frags of a block are free. For more details again + * Here we check if all frags of a block are free. For more details again * please see the source of newfs(8), as this function is taken over almost * unchanged. */ @@ -1753,7 +1749,7 @@ isblock(struct fs *fs, unsigned char *cp, int h) /* ********************************************************** clrblock ***** */ /* * Here we allocate a complete block in the block map. For more details again - * please see the source of newfs(8), as this function is taken over almost + * please see the source of newfs(8), as this function is taken over almost * unchanged. */ static void @@ -1788,7 +1784,7 @@ clrblock(struct fs *fs, unsigned char *cp, int h) /* ********************************************************** setblock ***** */ /* * Here we free a complete block in the free block map. For more details again - * please see the source of newfs(8), as this function is taken over almost + * please see the source of newfs(8), as this function is taken over almost * unchanged. */ static void @@ -1823,9 +1819,9 @@ setblock(struct fs *fs, unsigned char *cp, int h) /* ************************************************************ ginode ***** */ /* * This function provides access to an individual inode. We find out in which - * block the requested inode is located, read it from disk if needed, and - * return the pointer into that block. We maintain a cache of one block to - * not read the same block again and again if we iterate linearly over all + * block the requested inode is located, read it from disk if needed, and + * return the pointer into that block. We maintain a cache of one block to + * not read the same block again and again if we iterate linearly over all * inodes. */ static union dinode * @@ -1856,7 +1852,7 @@ ginode(ino_t inumber, int fsi, int cg) /* ****************************************************** charsperline ***** */ /* * Figure out how many lines our current terminal has. For more details again - * please see the source of newfs(8), as this function is taken over almost + * please see the source of newfs(8), as this function is taken over almost * unchanged. */ static int @@ -1886,25 +1882,25 @@ charsperline(void) /* ************************************************************** main ***** */ /* - * growfs(8) is a utility which allows to increase the size of an existing - * ufs file system. Currently this can only be done on unmounted file system. - * It recognizes some command line options to specify the new desired size, - * and it does some basic checkings. The old file system size is determined - * and after some more checks like we can really access the new last block + * growfs(8) is a utility which allows to increase the size of an existing + * ufs file system. Currently this can only be done on unmounted file system. + * It recognizes some command line options to specify the new desired size, + * and it does some basic checkings. The old file system size is determined + * and after some more checks like we can really access the new last block * on the disk etc. we calculate the new parameters for the superblock. After - * having done this we just call growfs() which will do the work. Before + * having done this we just call growfs() which will do the work. Before * we finish the only thing left is to update the disklabel. * We still have to provide support for snapshots. Therefore we first have to - * understand what data structures are always replicated in the snapshot on - * creation, for all other blocks we touch during our procedure, we have to + * understand what data structures are always replicated in the snapshot on + * creation, for all other blocks we touch during our procedure, we have to * keep the old blocks unchanged somewhere available for the snapshots. If we - * are lucky, then we only have to handle our blocks to be relocated in that + * are lucky, then we only have to handle our blocks to be relocated in that * way. - * Also we have to consider in what order we actually update the critical + * Also we have to consider in what order we actually update the critical * data structures of the file system to make sure, that in case of a disaster * fsck(8) is still able to restore any lost data. - * The foreseen last step then will be to provide for growing even mounted - * file systems. There we have to extend the mount() system call to provide + * The foreseen last step then will be to provide for growing even mounted + * file systems. There we have to extend the mount() system call to provide * userland access to the file system locking facility. */ int @@ -1968,8 +1964,8 @@ main(int argc, char **argv) * /dev/%s * /dev/vinum/r%s * /dev/vinum/%s. - * - * FreeBSD now doesn't distinguish between raw and block + * + * FreeBSD now doesn't distinguish between raw and block * devices any longer, but it should still work this way. */ len=strlen(device)+strlen(_PATH_DEV)+2+strlen("vinum/"); @@ -2014,9 +2010,9 @@ main(int argc, char **argv) } /* - * Try to read a label and gess the slice if not specified. This - * code should guess the right thing and avaid to bother the user - * user with the task of specifying the option -v on vinum volumes. + * Try to read a label and guess the slice if not specified. This + * code should guess the right thing and avoid to bother the user + * with the task of specifying the option -v on vinum volumes. */ cp=device+strlen(device)-1; lp = get_disklabel(fsi); @@ -2031,7 +2027,7 @@ main(int argc, char **argv) } /* - * Check if that partition looks suited for growing a file system. + * Check if that partition is suitable for growing a file system. */ if (pp->p_size < 1) { errx(1, "partition is unavailable"); @@ -2073,7 +2069,7 @@ main(int argc, char **argv) errx(1, "There is not enough space (%d < %d)", pp->p_size, size); } - sblock.fs_size = dbtofsb(&osblock, size); + sblock.fs_size = dbtofsb(&osblock, size); } /* @@ -2111,7 +2107,7 @@ main(int argc, char **argv) if (strcmp(reply, "Yes\n")){ printf("\n Nothing done \n"); exit (0); - } + } } printf("new file systemsize is: %d frags\n", sblock.fs_size); @@ -2167,7 +2163,7 @@ main(int argc, char **argv) */ sblock.fs_cssize = fragroundup(&sblock, sblock.fs_ncg * sizeof(struct csum)); - + if(osblock.fs_size >= sblock.fs_size) { errx(1, "not enough new space"); } @@ -2269,7 +2265,7 @@ get_disklabel(int fd) */ static void usage(void) -{ +{ DBG_FUNC("usage") DBG_ENTER; @@ -2282,12 +2278,12 @@ usage(void) /* *********************************************************** updclst ***** */ /* - * This updates most paramters and the bitmap related to cluster. We have to - * assume, that sblock, osblock, acg are set up. + * This updates most parameters and the bitmap related to cluster. We have to + * assume that sblock, osblock, acg are set up. */ static void updclst(int block) -{ +{ DBG_FUNC("updclst") static int lcs=0; @@ -2313,7 +2309,7 @@ updclst(int block) break; } } - } + } if(lcs < sblock.fs_contigsumsize) { if(lcs) { cg_clustersum(&acg)[lcs]--; @@ -2335,7 +2331,7 @@ updclst(int block) static void updrefs(int cg, ino_t in, struct gfs_bpp *bp, int fsi, int fso, unsigned int Nflag) -{ +{ DBG_FUNC("updrefs") ufs_lbn_t len, lbn, numblks; ufs2_daddr_t iptr, blksperindir; |