inode.c revision 329883 
1/*
2 * Copyright (c) 1980, 1986, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 *    may be used to endorse or promote products derived from this software
15 *    without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30#if 0
31#ifndef lint
32static const char sccsid[] = "@(#)inode.c	8.8 (Berkeley) 4/28/95";
33#endif /* not lint */
34#endif
35#include <sys/cdefs.h>
36__FBSDID("$FreeBSD: stable/10/sbin/fsck_ffs/inode.c 329883 2018-02-23 23:07:41Z mckusick $");
37
38#include <sys/param.h>
39#include <sys/stdint.h>
40#include <sys/sysctl.h>
41
42#include <ufs/ufs/dinode.h>
43#include <ufs/ufs/dir.h>
44#include <ufs/ffs/fs.h>
45
46#include <err.h>
47#include <pwd.h>
48#include <string.h>
49#include <time.h>
50
51#include "fsck.h"
52
53static ino_t startinum;
54
55static int iblock(struct inodesc *, long ilevel, off_t isize, int type);
56
57int
58ckinode(union dinode *dp, struct inodesc *idesc)
59{
60	off_t remsize, sizepb;
61	int i, offset, ret;
62	union dinode dino;
63	ufs2_daddr_t ndb;
64	mode_t mode;
65	char pathbuf[MAXPATHLEN + 1];
66
67	if (idesc->id_fix != IGNORE)
68		idesc->id_fix = DONTKNOW;
69	idesc->id_lbn = -1;
70	idesc->id_entryno = 0;
71	idesc->id_filesize = DIP(dp, di_size);
72	mode = DIP(dp, di_mode) & IFMT;
73	if (mode == IFBLK || mode == IFCHR || (mode == IFLNK &&
74	    DIP(dp, di_size) < (unsigned)sblock.fs_maxsymlinklen))
75		return (KEEPON);
76	if (sblock.fs_magic == FS_UFS1_MAGIC)
77		dino.dp1 = dp->dp1;
78	else
79		dino.dp2 = dp->dp2;
80	ndb = howmany(DIP(&dino, di_size), sblock.fs_bsize);
81	for (i = 0; i < NDADDR; i++) {
82		idesc->id_lbn++;
83		if (--ndb == 0 &&
84		    (offset = blkoff(&sblock, DIP(&dino, di_size))) != 0)
85			idesc->id_numfrags =
86				numfrags(&sblock, fragroundup(&sblock, offset));
87		else
88			idesc->id_numfrags = sblock.fs_frag;
89		if (DIP(&dino, di_db[i]) == 0) {
90			if (idesc->id_type == DATA && ndb >= 0) {
91				/* An empty block in a directory XXX */
92				getpathname(pathbuf, idesc->id_number,
93						idesc->id_number);
94				pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
95					pathbuf);
96				if (reply("ADJUST LENGTH") == 1) {
97					dp = ginode(idesc->id_number);
98					DIP_SET(dp, di_size,
99					    i * sblock.fs_bsize);
100					printf(
101					    "YOU MUST RERUN FSCK AFTERWARDS\n");
102					rerun = 1;
103					inodirty();
104
105				}
106			}
107			continue;
108		}
109		idesc->id_blkno = DIP(&dino, di_db[i]);
110		if (idesc->id_type != DATA)
111			ret = (*idesc->id_func)(idesc);
112		else
113			ret = dirscan(idesc);
114		if (ret & STOP)
115			return (ret);
116	}
117	idesc->id_numfrags = sblock.fs_frag;
118	remsize = DIP(&dino, di_size) - sblock.fs_bsize * NDADDR;
119	sizepb = sblock.fs_bsize;
120	for (i = 0; i < NIADDR; i++) {
121		sizepb *= NINDIR(&sblock);
122		if (DIP(&dino, di_ib[i])) {
123			idesc->id_blkno = DIP(&dino, di_ib[i]);
124			ret = iblock(idesc, i + 1, remsize, BT_LEVEL1 + i);
125			if (ret & STOP)
126				return (ret);
127		} else {
128			idesc->id_lbn += sizepb / sblock.fs_bsize;
129			if (idesc->id_type == DATA && remsize > 0) {
130				/* An empty block in a directory XXX */
131				getpathname(pathbuf, idesc->id_number,
132						idesc->id_number);
133				pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
134					pathbuf);
135				if (reply("ADJUST LENGTH") == 1) {
136					dp = ginode(idesc->id_number);
137					DIP_SET(dp, di_size,
138					    DIP(dp, di_size) - remsize);
139					remsize = 0;
140					printf(
141					    "YOU MUST RERUN FSCK AFTERWARDS\n");
142					rerun = 1;
143					inodirty();
144					break;
145				}
146			}
147		}
148		remsize -= sizepb;
149	}
150	return (KEEPON);
151}
152
153static int
154iblock(struct inodesc *idesc, long ilevel, off_t isize, int type)
155{
156	struct bufarea *bp;
157	int i, n, (*func)(struct inodesc *), nif;
158	off_t sizepb;
159	char buf[BUFSIZ];
160	char pathbuf[MAXPATHLEN + 1];
161	union dinode *dp;
162
163	if (idesc->id_type != DATA) {
164		func = idesc->id_func;
165		if (((n = (*func)(idesc)) & KEEPON) == 0)
166			return (n);
167	} else
168		func = dirscan;
169	if (chkrange(idesc->id_blkno, idesc->id_numfrags))
170		return (SKIP);
171	bp = getdatablk(idesc->id_blkno, sblock.fs_bsize, type);
172	ilevel--;
173	for (sizepb = sblock.fs_bsize, i = 0; i < ilevel; i++)
174		sizepb *= NINDIR(&sblock);
175	if (howmany(isize, sizepb) > NINDIR(&sblock))
176		nif = NINDIR(&sblock);
177	else
178		nif = howmany(isize, sizepb);
179	if (idesc->id_func == pass1check && nif < NINDIR(&sblock)) {
180		for (i = nif; i < NINDIR(&sblock); i++) {
181			if (IBLK(bp, i) == 0)
182				continue;
183			(void)sprintf(buf, "PARTIALLY TRUNCATED INODE I=%lu",
184			    (u_long)idesc->id_number);
185			if (preen) {
186				pfatal("%s", buf);
187			} else if (dofix(idesc, buf)) {
188				IBLK_SET(bp, i, 0);
189				dirty(bp);
190			}
191		}
192		flush(fswritefd, bp);
193	}
194	for (i = 0; i < nif; i++) {
195		if (ilevel == 0)
196			idesc->id_lbn++;
197		if (IBLK(bp, i)) {
198			idesc->id_blkno = IBLK(bp, i);
199			if (ilevel == 0)
200				n = (*func)(idesc);
201			else
202				n = iblock(idesc, ilevel, isize, type);
203			if (n & STOP) {
204				bp->b_flags &= ~B_INUSE;
205				return (n);
206			}
207		} else {
208			if (idesc->id_type == DATA && isize > 0) {
209				/* An empty block in a directory XXX */
210				getpathname(pathbuf, idesc->id_number,
211						idesc->id_number);
212				pfatal("DIRECTORY %s: CONTAINS EMPTY BLOCKS",
213					pathbuf);
214				if (reply("ADJUST LENGTH") == 1) {
215					dp = ginode(idesc->id_number);
216					DIP_SET(dp, di_size,
217					    DIP(dp, di_size) - isize);
218					isize = 0;
219					printf(
220					    "YOU MUST RERUN FSCK AFTERWARDS\n");
221					rerun = 1;
222					inodirty();
223					bp->b_flags &= ~B_INUSE;
224					return(STOP);
225				}
226			}
227		}
228		isize -= sizepb;
229	}
230	bp->b_flags &= ~B_INUSE;
231	return (KEEPON);
232}
233
234/*
235 * Check that a block in a legal block number.
236 * Return 0 if in range, 1 if out of range.
237 */
238int
239chkrange(ufs2_daddr_t blk, int cnt)
240{
241	int c;
242
243	if (cnt <= 0 || blk <= 0 || blk > maxfsblock ||
244	    cnt - 1 > maxfsblock - blk)
245		return (1);
246	if (cnt > sblock.fs_frag ||
247	    fragnum(&sblock, blk) + cnt > sblock.fs_frag) {
248		if (debug)
249			printf("bad size: blk %ld, offset %i, size %d\n",
250			    (long)blk, (int)fragnum(&sblock, blk), cnt);
251		return (1);
252	}
253	c = dtog(&sblock, blk);
254	if (blk < cgdmin(&sblock, c)) {
255		if ((blk + cnt) > cgsblock(&sblock, c)) {
256			if (debug) {
257				printf("blk %ld < cgdmin %ld;",
258				    (long)blk, (long)cgdmin(&sblock, c));
259				printf(" blk + cnt %ld > cgsbase %ld\n",
260				    (long)(blk + cnt),
261				    (long)cgsblock(&sblock, c));
262			}
263			return (1);
264		}
265	} else {
266		if ((blk + cnt) > cgbase(&sblock, c+1)) {
267			if (debug)  {
268				printf("blk %ld >= cgdmin %ld;",
269				    (long)blk, (long)cgdmin(&sblock, c));
270				printf(" blk + cnt %ld > sblock.fs_fpg %ld\n",
271				    (long)(blk + cnt), (long)sblock.fs_fpg);
272			}
273			return (1);
274		}
275	}
276	return (0);
277}
278
279/*
280 * General purpose interface for reading inodes.
281 */
282union dinode *
283ginode(ino_t inumber)
284{
285	ufs2_daddr_t iblk;
286
287	if (inumber < ROOTINO || inumber > maxino)
288		errx(EEXIT, "bad inode number %ju to ginode",
289		    (uintmax_t)inumber);
290	if (startinum == 0 ||
291	    inumber < startinum || inumber >= startinum + INOPB(&sblock)) {
292		iblk = ino_to_fsba(&sblock, inumber);
293		if (pbp != 0)
294			pbp->b_flags &= ~B_INUSE;
295		pbp = getdatablk(iblk, sblock.fs_bsize, BT_INODES);
296		startinum = (inumber / INOPB(&sblock)) * INOPB(&sblock);
297	}
298	if (sblock.fs_magic == FS_UFS1_MAGIC)
299		return ((union dinode *)
300		    &pbp->b_un.b_dinode1[inumber % INOPB(&sblock)]);
301	return ((union dinode *)&pbp->b_un.b_dinode2[inumber % INOPB(&sblock)]);
302}
303
304/*
305 * Special purpose version of ginode used to optimize first pass
306 * over all the inodes in numerical order.
307 */
308static ino_t nextino, lastinum, lastvalidinum;
309static long readcount, readpercg, fullcnt, inobufsize, partialcnt, partialsize;
310static struct bufarea inobuf;
311
312union dinode *
313getnextinode(ino_t inumber, int rebuildcg)
314{
315	int j;
316	long size;
317	mode_t mode;
318	ufs2_daddr_t ndb, blk;
319	union dinode *dp;
320	static caddr_t nextinop;
321
322	if (inumber != nextino++ || inumber > lastvalidinum)
323		errx(EEXIT, "bad inode number %ju to nextinode",
324		    (uintmax_t)inumber);
325	if (inumber >= lastinum) {
326		readcount++;
327		blk = ino_to_fsba(&sblock, lastinum);
328		if (readcount % readpercg == 0) {
329			size = partialsize;
330			lastinum += partialcnt;
331		} else {
332			size = inobufsize;
333			lastinum += fullcnt;
334		}
335		/*
336		 * If getblk encounters an error, it will already have zeroed
337		 * out the buffer, so we do not need to do so here.
338		 */
339		getblk(&inobuf, blk, size);
340		nextinop = inobuf.b_un.b_buf;
341	}
342	dp = (union dinode *)nextinop;
343	if (rebuildcg && nextinop == inobuf.b_un.b_buf) {
344		/*
345		 * Try to determine if we have reached the end of the
346		 * allocated inodes.
347		 */
348		mode = DIP(dp, di_mode) & IFMT;
349		if (mode == 0) {
350			if (memcmp(dp->dp2.di_db, ufs2_zino.di_db,
351				NDADDR * sizeof(ufs2_daddr_t)) ||
352			      memcmp(dp->dp2.di_ib, ufs2_zino.di_ib,
353				NIADDR * sizeof(ufs2_daddr_t)) ||
354			      dp->dp2.di_mode || dp->dp2.di_size)
355				return (NULL);
356			goto inodegood;
357		}
358		if (!ftypeok(dp))
359			return (NULL);
360		ndb = howmany(DIP(dp, di_size), sblock.fs_bsize);
361		if (ndb < 0)
362			return (NULL);
363		if (mode == IFBLK || mode == IFCHR)
364			ndb++;
365		if (mode == IFLNK) {
366			/*
367			 * Fake ndb value so direct/indirect block checks below
368			 * will detect any garbage after symlink string.
369			 */
370			if (DIP(dp, di_size) < (off_t)sblock.fs_maxsymlinklen) {
371				ndb = howmany(DIP(dp, di_size),
372				    sizeof(ufs2_daddr_t));
373				if (ndb > NDADDR) {
374					j = ndb - NDADDR;
375					for (ndb = 1; j > 1; j--)
376						ndb *= NINDIR(&sblock);
377					ndb += NDADDR;
378				}
379			}
380		}
381		for (j = ndb; ndb < NDADDR && j < NDADDR; j++)
382			if (DIP(dp, di_db[j]) != 0)
383				return (NULL);
384		for (j = 0, ndb -= NDADDR; ndb > 0; j++)
385			ndb /= NINDIR(&sblock);
386		for (; j < NIADDR; j++)
387			if (DIP(dp, di_ib[j]) != 0)
388				return (NULL);
389	}
390inodegood:
391	if (sblock.fs_magic == FS_UFS1_MAGIC)
392		nextinop += sizeof(struct ufs1_dinode);
393	else
394		nextinop += sizeof(struct ufs2_dinode);
395	return (dp);
396}
397
398void
399setinodebuf(ino_t inum)
400{
401
402	if (inum % sblock.fs_ipg != 0)
403		errx(EEXIT, "bad inode number %ju to setinodebuf",
404		    (uintmax_t)inum);
405	lastvalidinum = inum + sblock.fs_ipg - 1;
406	startinum = 0;
407	nextino = inum;
408	lastinum = inum;
409	readcount = 0;
410	if (inobuf.b_un.b_buf != NULL)
411		return;
412	inobufsize = blkroundup(&sblock, INOBUFSIZE);
413	fullcnt = inobufsize / ((sblock.fs_magic == FS_UFS1_MAGIC) ?
414	    sizeof(struct ufs1_dinode) : sizeof(struct ufs2_dinode));
415	readpercg = sblock.fs_ipg / fullcnt;
416	partialcnt = sblock.fs_ipg % fullcnt;
417	partialsize = partialcnt * ((sblock.fs_magic == FS_UFS1_MAGIC) ?
418	    sizeof(struct ufs1_dinode) : sizeof(struct ufs2_dinode));
419	if (partialcnt != 0) {
420		readpercg++;
421	} else {
422		partialcnt = fullcnt;
423		partialsize = inobufsize;
424	}
425	initbarea(&inobuf, BT_INODES);
426	if ((inobuf.b_un.b_buf = Malloc((unsigned)inobufsize)) == NULL)
427		errx(EEXIT, "cannot allocate space for inode buffer");
428}
429
430void
431freeinodebuf(void)
432{
433
434	if (inobuf.b_un.b_buf != NULL)
435		free((char *)inobuf.b_un.b_buf);
436	inobuf.b_un.b_buf = NULL;
437}
438
439/*
440 * Routines to maintain information about directory inodes.
441 * This is built during the first pass and used during the
442 * second and third passes.
443 *
444 * Enter inodes into the cache.
445 */
446void
447cacheino(union dinode *dp, ino_t inumber)
448{
449	struct inoinfo *inp, **inpp;
450	int i, blks;
451
452	if (howmany(DIP(dp, di_size), sblock.fs_bsize) > NDADDR)
453		blks = NDADDR + NIADDR;
454	else if (DIP(dp, di_size) > 0)
455		blks = howmany(DIP(dp, di_size), sblock.fs_bsize);
456	else
457		blks = 1;
458	inp = (struct inoinfo *)
459		Malloc(sizeof(*inp) + (blks - 1) * sizeof(ufs2_daddr_t));
460	if (inp == NULL)
461		errx(EEXIT, "cannot increase directory list");
462	inpp = &inphead[inumber % dirhash];
463	inp->i_nexthash = *inpp;
464	*inpp = inp;
465	inp->i_parent = inumber == ROOTINO ? ROOTINO : (ino_t)0;
466	inp->i_dotdot = (ino_t)0;
467	inp->i_number = inumber;
468	inp->i_isize = DIP(dp, di_size);
469	inp->i_numblks = blks;
470	for (i = 0; i < (blks < NDADDR ? blks : NDADDR); i++)
471		inp->i_blks[i] = DIP(dp, di_db[i]);
472	if (blks > NDADDR)
473		for (i = 0; i < NIADDR; i++)
474			inp->i_blks[NDADDR + i] = DIP(dp, di_ib[i]);
475	if (inplast == listmax) {
476		listmax += 100;
477		inpsort = (struct inoinfo **)realloc((char *)inpsort,
478		    (unsigned)listmax * sizeof(struct inoinfo *));
479		if (inpsort == NULL)
480			errx(EEXIT, "cannot increase directory list");
481	}
482	inpsort[inplast++] = inp;
483}
484
485/*
486 * Look up an inode cache structure.
487 */
488struct inoinfo *
489getinoinfo(ino_t inumber)
490{
491	struct inoinfo *inp;
492
493	for (inp = inphead[inumber % dirhash]; inp; inp = inp->i_nexthash) {
494		if (inp->i_number != inumber)
495			continue;
496		return (inp);
497	}
498	errx(EEXIT, "cannot find inode %ju", (uintmax_t)inumber);
499	return ((struct inoinfo *)0);
500}
501
502/*
503 * Clean up all the inode cache structure.
504 */
505void
506inocleanup(void)
507{
508	struct inoinfo **inpp;
509
510	if (inphead == NULL)
511		return;
512	for (inpp = &inpsort[inplast - 1]; inpp >= inpsort; inpp--)
513		free((char *)(*inpp));
514	free((char *)inphead);
515	free((char *)inpsort);
516	inphead = inpsort = NULL;
517}
518
519void
520inodirty(void)
521{
522
523	dirty(pbp);
524}
525
526void
527clri(struct inodesc *idesc, const char *type, int flag)
528{
529	union dinode *dp;
530
531	dp = ginode(idesc->id_number);
532	if (flag == 1) {
533		pwarn("%s %s", type,
534		    (DIP(dp, di_mode) & IFMT) == IFDIR ? "DIR" : "FILE");
535		pinode(idesc->id_number);
536	}
537	if (preen || reply("CLEAR") == 1) {
538		if (preen)
539			printf(" (CLEARED)\n");
540		n_files--;
541		if (bkgrdflag == 0) {
542			(void)ckinode(dp, idesc);
543			inoinfo(idesc->id_number)->ino_state = USTATE;
544			clearinode(dp);
545			inodirty();
546		} else {
547			cmd.value = idesc->id_number;
548			cmd.size = -DIP(dp, di_nlink);
549			if (debug)
550				printf("adjrefcnt ino %ld amt %lld\n",
551				    (long)cmd.value, (long long)cmd.size);
552			if (sysctl(adjrefcnt, MIBSIZE, 0, 0,
553			    &cmd, sizeof cmd) == -1)
554				rwerror("ADJUST INODE", cmd.value);
555		}
556	}
557}
558
559int
560findname(struct inodesc *idesc)
561{
562	struct direct *dirp = idesc->id_dirp;
563
564	if (dirp->d_ino != idesc->id_parent || idesc->id_entryno < 2) {
565		idesc->id_entryno++;
566		return (KEEPON);
567	}
568	memmove(idesc->id_name, dirp->d_name, (size_t)dirp->d_namlen + 1);
569	return (STOP|FOUND);
570}
571
572int
573findino(struct inodesc *idesc)
574{
575	struct direct *dirp = idesc->id_dirp;
576
577	if (dirp->d_ino == 0)
578		return (KEEPON);
579	if (strcmp(dirp->d_name, idesc->id_name) == 0 &&
580	    dirp->d_ino >= ROOTINO && dirp->d_ino <= maxino) {
581		idesc->id_parent = dirp->d_ino;
582		return (STOP|FOUND);
583	}
584	return (KEEPON);
585}
586
587int
588clearentry(struct inodesc *idesc)
589{
590	struct direct *dirp = idesc->id_dirp;
591
592	if (dirp->d_ino != idesc->id_parent || idesc->id_entryno < 2) {
593		idesc->id_entryno++;
594		return (KEEPON);
595	}
596	dirp->d_ino = 0;
597	return (STOP|FOUND|ALTERED);
598}
599
600void
601pinode(ino_t ino)
602{
603	union dinode *dp;
604	char *p;
605	struct passwd *pw;
606	time_t t;
607
608	printf(" I=%lu ", (u_long)ino);
609	if (ino < ROOTINO || ino > maxino)
610		return;
611	dp = ginode(ino);
612	printf(" OWNER=");
613	if ((pw = getpwuid((int)DIP(dp, di_uid))) != 0)
614		printf("%s ", pw->pw_name);
615	else
616		printf("%u ", (unsigned)DIP(dp, di_uid));
617	printf("MODE=%o\n", DIP(dp, di_mode));
618	if (preen)
619		printf("%s: ", cdevname);
620	printf("SIZE=%ju ", (uintmax_t)DIP(dp, di_size));
621	t = DIP(dp, di_mtime);
622	p = ctime(&t);
623	printf("MTIME=%12.12s %4.4s ", &p[4], &p[20]);
624}
625
626void
627blkerror(ino_t ino, const char *type, ufs2_daddr_t blk)
628{
629
630	pfatal("%jd %s I=%ju", (intmax_t)blk, type, (uintmax_t)ino);
631	printf("\n");
632	switch (inoinfo(ino)->ino_state) {
633
634	case FSTATE:
635	case FZLINK:
636		inoinfo(ino)->ino_state = FCLEAR;
637		return;
638
639	case DSTATE:
640	case DZLINK:
641		inoinfo(ino)->ino_state = DCLEAR;
642		return;
643
644	case FCLEAR:
645	case DCLEAR:
646		return;
647
648	default:
649		errx(EEXIT, "BAD STATE %d TO BLKERR", inoinfo(ino)->ino_state);
650		/* NOTREACHED */
651	}
652}
653
654/*
655 * allocate an unused inode
656 */
657ino_t
658allocino(ino_t request, int type)
659{
660	ino_t ino;
661	union dinode *dp;
662	struct bufarea *cgbp;
663	struct cg *cgp;
664	int cg;
665
666	if (request == 0)
667		request = ROOTINO;
668	else if (inoinfo(request)->ino_state != USTATE)
669		return (0);
670	for (ino = request; ino < maxino; ino++)
671		if (inoinfo(ino)->ino_state == USTATE)
672			break;
673	if (ino == maxino)
674		return (0);
675	cg = ino_to_cg(&sblock, ino);
676	cgbp = cgget(cg);
677	cgp = cgbp->b_un.b_cg;
678	if (!check_cgmagic(cg, cgbp))
679		return (0);
680	setbit(cg_inosused(cgp), ino % sblock.fs_ipg);
681	cgp->cg_cs.cs_nifree--;
682	switch (type & IFMT) {
683	case IFDIR:
684		inoinfo(ino)->ino_state = DSTATE;
685		cgp->cg_cs.cs_ndir++;
686		break;
687	case IFREG:
688	case IFLNK:
689		inoinfo(ino)->ino_state = FSTATE;
690		break;
691	default:
692		return (0);
693	}
694	dirty(cgbp);
695	dp = ginode(ino);
696	DIP_SET(dp, di_db[0], allocblk((long)1));
697	if (DIP(dp, di_db[0]) == 0) {
698		inoinfo(ino)->ino_state = USTATE;
699		return (0);
700	}
701	DIP_SET(dp, di_mode, type);
702	DIP_SET(dp, di_flags, 0);
703	DIP_SET(dp, di_atime, time(NULL));
704	DIP_SET(dp, di_ctime, DIP(dp, di_atime));
705	DIP_SET(dp, di_mtime, DIP(dp, di_ctime));
706	DIP_SET(dp, di_mtimensec, 0);
707	DIP_SET(dp, di_ctimensec, 0);
708	DIP_SET(dp, di_atimensec, 0);
709	DIP_SET(dp, di_size, sblock.fs_fsize);
710	DIP_SET(dp, di_blocks, btodb(sblock.fs_fsize));
711	n_files++;
712	inodirty();
713	inoinfo(ino)->ino_type = IFTODT(type);
714	return (ino);
715}
716
717/*
718 * deallocate an inode
719 */
720void
721freeino(ino_t ino)
722{
723	struct inodesc idesc;
724	union dinode *dp;
725
726	memset(&idesc, 0, sizeof(struct inodesc));
727	idesc.id_type = ADDR;
728	idesc.id_func = pass4check;
729	idesc.id_number = ino;
730	dp = ginode(ino);
731	(void)ckinode(dp, &idesc);
732	clearinode(dp);
733	inodirty();
734	inoinfo(ino)->ino_state = USTATE;
735	n_files--;
736}
737