xref: /freebsd/sys/fs/ext2fs/ext2_subr.c (revision f7c32ed617858bcd22f8d1b03199099d50125721)
1 /*-
2  *  modified for Lites 1.1
3  *
4  *  Aug 1995, Godmar Back (gback@cs.utah.edu)
5  *  University of Utah, Department of Computer Science
6  */
7 /*-
8  * SPDX-License-Identifier: BSD-3-Clause
9  *
10  * Copyright (c) 1982, 1986, 1989, 1993
11  *	The Regents of the University of California.  All rights reserved.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  * 3. Neither the name of the University nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  *
37  *	@(#)ffs_subr.c	8.2 (Berkeley) 9/21/93
38  * $FreeBSD$
39  */
40 
41 #include <sys/param.h>
42 
43 #include <sys/proc.h>
44 #include <sys/sdt.h>
45 #include <sys/systm.h>
46 #include <sys/bio.h>
47 #include <sys/buf.h>
48 #include <sys/lock.h>
49 #include <sys/ucred.h>
50 #include <sys/vnode.h>
51 
52 #include <fs/ext2fs/fs.h>
53 #include <fs/ext2fs/inode.h>
54 #include <fs/ext2fs/ext2fs.h>
55 #include <fs/ext2fs/ext2_extern.h>
56 #include <fs/ext2fs/fs.h>
57 #include <fs/ext2fs/ext2_extents.h>
58 #include <fs/ext2fs/ext2_mount.h>
59 #include <fs/ext2fs/ext2_dinode.h>
60 
61 /*
62  * Return buffer with the contents of block "offset" from the beginning of
63  * directory "ip".  If "res" is non-zero, fill it in with a pointer to the
64  * remaining space in the directory.
65  */
66 int
67 ext2_blkatoff(struct vnode *vp, off_t offset, char **res, struct buf **bpp)
68 {
69 	struct inode *ip;
70 	struct m_ext2fs *fs;
71 	struct buf *bp;
72 	e2fs_lbn_t lbn;
73 	int error, bsize;
74 
75 	ip = VTOI(vp);
76 	fs = ip->i_e2fs;
77 	lbn = lblkno(fs, offset);
78 	bsize = blksize(fs, ip, lbn);
79 
80 	if ((error = bread(vp, lbn, bsize, NOCRED, &bp)) != 0) {
81 		brelse(bp);
82 		return (error);
83 	}
84 	error = ext2_dir_blk_csum_verify(ip, bp);
85 	if (error != 0) {
86 		brelse(bp);
87 		return (error);
88 	}
89 	if (res)
90 		*res = (char *)bp->b_data + blkoff(fs, offset);
91 
92 	*bpp = bp;
93 
94 	return (0);
95 }
96 
97 /*
98  * Update the cluster map because of an allocation of free like ffs.
99  *
100  * Cnt == 1 means free; cnt == -1 means allocating.
101  */
102 void
103 ext2_clusteracct(struct m_ext2fs *fs, char *bbp, int cg, e4fs_daddr_t bno, int cnt)
104 {
105 	int32_t *sump = fs->e2fs_clustersum[cg].cs_sum;
106 	int32_t *lp;
107 	e4fs_daddr_t start, end, loc, forw, back;
108 	int bit, i;
109 
110 	/* Initialize the cluster summary array. */
111 	if (fs->e2fs_clustersum[cg].cs_init == 0) {
112 		int run = 0;
113 
114 		bit = 1;
115 		loc = 0;
116 
117 		for (i = 0; i < fs->e2fs_fpg; i++) {
118 			if ((bbp[loc] & bit) == 0)
119 				run++;
120 			else if (run != 0) {
121 				if (run > fs->e2fs_contigsumsize)
122 					run = fs->e2fs_contigsumsize;
123 				sump[run]++;
124 				run = 0;
125 			}
126 			if ((i & (NBBY - 1)) != (NBBY - 1))
127 				bit <<= 1;
128 			else {
129 				loc++;
130 				bit = 1;
131 			}
132 		}
133 		if (run != 0) {
134 			if (run > fs->e2fs_contigsumsize)
135 				run = fs->e2fs_contigsumsize;
136 			sump[run]++;
137 		}
138 		fs->e2fs_clustersum[cg].cs_init = 1;
139 	}
140 
141 	if (fs->e2fs_contigsumsize <= 0)
142 		return;
143 
144 	/* Find the size of the cluster going forward. */
145 	start = bno + 1;
146 	end = start + fs->e2fs_contigsumsize;
147 	if (end > fs->e2fs_fpg)
148 		end = fs->e2fs_fpg;
149 	loc = start / NBBY;
150 	bit = 1 << (start % NBBY);
151 	for (i = start; i < end; i++) {
152 		if ((bbp[loc] & bit) != 0)
153 			break;
154 		if ((i & (NBBY - 1)) != (NBBY - 1))
155 			bit <<= 1;
156 		else {
157 			loc++;
158 			bit = 1;
159 		}
160 	}
161 	forw = i - start;
162 
163 	/* Find the size of the cluster going backward. */
164 	start = bno - 1;
165 	end = start - fs->e2fs_contigsumsize;
166 	if (end < 0)
167 		end = -1;
168 	loc = start / NBBY;
169 	bit = 1 << (start % NBBY);
170 	for (i = start; i > end; i--) {
171 		if ((bbp[loc] & bit) != 0)
172 			break;
173 		if ((i & (NBBY - 1)) != 0)
174 			bit >>= 1;
175 		else {
176 			loc--;
177 			bit = 1 << (NBBY - 1);
178 		}
179 	}
180 	back = start - i;
181 
182 	/*
183 	 * Account for old cluster and the possibly new forward and
184 	 * back clusters.
185 	 */
186 	i = back + forw + 1;
187 	if (i > fs->e2fs_contigsumsize)
188 		i = fs->e2fs_contigsumsize;
189 	sump[i] += cnt;
190 	if (back > 0)
191 		sump[back] -= cnt;
192 	if (forw > 0)
193 		sump[forw] -= cnt;
194 
195 	/* Update cluster summary information. */
196 	lp = &sump[fs->e2fs_contigsumsize];
197 	for (i = fs->e2fs_contigsumsize; i > 0; i--)
198 		if (*lp-- > 0)
199 			break;
200 	fs->e2fs_maxcluster[cg] = i;
201 }
202