home *** CD-ROM | disk | FTP | other *** search
/ NetNews Usenet Archive 1992 #30 / NN_1992_30.iso / spool / comp / unix / bsd / 10148 < prev    next >
Encoding:
Internet Message Format  |  1992-12-13  |  23.1 KB
  1. Path: sparky!uunet!cs.utexas.edu!sun-barr!ames!pacbell.com!hoptoad!curt
  2. From: curt@hoptoad.uucp (Curt Mayer)
  3. Newsgroups: comp.unix.bsd
  4. Subject: Almost Free Symbolic Links (source code)
  5. Message-ID: <39777@hoptoad.uucp>
  6. Date: 13 Dec 92 02:45:58 GMT
  7. Distribution: world
  8. Organization: kernel hackers R us
  9. Lines: 828
  10. Keywords: symlink data in inode block list
  11. Summary: cute hack
  12.  
  13. ---------cut anywhere near here----------
  14. : To unbundle, sh this file
  15. #!/bin/sh
  16. mkdir .
  17. echo ./README
  18. cat >./README <<'@@@ Fin de ./README'
  19. this cruddy but complete hack answers one of the objections to symlinks:
  20. that they are slow, and cost an entire frag. symlinks of less than length
  21. 60 are stored in the inode itself. symlinks longer than this are still
  22. in the inode. to make the illusion of normality complete, dump and fsck
  23. are hacked. additionally, I made dumpfs verbose to excess.
  24.  
  25. stability is perfect, having been in since 0.1 came out.
  26.  
  27. to create fast symlinks, just put FASTLINKS in your kernel options, reconfig
  28. and rebuild.
  29. if you try to read a filesystem containing fast links with a kernel not built
  30. for them, you just get an einval when you reference any fast link. I call that
  31. a soft failure. a floppy boot disk needn't contain any symlinks anyway.
  32.  
  33. share and enjoy.
  34.  
  35. legalese:
  36. hack, slash, and redistribute all you want, just don't claim you wrote it.
  37.  
  38. @@@ Fin de ./README
  39. echo ./dump.diffs
  40. cat >./dump.diffs <<'@@@ Fin de ./dump.diffs'
  41. diff -c /usr/src/sbin/dump/dumptraverse.c /usr/src/sbin/dump.new/dumptraverse.c
  42. *** /usr/src/sbin/dump/dumptraverse.c    Wed Apr 24 17:55:03 1991
  43. --- /usr/src/sbin/dump.new/dumptraverse.c    Mon Nov  2 21:50:31 1992
  44. ***************
  45. *** 308,313 ****
  46. --- 308,320 ----
  47.           writeheader(ino);
  48.           return;
  49.       }
  50. +     if (DFASTLINK(*dp)) {
  51. +         spcl.c_addr[0] = 1;
  52. +         spcl.c_count = 1;
  53. +         writeheader(ino);
  54. +         writerec(dp->di_symlink);
  55. +         return;
  56. +     }
  57.       if (dp->di_size > NDADDR * sblock->fs_bsize)
  58.           cnt = NDADDR * sblock->fs_frag;
  59.       else
  60. @@@ Fin de ./dump.diffs
  61. echo ./fsck.diffs
  62. cat >./fsck.diffs <<'@@@ Fin de ./fsck.diffs'
  63. diff -c /usr/src/sbin/fsck/inode.c /usr/src/sbin/fsck.new/inode.c
  64. *** /usr/src/sbin/fsck/inode.c    Sat Apr 20 14:39:03 1991
  65. --- /usr/src/sbin/fsck.new/inode.c    Thu Oct 29 23:43:25 1992
  66. ***************
  67. *** 58,64 ****
  68.           idesc->id_fix = DONTKNOW;
  69.       idesc->id_entryno = 0;
  70.       idesc->id_filesize = dp->di_size;
  71. !     if ((dp->di_mode & IFMT) == IFBLK || (dp->di_mode & IFMT) == IFCHR)
  72.           return (KEEPON);
  73.       dino = *dp;
  74.       ndb = howmany(dino.di_size, sblock.fs_bsize);
  75. --- 58,65 ----
  76.           idesc->id_fix = DONTKNOW;
  77.       idesc->id_entryno = 0;
  78.       idesc->id_filesize = dp->di_size;
  79. !     if ((dp->di_mode & IFMT) == IFBLK || (dp->di_mode & IFMT) == IFCHR ||
  80. !         DFASTLINK(*dp))
  81.           return (KEEPON);
  82.       dino = *dp;
  83.       ndb = howmany(dino.di_size, sblock.fs_bsize);
  84. diff -c /usr/src/sbin/fsck/pass1.c /usr/src/sbin/fsck.new/pass1.c
  85. *** /usr/src/sbin/fsck/pass1.c    Sat Apr 20 14:39:04 1991
  86. --- /usr/src/sbin/fsck.new/pass1.c    Tue Nov  3 02:24:23 1992
  87. ***************
  88. *** 101,106 ****
  89. --- 101,113 ----
  90.                   continue;
  91.               }
  92.               lastino = inumber;
  93. +             /* is fast symlink? */
  94. +             if (DFASTLINK(*dp)) {
  95. +                 lncntp[inumber] = dp->di_nlink;
  96. +                 statemap[inumber] = FSTATE;
  97. +                 n_files++;
  98. +                 continue;
  99. +             }
  100.               if (/* dp->di_size < 0 || */
  101.                   dp->di_size + sblock.fs_bsize - 1 < dp->di_size) {
  102.                   if (debug)
  103. diff -c /usr/src/sbin/fsck/pass5.c /usr/src/sbin/fsck.new/pass5.c
  104. *** /usr/src/sbin/fsck/pass5.c    Sat Apr 20 14:39:05 1991
  105. --- /usr/src/sbin/fsck.new/pass5.c    Fri Oct 30 02:20:20 1992
  106. ***************
  107. *** 109,118 ****
  108. --- 109,122 ----
  109.           dmax = dbase + fs->fs_fpg;
  110.           if (dmax > fs->fs_size)
  111.               dmax = fs->fs_size;
  112. + #ifdef notdef
  113.           if (now > cg->cg_time)
  114.               newcg->cg_time = cg->cg_time;
  115.           else
  116.               newcg->cg_time = now;
  117. + #else
  118. +         newcg->cg_time = cg->cg_time;
  119. + #endif
  120.           newcg->cg_cgx = c;
  121.           if (c == fs->fs_ncg - 1)
  122.               newcg->cg_ncyl = fs->fs_ncyl % fs->fs_cpg;
  123. @@@ Fin de ./fsck.diffs
  124. echo ./ufs.diffs
  125. cat >./ufs.diffs <<'@@@ Fin de ./ufs.diffs'
  126. diff -c /usr/src/sys.386bsd/ufs/dinode.h /usr/src/sys.386bsd/ufs.new/dinode.h
  127. *** /usr/src/sys.386bsd/ufs/dinode.h    Tue Dec 24 14:24:20 1991
  128. --- /usr/src/sys.386bsd/ufs.new/dinode.h    Thu Oct 29 21:17:53 1992
  129. ***************
  130. *** 41,46 ****
  131. --- 41,48 ----
  132.   #define    NDADDR    12        /* direct addresses in inode */
  133.   #define    NIADDR    3        /* indirect addresses in inode */
  134.   
  135. + #define    MAXFASTLINK    (((NDADDR+NIADDR) * sizeof(daddr_t)) - 1)
  136. + 
  137.   struct dinode {
  138.       u_short    di_mode;    /*  0: mode and type of file */
  139.       short    di_nlink;    /*  2: number of links to file */
  140. ***************
  141. *** 53,60 ****
  142.       long    di_mtspare;
  143.       time_t    di_ctime;    /* 32: last time inode changed */
  144.       long    di_ctspare;
  145. !     daddr_t    di_db[NDADDR];    /* 40: disk block addresses */
  146. !     daddr_t    di_ib[NIADDR];    /* 88: indirect blocks */
  147.       long    di_flags;    /* 100: status, currently unused */
  148.       long    di_blocks;    /* 104: blocks actually held */
  149.       long    di_gen;        /* 108: generation number */
  150. --- 55,67 ----
  151.       long    di_mtspare;
  152.       time_t    di_ctime;    /* 32: last time inode changed */
  153.       long    di_ctspare;
  154. !     union {
  155. !         struct {
  156. !             daddr_t    di_udb[NDADDR];    /* 40: disk block addresses */
  157. !             daddr_t    di_uib[NIADDR];    /* 88: indirect blocks */
  158. !         } di_addr;
  159. !         char di_usymlink[MAXFASTLINK];
  160. !     } di_un;
  161.       long    di_flags;    /* 100: status, currently unused */
  162.       long    di_blocks;    /* 104: blocks actually held */
  163.       long    di_gen;        /* 108: generation number */
  164. ***************
  165. *** 61,66 ****
  166. --- 68,77 ----
  167.       long    di_spare[4];    /* 112: reserved, currently unused */
  168.   };
  169.   
  170. + #define    di_db        di_un.di_addr.di_udb
  171. + #define    di_ib        di_un.di_addr.di_uib
  172. + #define    di_symlink    di_un.di_usymlink
  173. + 
  174.   #if BYTE_ORDER == LITTLE_ENDIAN || defined(tahoe) /* ugh! -- must be fixed */
  175.   #define    di_size        di_qsize.val[0]
  176.   #else /* BYTE_ORDER == BIG_ENDIAN */
  177. ***************
  178. *** 84,86 ****
  179. --- 95,103 ----
  180.   #define    IREAD        0400        /* read permission */
  181.   #define    IWRITE        0200        /* write permission */
  182.   #define    IEXEC        0100        /* execute permission */
  183. + 
  184. + #define    DFASTLINK(di) \
  185. +     ((((di).di_mode & IFMT) == IFLNK) && \
  186. +         ((di).di_size <= MAXFASTLINK) && \
  187. +         ((di).di_size == (di).di_spare[0]))
  188. + 
  189. diff -c /usr/src/sys.386bsd/ufs/inode.h /usr/src/sys.386bsd/ufs.new/inode.h
  190. *** /usr/src/sys.386bsd/ufs/inode.h    Tue Dec 24 14:24:20 1991
  191. --- /usr/src/sys.386bsd/ufs.new/inode.h    Thu Oct 29 21:17:15 1992
  192. ***************
  193. *** 67,72 ****
  194. --- 67,74 ----
  195.       struct    dinode i_din;    /* the on-disk dinode */
  196.   };
  197.   
  198. + #define    FASTLINK(ip)    (DFASTLINK((ip)->i_din))
  199. + #define    i_symlink    i_din.di_symlink
  200.   #define    i_mode        i_din.di_mode
  201.   #define    i_nlink        i_din.di_nlink
  202.   #define    i_uid        i_din.di_uid
  203. diff -c /usr/src/sys.386bsd/ufs/ufs_inode.c /usr/src/sys.386bsd/ufs.new/ufs_inode.c
  204. *** /usr/src/sys.386bsd/ufs/ufs_inode.c    Tue Dec 24 14:24:20 1991
  205. --- /usr/src/sys.386bsd/ufs.new/ufs_inode.c    Thu Oct 29 21:16:02 1992
  206. ***************
  207. *** 406,411 ****
  208. --- 406,418 ----
  209.       struct inode tip;
  210.   
  211.       vnode_pager_setsize(ITOV(oip), length);
  212. +     if (FASTLINK(oip)) {
  213. +         if (length != 0)
  214. +             panic("itrunc fastlink to non-zero");
  215. +         bzero(oip->i_symlink, MAXFASTLINK);
  216. +         oip->i_size = 0;
  217. +         oip->i_din.di_spare[0] = 0;
  218. +     }
  219.       if (oip->i_size <= length) {
  220.           oip->i_flag |= ICHG|IUPD;
  221.           error = iupdat(oip, &time, &time, 1);
  222. diff -c /usr/src/sys.386bsd/ufs/ufs_vnops.c /usr/src/sys.386bsd/ufs.new/ufs_vnops.c
  223. *** /usr/src/sys.386bsd/ufs/ufs_vnops.c    Tue Dec 24 14:24:21 1991
  224. --- /usr/src/sys.386bsd/ufs.new/ufs_vnops.c    Thu Oct 29 21:28:34 1992
  225. ***************
  226. *** 31,36 ****
  227. --- 31,44 ----
  228.    * SUCH DAMAGE.
  229.    *
  230.    *    @(#)ufs_vnops.c    7.64 (Berkeley) 5/16/91
  231. +  *
  232. +  * PATCHES MAGIC                LEVEL   PATCH THAT GOT US HERE
  233. +  * --------------------         -----   ----------------------
  234. +  * CURRENT PATCH LEVEL:         1       00007
  235. +  * --------------------         -----   ----------------------
  236. +  *
  237. +  * 20 Aug 92    David Greenman        Fixed incorrect setting of B_AGE after
  238. +  *                    each read to improve cache performance
  239.    */
  240.   
  241.   #include "param.h"
  242. ***************
  243. *** 497,504 ****
  244. --- 505,514 ----
  245.               return (error);
  246.           }
  247.           error = uiomove(bp->b_un.b_addr + on, (int)n, uio);
  248. + #if OMIT    /* 20 Aug 92*/
  249.           if (n + on == fs->fs_bsize || uio->uio_offset == ip->i_size)
  250.               bp->b_flags |= B_AGE;
  251. + #endif    /* OMIT*/
  252.           brelse(bp);
  253.       } while (error == 0 && uio->uio_resid > 0 && n != 0);
  254.       return (error);
  255. ***************
  256. *** 1267,1278 ****
  257.       struct proc *p;
  258.   {
  259.       struct inode *ip;
  260.       int error;
  261.   
  262.       error = maknode(IFLNK | vap->va_mode, ndp, &ip);
  263.       if (error)
  264.           return (error);
  265. !     error = vn_rdwr(UIO_WRITE, ITOV(ip), target, strlen(target), (off_t)0,
  266.           UIO_SYSSPACE, IO_NODELOCKED, ndp->ni_cred, (int *)0,
  267.           (struct proc *)0);
  268.       iput(ip);
  269. --- 1277,1298 ----
  270.       struct proc *p;
  271.   {
  272.       struct inode *ip;
  273. +     int len = strlen(target);
  274.       int error;
  275.   
  276.       error = maknode(IFLNK | vap->va_mode, ndp, &ip);
  277.       if (error)
  278.           return (error);
  279. ! #ifdef FASTLINKS
  280. !     if (len <= MAXFASTLINK) {
  281. !         ip->i_din.di_spare[0] = len;
  282. !         ip->i_size = len;
  283. !         bcopy(target, ip->i_symlink, len);
  284. !         ip->i_flag |= ICHG;
  285. !         error = iupdat(ip, &time, &time, 1);
  286. !     } else
  287. ! #endif
  288. !     error = vn_rdwr(UIO_WRITE, ITOV(ip), target, len, (off_t)0,
  289.           UIO_SYSSPACE, IO_NODELOCKED, ndp->ni_cred, (int *)0,
  290.           (struct proc *)0);
  291.       iput(ip);
  292. ***************
  293. *** 1314,1321 ****
  294.       struct uio *uiop;
  295.       struct ucred *cred;
  296.   {
  297. ! 
  298. !     return (ufs_read(vp, uiop, 0, cred));
  299.   }
  300.   
  301.   /*
  302. --- 1334,1344 ----
  303.       struct uio *uiop;
  304.       struct ucred *cred;
  305.   {
  306. !     struct inode *ip = VTOI(vp);
  307. !     if (FASTLINK(ip))
  308. !         return (uiomove(ip->i_symlink, ip->i_size, uiop));
  309. !     else
  310. !         return (ufs_read(vp, uiop, 0, cred));
  311.   }
  312.   
  313.   /*
  314. @@@ Fin de ./ufs.diffs
  315. mkdir ./usr
  316. mkdir ./usr/src
  317. mkdir ./usr/src/sbin
  318. mkdir ./usr/src/sbin/dumpfs
  319. echo ./usr/src/sbin/dumpfs/dumpfs.c
  320. cat >./usr/src/sbin/dumpfs/dumpfs.c <<'@@@ Fin de ./usr/src/sbin/dumpfs/dumpfs.c'
  321. #define    EXTREME
  322. /*
  323.  * Copyright (c) 1983 The Regents of the University of California.
  324.  * All rights reserved.
  325.  *
  326.  * Redistribution and use in source and binary forms, with or without
  327.  * modification, are permitted provided that the following conditions
  328.  * are met:
  329.  * 1. Redistributions of source code must retain the above copyright
  330.  *    notice, this list of conditions and the following disclaimer.
  331.  * 2. Redistributions in binary form must reproduce the above copyright
  332.  *    notice, this list of conditions and the following disclaimer in the
  333.  *    documentation and/or other materials provided with the distribution.
  334.  * 3. All advertising materials mentioning features or use of this software
  335.  *    must display the following acknowledgement:
  336.  *    This product includes software developed by the University of
  337.  *    California, Berkeley and its contributors.
  338.  * 4. Neither the name of the University nor the names of its contributors
  339.  *    may be used to endorse or promote products derived from this software
  340.  *    without specific prior written permission.
  341.  *
  342.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  343.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  344.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  345.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  346.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  347.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  348.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  349.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  350.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  351.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  352.  * SUCH DAMAGE.
  353.  */
  354. /*
  355.  * added much verbose hackery in conjunction with fast symlinks.
  356.  * curt mayer, 11 Dec 1992
  357.  */
  358.  
  359. #ifndef lint
  360. char copyright[] =
  361. "@(#) Copyright (c) 1983 The Regents of the University of California.\n\
  362.  All rights reserved.\n";
  363. #endif /* not lint */
  364.  
  365. #ifndef lint
  366. static char sccsid[] = "@(#)dumpfs.c    5.10 (Berkeley) 6/1/90";
  367. #endif /* not lint */
  368.  
  369. #include <sys/param.h>
  370. #include <ufs/dinode.h>
  371. #include <ufs/dir.h>
  372. #include <ufs/fs.h>
  373.  
  374. #include <stdio.h>
  375. #include <fstab.h>
  376.  
  377. /*
  378.  * dumpfs
  379.  */
  380.  
  381. union {
  382.     struct fs fs;
  383.     char pad[MAXBSIZE];
  384. } fsun;
  385. #define    afs    fsun.fs
  386.  
  387. union {
  388.     struct cg cg;
  389.     char pad[MAXBSIZE];
  390. } cgun;
  391. #define    acg    cgun.cg
  392.  
  393. struct dinode *din;
  394.  
  395. extern char *malloc();
  396.  
  397. long    dev_bsize = 1;
  398.  
  399. main(argc, argv)
  400.     char **argv;
  401. {
  402.     register struct fstab *fs;
  403.  
  404.     argc--, argv++;
  405.     if (argc < 1) {
  406.         fprintf(stderr, "usage: dumpfs fs ...\n");
  407.         exit(1);
  408.     }
  409.     for (; argc > 0; argv++, argc--) {
  410.         fs = getfsfile(*argv);
  411.         if (fs == 0)
  412.             dumpfs(*argv);
  413.         else
  414.             dumpfs(fs->fs_spec);
  415.     }
  416. }
  417.  
  418. dumpfs(name)
  419.     char *name;
  420. {
  421.     int c, i, j, k, size;
  422.  
  423.     close(0);
  424.     if (open(name, 0) != 0) {
  425.         perror(name);
  426.         return;
  427.     }
  428.     lseek(0, SBOFF, 0);
  429.     if (read(0, &afs, SBSIZE) != SBSIZE) {
  430.         perror(name);
  431.         return;
  432.     }
  433.     if (afs.fs_postblformat == FS_42POSTBLFMT)
  434.         afs.fs_nrpos = 8;
  435.     dev_bsize = afs.fs_fsize / fsbtodb(&afs, 1);
  436.     if (afs.fs_inopb > 0 && afs.fs_inopb <= 1024) {
  437.         din = (struct dinode *)
  438.             malloc(afs.fs_inopb * sizeof(struct dinode));
  439.     }
  440.     printf("magic\t%x\tformat\t%s\ttime\t%s", afs.fs_magic,
  441.         afs.fs_postblformat == FS_42POSTBLFMT ? "static" : "dynamic",
  442.         ctime(&afs.fs_time));
  443.     printf("nbfree\t%d\tndir\t%d\tnifree\t%d\tnffree\t%d\n",
  444.         afs.fs_cstotal.cs_nbfree, afs.fs_cstotal.cs_ndir,
  445.         afs.fs_cstotal.cs_nifree, afs.fs_cstotal.cs_nffree);
  446.     printf("ncg\t%d\tncyl\t%d\tsize\t%d\tblocks\t%d\n",
  447.         afs.fs_ncg, afs.fs_ncyl, afs.fs_size, afs.fs_dsize);
  448.     printf("bsize\t%d\tshift\t%d\tmask\t0x%08x\n",
  449.         afs.fs_bsize, afs.fs_bshift, afs.fs_bmask);
  450.     printf("fsize\t%d\tshift\t%d\tmask\t0x%08x\n",
  451.         afs.fs_fsize, afs.fs_fshift, afs.fs_fmask);
  452.     printf("frag\t%d\tshift\t%d\tfsbtodb\t%d\n",
  453.         afs.fs_frag, afs.fs_fragshift, afs.fs_fsbtodb);
  454.     printf("cpg\t%d\tbpg\t%d\tfpg\t%d\tipg\t%d\n",
  455.         afs.fs_cpg, afs.fs_fpg / afs.fs_frag, afs.fs_fpg, afs.fs_ipg);
  456.     printf("minfree\t%d%%\toptim\t%s\tmaxcontig %d\tmaxbpg\t%d\n",
  457.         afs.fs_minfree, afs.fs_optim == FS_OPTSPACE ? "space" : "time",
  458.         afs.fs_maxcontig, afs.fs_maxbpg);
  459.     printf("rotdelay %dms\theadswitch %dus\ttrackseek %dus\trps\t%d\n",
  460.         afs.fs_rotdelay, afs.fs_headswitch, afs.fs_trkseek, afs.fs_rps);
  461.     printf("ntrak\t%d\tnsect\t%d\tnpsect\t%d\tspc\t%d\n",
  462.         afs.fs_ntrak, afs.fs_nsect, afs.fs_npsect, afs.fs_spc);
  463.     printf("trackskew %d\tinterleave %d\n",
  464.         afs.fs_trackskew, afs.fs_interleave);
  465.     printf("nindir\t%d\tinopb\t%d\tnspf\t%d\n",
  466.         afs.fs_nindir, afs.fs_inopb, afs.fs_nspf);
  467.     printf("sblkno\t%d\tcblkno\t%d\tiblkno\t%d\tdblkno\t%d\n",
  468.         afs.fs_sblkno, afs.fs_cblkno, afs.fs_iblkno, afs.fs_dblkno);
  469.     printf("sbsize\t%d\tcgsize\t%d\tcgoffset %d\tcgmask\t0x%08x\n",
  470.         afs.fs_sbsize, afs.fs_cgsize, afs.fs_cgoffset, afs.fs_cgmask);
  471.     printf("csaddr\t%d\tcssize\t%d\tshift\t%d\tmask\t0x%08x\n",
  472.         afs.fs_csaddr, afs.fs_cssize, afs.fs_csshift, afs.fs_csmask);
  473.     printf("cgrotor\t%d\tfmod\t%d\tronly\t%d\n",
  474.         afs.fs_cgrotor, afs.fs_fmod, afs.fs_ronly);
  475.     if (afs.fs_cpc != 0)
  476.         printf("blocks available in each of %d rotational positions",
  477.              afs.fs_nrpos);
  478.     else
  479.         printf("insufficient space to maintain rotational tables\n");
  480.     for (c = 0; c < afs.fs_cpc; c++) {
  481.         printf("\ncylinder number %d:", c);
  482.         for (i = 0; i < afs.fs_nrpos; i++) {
  483.             if (fs_postbl(&afs, c)[i] == -1)
  484.                 continue;
  485.             printf("\n   position %d:\t", i);
  486.             for (j = fs_postbl(&afs, c)[i], k = 1; ;
  487.                  j += fs_rotbl(&afs)[j], k++) {
  488.                 printf("%5d", j);
  489.                 if (k % 12 == 0)
  490.                     printf("\n\t\t");
  491.                 if (fs_rotbl(&afs)[j] == 0)
  492.                     break;
  493.             }
  494.         }
  495.     }
  496.     printf("\ncs[].cs_(nbfree,ndir,nifree,nffree):\n\t");
  497.     for (i = 0, j = 0; i < afs.fs_cssize; i += afs.fs_bsize, j++) {
  498.         size = afs.fs_cssize - i < afs.fs_bsize ?
  499.             afs.fs_cssize - i : afs.fs_bsize;
  500.         afs.fs_csp[j] = (struct csum *)calloc(1, size);
  501.         lseek(0, fsbtodb(&afs, (afs.fs_csaddr + j * afs.fs_frag)) *
  502.             dev_bsize, 0);
  503.         if (read(0, afs.fs_csp[j], size) != size) {
  504.             perror(name);
  505.             return;
  506.         }
  507.     }
  508.     for (i = 0; i < afs.fs_ncg; i++) {
  509.         struct csum *cs = &afs.fs_cs(&afs, i);
  510.         if (i && i % 4 == 0)
  511.             printf("\n\t");
  512.         printf("(%d,%d,%d,%d) ",
  513.             cs->cs_nbfree, cs->cs_ndir, cs->cs_nifree, cs->cs_nffree);
  514.     }
  515.     printf("\n");
  516.     if (afs.fs_ncyl % afs.fs_cpg) {
  517.         printf("cylinders in last group %d\n",
  518.             i = afs.fs_ncyl % afs.fs_cpg);
  519.         printf("blocks in last group %d\n",
  520.             i * afs.fs_spc / NSPB(&afs));
  521.     }
  522.     printf("\n");
  523.     for (i = 0; i < afs.fs_ncg; i++)
  524.         dumpcg(name, i);
  525.     close(0);
  526. };
  527.  
  528. static char xxbuf[11];
  529.  
  530. char *
  531. modestr(k)
  532. unsigned short k;
  533. {
  534.     int type, i, mode;
  535.  
  536.     type = ((k & IFMT) >> 12) & 0xf;
  537.     xxbuf[0] = ".=c.d.b.-.l.s..."[type];
  538.     for (i = 0; i < 3; i++) {
  539.         mode = (k << (i * 3)) & (IREAD | IWRITE | IEXEC);
  540.         xxbuf[1 + (i * 3) + 0] = (mode & IREAD) ? 'r' : '-';
  541.         xxbuf[1 + (i * 3) + 1] = (mode & IWRITE) ? 'w' : '-';
  542.         xxbuf[1 + (i * 3) + 2] = (mode & IEXEC) ? 'x' : '-';
  543.     }
  544.     if (k & ISUID) xxbuf[1 + (0 * 3) + 2] = 's';
  545.     if (k & ISGID) xxbuf[1 + (1 * 3) + 2] = 's';
  546.     if (k & ISVTX) xxbuf[1 + (2 * 3) + 2] = 's';
  547.     xxbuf[10] = '\0';
  548.     return (xxbuf);    
  549. }
  550.  
  551. dumpcg(name, c)
  552.     char *name;
  553.     int c;
  554. {
  555.     int i, j;
  556.  
  557.     printf("\ncg %d:\n", c);
  558.     lseek(0, fsbtodb(&afs, cgtod(&afs, c)) * dev_bsize, 0);
  559.     i = lseek(0, 0, 1);
  560.     if (read(0, (char *)&acg, afs.fs_bsize) != afs.fs_bsize) {
  561.         printf("dumpfs: %s: error reading cg\n", name);
  562.         return;
  563.     }
  564.     printf("magic\t%x\ttell\t%x\ttime\t%s",
  565.         afs.fs_postblformat == FS_42POSTBLFMT ?
  566.         ((struct ocg *)&acg)->cg_magic : acg.cg_magic,
  567.         i, ctime(&acg.cg_time));
  568.     printf("cgx\t%d\tncyl\t%d\tniblk\t%d\tndblk\t%d\n",
  569.         acg.cg_cgx, acg.cg_ncyl, acg.cg_niblk, acg.cg_ndblk);
  570.     printf("nbfree\t%d\tndir\t%d\tnifree\t%d\tnffree\t%d\n",
  571.         acg.cg_cs.cs_nbfree, acg.cg_cs.cs_ndir,
  572.         acg.cg_cs.cs_nifree, acg.cg_cs.cs_nffree);
  573.     printf("rotor\t%d\tirotor\t%d\tfrotor\t%d\nfrsum",
  574.         acg.cg_rotor, acg.cg_irotor, acg.cg_frotor);
  575.     for (i = 1, j = 0; i < afs.fs_frag; i++) {
  576.         printf("\t%d", acg.cg_frsum[i]);
  577.         j += i * acg.cg_frsum[i];
  578.     }
  579.     printf("\nsum of frsum: %d\niused:\t", j);
  580.     pbits(c * afs.fs_ipg, cg_inosused(&acg), afs.fs_ipg);
  581.     printf("free:\t");
  582.     pbits(c * afs.fs_fpg, cg_blksfree(&acg), afs.fs_fpg);
  583.     printf("b:\n");
  584.     for (i = 0; i < afs.fs_cpg; i++) {
  585.         if (cg_blktot(&acg)[i] == 0)
  586.             continue;
  587.         printf("   c%d:\t(%d)\t", i, cg_blktot(&acg)[i]);
  588.         for (j = 0; j < afs.fs_nrpos; j++) {
  589.             if (afs.fs_cpc > 0 &&
  590.                 fs_postbl(&afs, i % afs.fs_cpc)[j] == -1)
  591.                 continue;
  592.             printf(" %d", cg_blks(&afs, &acg, i)[j]);
  593.         }
  594.         printf("\n");
  595.     }
  596.     if (din)
  597.         dumpinodes(c, name);
  598. };
  599.  
  600. dumpinodes(c, name)
  601. int c;
  602. char *name;
  603. {
  604.     int i, j, k, l, m;
  605.  
  606.     printf("inum\tmode\t\tlinks\tuid\tgid\tblocks\tsize\n");
  607.     for (i = 0; i < acg.cg_niblk; i += INOPB(&afs)) {
  608.         j = (afs.fs_ipg * c) + i;
  609.         lseek(0, (fsbtodb(&afs, itod(&afs, j)) * dev_bsize), 0);
  610.         if (read(0, (char *)din, INOPB(&afs) * sizeof(struct dinode)) != 
  611.             INOPB(&afs) * sizeof(struct dinode)) {
  612.             printf("dumpfs: %s: error reading inode\n", name);
  613.             return;
  614.         }
  615.         for (k = 0; k < INOPB(&afs); k++) {
  616. #ifdef EXTREME
  617.             int l, m;
  618.             char *p;
  619.             char c;
  620. #endif
  621.             if (!din[k].di_mode)
  622.                 continue;
  623. #ifdef EXTREME
  624.             p = (char *)&din[k];
  625.             for (l = 0; l < sizeof(din[k]); l += 16) {
  626.                 for (m = 0; m < 16; m++) {
  627.                     printf("%02x ", p[l+m] & 0xff);
  628.                 }
  629.                 printf("  ");
  630.                 for (m = 0; m < 16; m++) {
  631.                     c = p[l+m];
  632.                     if (c < 0x20 || c > 0x7e) c = '.';
  633.                     printf("%c", c);
  634.                 }
  635.                 printf("\n");
  636.             }
  637.             printf("\n");
  638. #endif
  639.             printf("%d\t%s\t%d\t%d\t%d\t%d\t%d\n\t",
  640.                 j + k, modestr(din[k].di_mode),
  641.                 din[k].di_nlink, 
  642.                 din[k].di_uid,  din[k].di_gid, 
  643.                 din[k].di_blocks, din[k].di_size);
  644.  
  645.             /* dump fast symlink */
  646.             if (((din[k].di_mode & IFMT) == IFLNK) &&
  647.                 (din[k].di_size <= MAXFASTLINK) &&
  648.                 (din[k].di_size == din[k].di_spare[0])) {
  649.                 printf("%s\n\n", din[k].di_symlink);
  650.                 continue;
  651.             }
  652.  
  653.             /* dump cdev/bdev */
  654.             if (((din[k].di_mode & IFMT) == IFCHR) ||
  655.                 ((din[k].di_mode & IFMT) == IFBLK)) {
  656.                 printf("major %d minor %d (0x%x)\n\n", 
  657.                     major(din[k].di_rdev),
  658.                     minor(din[k].di_rdev),
  659.                     minor(din[k].di_rdev));
  660.                 continue;
  661.             }
  662.             
  663.             /* dump normal symlink */
  664.             if (((din[k].di_mode & IFMT) == IFLNK) &&
  665.                 ((din[k].di_size > MAXFASTLINK) ||
  666.                  (din[k].di_size != din[k].di_spare[0]))) {
  667.                 dumpsymlink(din[k].di_db[0], din[k].di_size, 
  668.                     name);
  669.             }
  670.  
  671.             /* dump directory */
  672.             if (((din[k].di_mode & IFMT) == IFDIR)) {
  673.                 printf("ino\tname\n\t");
  674.                 for (l = 0; l < NDADDR; l++) {
  675.                     dumpdirblk(din[k].di_db[l], 
  676.                         dblksize(&afs,&din[k], l), 
  677.                         name);
  678.                 }
  679.                 if (din[k].di_ib[0]) {
  680.                     printf("huge directory\n");
  681.                 }
  682.                 printf("\n\t");
  683.             }
  684.  
  685.             /* dump direct blocks */
  686.             for (m = NDADDR - 1; m >= 0; m--) {
  687.                 if (din[k].di_db[m] != 0)
  688.                     break;
  689.             }
  690.             for (l = 0 ; l <= m; l++) {
  691.                 printf("%d\t", din[k].di_db[l]);
  692.                 if (((l + 1) % 8) == 0) printf("\n\t");
  693.             }
  694.             if ((l % 8) != 0)
  695.                 printf("\n");
  696.             printf("\n");
  697.  
  698.             /* dump indirect blocks */
  699.             for (m = NIADDR - 1; m >= 0; m--) {
  700.                 if (din[k].di_ib[m] != 0)
  701.                     break;
  702.             }
  703.             for (l = 0 ; l <= m; l++) {
  704.                 dumpindir(l, din[k].di_ib[l], name);
  705.             }
  706.         }
  707.     }
  708. }
  709.  
  710. dumpdirblk(b, bs, name)
  711. int b;
  712. int bs;
  713. char *name;
  714. {
  715.     char *s, *p;
  716.     struct direct *d;
  717.  
  718.     if (!b)
  719.         return;
  720.  
  721.     lseek(0, fsbtodb(&afs, b) * dev_bsize, 0);
  722.     s = malloc(bs);
  723.     if (!s) {
  724.         printf("malloc failed\n");
  725.         return;
  726.     }
  727.     if (read(0, s, bs) != bs) {
  728.         printf("dumpfs: %s: error reading directory block\n", name);
  729.     }
  730.     for (p = s; p < &s[bs]; p += d->d_reclen) {
  731.         d = (struct direct *)p;
  732.         if (d->d_reclen > DIRSIZ(d))
  733.             continue;
  734.         printf("%d\t%s\n\t", d->d_ino, d->d_name);
  735.     }
  736. }
  737.  
  738. dumpsymlink(b, len, name)
  739. int b;
  740. int len;
  741. char *name;
  742. {
  743.     int i;
  744.     int m;
  745.     char *s;
  746.  
  747.     lseek(0, fsbtodb(&afs, b) * dev_bsize, 0);
  748.     s = malloc(afs.fs_bsize);
  749.     if (!s) {
  750.         printf("malloc failed\n");
  751.         return;
  752.     }
  753.     if (read(0, s, afs.fs_bsize) != afs.fs_bsize) {
  754.         printf("dumpfs: %s: error reading symlink block\n", name);
  755.     }
  756.     s[len] = '\0';
  757.     printf("%s\n\t", s);
  758.     free(s);
  759. }
  760.  
  761. dumpindir(d, b, name)
  762. int d;
  763. int b;
  764. char *name;
  765. {
  766.     daddr_t *indirs;
  767.     int i;
  768.     int m;
  769.  
  770.     printf("\tI%d %d:\n", d, b);
  771.     if (b == 0)
  772.         return;
  773.  
  774.     indirs = (daddr_t *)malloc(afs.fs_nindir * sizeof(daddr_t));
  775.     lseek(0, fsbtodb(&afs, b) * dev_bsize, 0);
  776.     if (read(0, (char *)indirs, afs.fs_nindir * sizeof(daddr_t)) != 
  777.         afs.fs_nindir * sizeof(daddr_t)) {
  778.         printf("dumpfs: %s: error reading indirect block\n", name);
  779.     }
  780.     if (d == 0) {
  781.         printf("\t");
  782.         
  783.         for (m = afs.fs_nindir - 1; m >= 0; m--) {
  784.             if (indirs[m] != 0)
  785.                 break;
  786.         }
  787.         for (i = 0; i <= m; i++) {
  788.             printf("%d\t", indirs[i]);
  789.             if (((i + 1) % 8) == 0) printf("\n\t");
  790.         }
  791.         if ((i % 8) != 0)
  792.             printf("\n");
  793.         printf("\n");
  794.     } else {
  795.         for (m = afs.fs_nindir - 1; m >= 0; m--) {
  796.             if (indirs[m] != 0)
  797.                 break;
  798.         }
  799.         for (i = 0; i <= m; i++) {
  800.             dumpindir(d - 1, indirs[i], name);
  801.         }
  802.     }
  803.     free((char *)indirs);
  804. }
  805.  
  806. pbits(base, cp, max)
  807.     int base;
  808.     register char *cp;
  809.     int max;
  810. {
  811.     register int i;
  812.     int count = 0, j;
  813.     int width = 0;
  814.  
  815.     for (i = 0; i < max; i++)
  816.         if (isset(cp, i)) {
  817.             if (count) {
  818.                 width += printf(",");
  819.                 if (width > 55) {
  820.                     printf("\n\t");
  821.                     width = 0;
  822.                 }
  823.             }
  824.             count++;
  825.             width += printf("%d", i+base);
  826.             j = i;
  827.             while ((i+1)<max && isset(cp, i+1))
  828.                 i++;
  829.             if (i != j)
  830.                 width += printf("-%d", i+base);
  831.         }
  832.     printf("\n");
  833. }
  834. @@@ Fin de ./usr/src/sbin/dumpfs/dumpfs.c
  835. exit 0
  836. ---------cut anywhere near here----------
  837. -- 
  838.     curt mayer
  839.         curt@toad.com
  840.         415-387-0217 home
  841.