lfs_inode.c revision 1.2 
1/*      $NetBSD: lfs_inode.c,v 1.2 1999/10/01 04:35:23 perseant Exp $ */
2
3/*-
4 * Copyright (c) 1980, 1991, 1993, 1994
5 *      The Regents of the University of California.  All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 *    notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in the
14 *    documentation and/or other materials provided with the distribution.
15 * 3. All advertising materials mentioning features or use of this software
16 *    must display the following acknowledgement:
17 *      This product includes software developed by the University of
18 *      California, Berkeley and its contributors.
19 * 4. Neither the name of the University nor the names of its contributors
20 *    may be used to endorse or promote products derived from this software
21 *    without specific prior written permission.
22 *
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * SUCH DAMAGE.
34 */
35
36#include <sys/cdefs.h>
37#ifndef lint
38__COPYRIGHT("@(#) Copyright (c) 1980, 1991, 1993, 1994\n\
39        The Regents of the University of California.  All rights reserved.\n");
40#endif /* not lint */
41
42#ifndef lint
43#if 0
44static char sccsid[] = "@(#)main.c      8.6 (Berkeley) 5/1/95";
45#else
46__RCSID("$NetBSD: lfs_inode.c,v 1.2 1999/10/01 04:35:23 perseant Exp $");
47#endif
48#endif /* not lint */
49
50#include <sys/param.h>
51#include <sys/time.h>
52#include <sys/stat.h>
53#include <ufs/ufs/dir.h>
54#include <ufs/ufs/dinode.h>
55#include <sys/mount.h>
56#include <ufs/lfs/lfs.h>
57
58#include <protocols/dumprestore.h>
59
60#include <ctype.h>
61#include <errno.h>
62#include <fts.h>
63#include <stdio.h>
64#ifdef __STDC__
65#include <string.h>
66#include <unistd.h>
67#endif
68
69#include "dump.h"
70
71#define MAXIFPB        (MAXBSIZE / sizeof(IFILE))
72
73#define	HASDUMPEDFILE	0x1
74#define	HASSUBDIRS	0x2
75
76struct lfs *sblock;
77
78/*
79 * Read the superblock from disk, and check its magic number.
80 * Determine whether byte-swapping needs to be done on this filesystem.
81 */
82int
83fs_read_sblock(char *sblock_buf)
84{
85	int needswap = 0;
86
87	sblock = (struct lfs *)sblock_buf;
88	rawread(LFS_LABELPAD, (char *) sblock, LFS_SBPAD);
89	if (sblock->lfs_magic != LFS_MAGIC) {
90#ifdef notyet
91		if (sblock->lfs_magic == bswap32(LFS_MAGIC)) {
92			lfs_sb_swap(sblock, sblock, 0);
93			needswap = 1;
94		} else
95#endif
96			quit("bad sblock magic number\n");
97	}
98	return needswap;
99}
100
101/*
102 * Fill in the ufsi struct, as well as the maxino and dev_bsize global
103 * variables.
104 */
105struct ufsi *
106fs_parametrize(void)
107{
108	static struct ufsi ufsi;
109
110	spcl.c_flags = iswap32(iswap32(spcl.c_flags) | DR_NEWINODEFMT);
111
112	ufsi.ufs_dsize = fsbtodb(sblock,sblock->lfs_size);
113	ufsi.ufs_bsize = sblock->lfs_bsize;
114	ufsi.ufs_bshift = sblock->lfs_bshift;
115	ufsi.ufs_fsize = sblock->lfs_fsize;
116	ufsi.ufs_frag = sblock->lfs_frag;
117	ufsi.ufs_fsatoda = 0;
118	ufsi.ufs_nindir = sblock->lfs_nindir;
119	ufsi.ufs_inopb = sblock->lfs_inopb;
120	ufsi.ufs_maxsymlinklen = sblock->lfs_maxsymlinklen;
121	ufsi.ufs_bmask = ~(sblock->lfs_bmask);
122	ufsi.ufs_qbmask = sblock->lfs_bmask;
123	ufsi.ufs_fmask = ~(sblock->lfs_ffmask);
124	ufsi.ufs_qfmask = sblock->lfs_ffmask;
125
126	dev_bsize = sblock->lfs_bsize >> sblock->lfs_fsbtodb;
127
128	return &ufsi;
129}
130
131ino_t
132fs_maxino(void)
133{
134	return ((getino(sblock->lfs_ifile)->di_size
135		   - (sblock->lfs_cleansz + sblock->lfs_segtabsz)
136		   * sblock->lfs_bsize)
137		  / sblock->lfs_bsize) * sblock->lfs_ifpb - 1;
138}
139
140/*
141 * XXX KS - I know there's a better way to do this.
142 */
143#define BASE_SINDIR (NDADDR)
144#define BASE_DINDIR (NDADDR+NINDIR(fs))
145#define BASE_TINDIR (NDADDR+NINDIR(fs)+NINDIR(fs)*NINDIR(fs))
146
147#define D_UNITS (NINDIR(fs))
148#define T_UNITS (NINDIR(fs)*NINDIR(fs))
149
150static daddr_t
151lfs_bmap(struct lfs *fs, struct dinode *idinode, ufs_daddr_t lbn)
152{
153	ufs_daddr_t residue, up;
154	int off=0;
155	char bp[MAXBSIZE];
156
157	if(lbn > 0 && lbn > (idinode->di_size-1)/dev_bsize) {
158		return UNASSIGNED;
159	}
160	/*
161	 * Indirect blocks: if it is a first-level indirect, pull its
162	 * address from the inode; otherwise, call ourselves to find the
163	 * address of the parent indirect block, and load that to find
164	 * the desired address.
165	 */
166	if(lbn < 0) {
167		lbn *= -1;
168		if(lbn == NDADDR) {
169			/* printf("lbn %d: single indir base\n", -lbn); */
170			return idinode->di_ib[0]; /* single indirect */
171		} else if(lbn == BASE_DINDIR+1) {
172			/* printf("lbn %d: double indir base\n", -lbn); */
173			return idinode->di_ib[1]; /* double indirect */
174		} else if(lbn == BASE_TINDIR+2) {
175			/* printf("lbn %d: triple indir base\n", -lbn); */
176			return idinode->di_ib[2]; /* triple indirect */
177		}
178
179		/*
180		 * Find the immediate parent. This is essentially finding the
181		 * residue of modulus, and then rounding accordingly.
182		 */
183		residue = (lbn-NDADDR) % NINDIR(fs);
184		if(residue == 1) {
185			/* Double indirect.  Parent is the triple. */
186			up = idinode->di_ib[2];
187			off = (lbn-2-BASE_TINDIR)/(NINDIR(fs)*NINDIR(fs));
188			if(up == UNASSIGNED || up == LFS_UNUSED_DADDR)
189				return UNASSIGNED;
190			/* printf("lbn %d: parent is the triple\n", -lbn); */
191			bread(up, bp, sblock->lfs_bsize);
192			return ((daddr_t *)bp)[off];
193		} else /* residue == 0 */ {
194			/* Single indirect.  Two cases. */
195			if(lbn < BASE_TINDIR) {
196				/* Parent is the double, simple */
197				up = -(BASE_DINDIR) - 1;
198				off = (lbn-BASE_DINDIR) / D_UNITS;
199				/* printf("lbn %d: parent is %d/%d\n", -lbn, up,off); */
200			} else {
201				/* Ancestor is the triple, more complex */
202				up = ((lbn-BASE_TINDIR) / T_UNITS)
203					* T_UNITS + BASE_TINDIR + 1;
204				off = (lbn/D_UNITS) - (up/D_UNITS);
205				up = -up;
206				/* printf("lbn %d: parent is %d/%d\n", -lbn, up,off); */
207			}
208		}
209	} else {
210		/* Direct block.  Its parent must be a single indirect. */
211		if(lbn < NDADDR)
212			return idinode->di_db[lbn];
213		else {
214			/* Parent is an indirect block. */
215			up = -(((lbn-NDADDR) / D_UNITS) * D_UNITS + NDADDR);
216			off = (lbn-NDADDR) % D_UNITS;
217			/* printf("lbn %d: parent is %d/%d\n", lbn,up,off); */
218		}
219	}
220	up = lfs_bmap(fs,idinode,up);
221	if(up == UNASSIGNED || up == LFS_UNUSED_DADDR)
222		return UNASSIGNED;
223	bread(up, bp, sblock->lfs_bsize);
224	return ((daddr_t *)bp)[off];
225}
226
227static struct ifile *
228lfs_ientry(ino_t ino)
229{
230    static struct ifile ifileblock[MAXIFPB];
231    static daddr_t ifblkno;
232    ufs_daddr_t lbn;
233    daddr_t blkno;
234
235    lbn = ino/sblock->lfs_ifpb + sblock->lfs_cleansz + sblock->lfs_segtabsz;
236    blkno = lfs_bmap(sblock,getino(sblock->lfs_ifile),lbn);
237    if(blkno != ifblkno)
238	    bread(blkno, (char *)ifileblock, sblock->lfs_bsize);
239    return ifileblock + (ino%sblock->lfs_ifpb);
240}
241
242/* Search a block for a specific dinode. */
243static struct dinode *
244lfs_ifind(struct lfs *fs, ino_t ino, struct dinode *dip)
245{
246	register int cnt;
247
248	for(cnt=0;cnt<INOPB(fs);cnt++)
249		if(dip[cnt].di_inumber == ino)
250			return &(dip[cnt]);
251	return NULL;
252}
253
254struct dinode *
255getino(inum)
256	ino_t inum;
257{
258	static daddr_t inoblkno;
259	daddr_t blkno;
260	static struct dinode inoblock[MAXINOPB];
261	static struct dinode ifile_dinode; /* XXX fill this in */
262	static struct dinode empty_dinode; /* Always stays zeroed */
263	struct dinode *dp;
264
265	if(inum == sblock->lfs_ifile) {
266		/* Load the ifile inode if not already */
267		if(ifile_dinode.di_u.inumber == 0) {
268			blkno = sblock->lfs_idaddr;
269			bread(blkno, (char *)inoblock, (int)sblock->lfs_bsize);
270			dp = lfs_ifind(sblock, inum, inoblock);
271			ifile_dinode = *dp; /* Structure copy */
272		}
273		return &ifile_dinode;
274	}
275
276	curino = inum;
277	blkno = lfs_ientry(inum)->if_daddr;
278	if(blkno == LFS_UNUSED_DADDR)
279		return &empty_dinode;
280
281	if(blkno != inoblkno) {
282		bread(blkno, (char *)inoblock, (int)sblock->lfs_bsize);
283#ifdef notyet
284		if (needswap)
285			for (i = 0; i < MAXINOPB; i++)
286				ffs_dinode_swap(&inoblock[i], &inoblock[i]);
287#endif
288	}
289	return lfs_ifind(sblock, inum, inoblock);
290}
291