78bcd8f9eba767d51088babad4b9111cb9da9a9f
[openafs.git] / src / vfsck / ufs_subr.c
1 /*
2  * Copyright (c) 1982, 1986, 1989 Regents of the University of California.
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms are permitted
6  * provided that the above copyright notice and this paragraph are
7  * duplicated in all such forms and that any documentation,
8  * advertising materials, and other materials related to such
9  * distribution and use acknowledge that the software was developed
10  * by the University of California, Berkeley.  The name of the
11  * University may not be used to endorse or promote products derived
12  * from this software without specific prior written permission.
13  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
14  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
15  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
16  *
17  *      @(#)ufs_subr.c  7.11 (Berkeley) 12/30/89
18  */
19
20 #include <afsconfig.h>
21 #include <afs/param.h>
22
23 #include <roken.h>
24
25 #define VICE
26
27 #ifdef AFS_VFSINCL_ENV
28 #ifdef  AFS_SUN5_ENV
29 #include <sys/fs/ufs_fs.h>
30 #else
31 #include <ufs/fs.h>
32 #endif
33 #else /* AFS_VFSINCL_ENV */
34 #include <sys/fs.h>
35 #endif /* AFS_VFSINCL_ENV */
36
37 extern int around[9];
38 extern int inside[9];
39 extern u_char *fragtbl[];
40
41 /*
42  * Update the frsum fields to reflect addition or deletion
43  * of some frags.
44  */
45 fragacct(fs, fragmap, fraglist, cnt)
46      struct fs *fs;
47      int fragmap;
48      afs_int32 fraglist[];
49      int cnt;
50 {
51     int inblk;
52     int field, subfield;
53     int siz, pos;
54
55     inblk = (int)(fragtbl[fs->fs_frag][fragmap]) << 1;
56     fragmap <<= 1;
57     for (siz = 1; siz < fs->fs_frag; siz++) {
58         if ((inblk & (1 << (siz + (fs->fs_frag % NBBY)))) == 0)
59             continue;
60         field = around[siz];
61         subfield = inside[siz];
62         for (pos = siz; pos <= fs->fs_frag; pos++) {
63             if ((fragmap & field) == subfield) {
64                 fraglist[siz] += cnt;
65                 pos += siz;
66                 field <<= siz;
67                 subfield <<= siz;
68             }
69             field <<= 1;
70             subfield <<= 1;
71         }
72     }
73 }
74
75 /*
76  * block operations
77  *
78  * check if a block is available
79  */
80 isblock(fs, cp, h)
81      struct fs *fs;
82      unsigned char *cp;
83      daddr_t h;
84 {
85     unsigned char mask;
86
87     switch ((int)fs->fs_frag) {
88     case 8:
89         return (cp[h] == 0xff);
90     case 4:
91         mask = 0x0f << ((h & 0x1) << 2);
92         return ((cp[h >> 1] & mask) == mask);
93     case 2:
94         mask = 0x03 << ((h & 0x3) << 1);
95         return ((cp[h >> 2] & mask) == mask);
96     case 1:
97         mask = 0x01 << (h & 0x7);
98         return ((cp[h >> 3] & mask) == mask);
99     default:
100         panic("isblock");
101         return (NULL);
102     }
103 }
104
105 /*
106  * take a block out of the map
107  */
108 clrblock(fs, cp, h)
109      struct fs *fs;
110      u_char *cp;
111      daddr_t h;
112 {
113
114     switch ((int)fs->fs_frag) {
115     case 8:
116         cp[h] = 0;
117         return;
118     case 4:
119         cp[h >> 1] &= ~(0x0f << ((h & 0x1) << 2));
120         return;
121     case 2:
122         cp[h >> 2] &= ~(0x03 << ((h & 0x3) << 1));
123         return;
124     case 1:
125         cp[h >> 3] &= ~(0x01 << (h & 0x7));
126         return;
127     default:
128         panic("clrblock");
129     }
130 }
131
132 /*
133  * put a block into the map
134  */
135 setblock(fs, cp, h)
136      struct fs *fs;
137      unsigned char *cp;
138      daddr_t h;
139 {
140
141     switch ((int)fs->fs_frag) {
142
143     case 8:
144         cp[h] = 0xff;
145         return;
146     case 4:
147         cp[h >> 1] |= (0x0f << ((h & 0x1) << 2));
148         return;
149     case 2:
150         cp[h >> 2] |= (0x03 << ((h & 0x3) << 1));
151         return;
152     case 1:
153         cp[h >> 3] |= (0x01 << (h & 0x7));
154         return;
155     default:
156         panic("setblock");
157     }
158 }
159
160 #if (!defined(vax) && !defined(tahoe)) || defined(VAX630) || defined(VAX650)
161 /*
162  * C definitions of special instructions.
163  * Normally expanded with inline.
164  */
165 scanc(size, cp, table, mask)
166      u_int size;
167      u_char *cp, table[];
168      u_char mask;
169 {
170     u_char *end = &cp[size];
171
172     while (cp < end && (table[*cp] & mask) == 0)
173         cp++;
174     return (end - cp);
175 }
176 #endif
177
178 #if !defined(vax) && !defined(tahoe)
179 skpc(mask, size, cp)
180      u_char mask;
181      u_int size;
182      u_char *cp;
183 {
184     u_char *end = &cp[size];
185
186     while (cp < end && *cp == mask)
187         cp++;
188     return (end - cp);
189 }
190
191 locc(mask, size, cp)
192      u_char mask;
193      u_int size;
194      u_char *cp;
195 {
196     u_char *end = &cp[size];
197
198     while (cp < end && *cp != mask)
199         cp++;
200     return (end - cp);
201 }
202 #endif