xref: /freebsd/usr.sbin/makefs/msdos/msdosfs_denode.c (revision acb1f1269c6f4ff89a0d28ba742f6687e9ef779d)
1 /*	$NetBSD: msdosfs_denode.c,v 1.7 2015/03/29 05:52:59 agc Exp $	*/
2 
3 /*-
4  * SPDX-License-Identifier: BSD-4-Clause
5  *
6  * Copyright (C) 1994, 1995, 1997 Wolfgang Solfrank.
7  * Copyright (C) 1994, 1995, 1997 TooLs GmbH.
8  * All rights reserved.
9  * Original code by Paul Popelka (paulp@uts.amdahl.com) (see below).
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  * 3. All advertising materials mentioning features or use of this software
20  *    must display the following acknowledgement:
21  *	This product includes software developed by TooLs GmbH.
22  * 4. The name of TooLs GmbH may not be used to endorse or promote products
23  *    derived from this software without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY TOOLS GMBH ``AS IS'' AND ANY EXPRESS OR
26  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28  * IN NO EVENT SHALL TOOLS GMBH BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
30  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
31  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
32  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
33  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
34  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35  */
36 /*-
37  * Written by Paul Popelka (paulp@uts.amdahl.com)
38  *
39  * You can do anything you want with this software, just don't say you wrote
40  * it, and don't remove this notice.
41  *
42  * This software is provided "as is".
43  *
44  * The author supplies this software to be publicly redistributed on the
45  * understanding that the author is not responsible for the correct
46  * functioning of this software in any circumstances and is not liable for
47  * any damages caused by this software.
48  *
49  * October 1992
50  */
51 
52 #include <sys/cdefs.h>
53 __FBSDID("$FreeBSD$");
54 
55 #include <sys/param.h>
56 #include <sys/errno.h>
57 
58 #include <stdbool.h>
59 #include <stdio.h>
60 #include <string.h>
61 #include <stdlib.h>
62 #include <util.h>
63 
64 #include <fs/msdosfs/bpb.h>
65 #include "msdos/denode.h"
66 #include <fs/msdosfs/fat.h>
67 #include <fs/msdosfs/msdosfsmount.h>
68 
69 #include "makefs.h"
70 #include "msdos.h"
71 
72 
73 /*
74  * If deget() succeeds it returns with the gotten denode locked().
75  *
76  * pmp	     - address of msdosfsmount structure of the filesystem containing
77  *	       the denode of interest.  The pm_dev field and the address of
78  *	       the msdosfsmount structure are used.
79  * dirclust  - which cluster bp contains, if dirclust is 0 (root directory)
80  *	       diroffset is relative to the beginning of the root directory,
81  *	       otherwise it is cluster relative.
82  * diroffset - offset past begin of cluster of denode we want
83  * depp	     - returns the address of the gotten denode.
84  */
85 int
86 deget(struct msdosfsmount *pmp, u_long dirclust, u_long diroffset,
87     struct denode **depp)
88 {
89 	int error;
90 	uint64_t inode;
91 	struct direntry *direntptr;
92 	struct denode *ldep;
93 	struct m_buf *bp;
94 
95 	MSDOSFS_DPRINTF(("deget(pmp %p, dirclust %lu, diroffset %lx, depp %p)\n",
96 	    pmp, dirclust, diroffset, depp));
97 
98 	/*
99 	 * On FAT32 filesystems, root is a (more or less) normal
100 	 * directory
101 	 */
102 	if (FAT32(pmp) && dirclust == MSDOSFSROOT)
103 		dirclust = pmp->pm_rootdirblk;
104 
105 	inode = (uint64_t)pmp->pm_bpcluster * dirclust + diroffset;
106 
107 	ldep = ecalloc(1, sizeof(*ldep));
108 	ldep->de_vnode = NULL;
109 	ldep->de_flag = 0;
110 	ldep->de_dirclust = dirclust;
111 	ldep->de_diroffset = diroffset;
112 	ldep->de_inode = inode;
113 	ldep->de_pmp = pmp;
114 	ldep->de_refcnt = 1;
115 	fc_purge(ldep, 0);	/* init the FAT cache for this denode */
116 	/*
117 	 * Copy the directory entry into the denode area of the vnode.
118 	 */
119 	if ((dirclust == MSDOSFSROOT
120 	     || (FAT32(pmp) && dirclust == pmp->pm_rootdirblk))
121 	    && diroffset == MSDOSFSROOT_OFS) {
122 		/*
123 		 * Directory entry for the root directory. There isn't one,
124 		 * so we manufacture one. We should probably rummage
125 		 * through the root directory and find a label entry (if it
126 		 * exists), and then use the time and date from that entry
127 		 * as the time and date for the root denode.
128 		 */
129 		ldep->de_vnode = (struct vnode *)-1;
130 
131 		ldep->de_Attributes = ATTR_DIRECTORY;
132 		ldep->de_LowerCase = 0;
133 		if (FAT32(pmp))
134 			ldep->de_StartCluster = pmp->pm_rootdirblk;
135 			/* de_FileSize will be filled in further down */
136 		else {
137 			ldep->de_StartCluster = MSDOSFSROOT;
138 			ldep->de_FileSize = pmp->pm_rootdirsize * DEV_BSIZE;
139 		}
140 		/*
141 		 * fill in time and date so that dos2unixtime() doesn't
142 		 * spit up when called from msdosfs_getattr() with root
143 		 * denode
144 		 */
145 		ldep->de_CHun = 0;
146 		ldep->de_CTime = 0x0000;	/* 00:00:00	 */
147 		ldep->de_CDate = (0 << DD_YEAR_SHIFT) | (1 << DD_MONTH_SHIFT)
148 		    | (1 << DD_DAY_SHIFT);
149 		/* Jan 1, 1980	 */
150 		ldep->de_ADate = ldep->de_CDate;
151 		ldep->de_MTime = ldep->de_CTime;
152 		ldep->de_MDate = ldep->de_CDate;
153 		/* leave the other fields as garbage */
154 	} else {
155 		error = m_readep(pmp, dirclust, diroffset, &bp, &direntptr);
156 		if (error) {
157 			ldep->de_Name[0] = SLOT_DELETED;
158 
159 			*depp = NULL;
160 			return (error);
161 		}
162 		(void)DE_INTERNALIZE(ldep, direntptr);
163 		brelse(bp);
164 	}
165 
166 	/*
167 	 * Fill in a few fields of the vnode and finish filling in the
168 	 * denode.  Then return the address of the found denode.
169 	 */
170 	if (ldep->de_Attributes & ATTR_DIRECTORY) {
171 		/*
172 		 * Since DOS directory entries that describe directories
173 		 * have 0 in the filesize field, we take this opportunity
174 		 * to find out the length of the directory and plug it into
175 		 * the denode structure.
176 		 */
177 		u_long size;
178 
179 		/*
180 		 * XXX it sometimes happens that the "." entry has cluster
181 		 * number 0 when it shouldn't.  Use the actual cluster number
182 		 * instead of what is written in directory entry.
183 		 */
184 		if (diroffset == 0 && ldep->de_StartCluster != dirclust) {
185 			MSDOSFS_DPRINTF(("deget(): \".\" entry at clust %lu != %lu\n",
186 			    dirclust, ldep->de_StartCluster));
187 
188 			ldep->de_StartCluster = dirclust;
189 		}
190 
191 		if (ldep->de_StartCluster != MSDOSFSROOT) {
192 			error = pcbmap(ldep, 0xffff, 0, &size, 0);
193 			if (error == E2BIG) {
194 				ldep->de_FileSize = de_cn2off(pmp, size);
195 				error = 0;
196 			} else {
197 				MSDOSFS_DPRINTF(("deget(): pcbmap returned %d\n",
198 				    error));
199 			}
200 		}
201 	}
202 	*depp = ldep;
203 	return (0);
204 }
205 
206 /*
207  * Truncate the file described by dep to the length specified by length.
208  */
209 int
210 detrunc(struct denode *dep, u_long length, int flags, struct ucred *cred)
211 {
212 	int error;
213 	int allerror;
214 	u_long eofentry;
215 	u_long chaintofree;
216 	daddr_t bn;
217 	int boff;
218 	int isadir = dep->de_Attributes & ATTR_DIRECTORY;
219 	struct m_buf *bp;
220 	struct msdosfsmount *pmp = dep->de_pmp;
221 
222 	MSDOSFS_DPRINTF(("detrunc(): file %s, length %lu, flags %x\n",
223 	    dep->de_Name, length, flags));
224 
225 	/*
226 	 * Disallow attempts to truncate the root directory since it is of
227 	 * fixed size.  That's just the way dos filesystems are.  We use
228 	 * the VROOT bit in the vnode because checking for the directory
229 	 * bit and a startcluster of 0 in the denode is not adequate to
230 	 * recognize the root directory at this point in a file or
231 	 * directory's life.
232 	 */
233 	if (dep->de_vnode != NULL && !FAT32(pmp)) {
234 		MSDOSFS_DPRINTF(("detrunc(): can't truncate root directory, "
235 		    "clust %ld, offset %ld\n",
236 		    dep->de_dirclust, dep->de_diroffset));
237 
238 		return (EINVAL);
239 	}
240 
241 	if (dep->de_FileSize < length)
242 		return deextend(dep, length, cred);
243 
244 	/*
245 	 * If the desired length is 0 then remember the starting cluster of
246 	 * the file and set the StartCluster field in the directory entry
247 	 * to 0.  If the desired length is not zero, then get the number of
248 	 * the last cluster in the shortened file.  Then get the number of
249 	 * the first cluster in the part of the file that is to be freed.
250 	 * Then set the next cluster pointer in the last cluster of the
251 	 * file to CLUST_EOFE.
252 	 */
253 	if (length == 0) {
254 		chaintofree = dep->de_StartCluster;
255 		dep->de_StartCluster = 0;
256 		eofentry = ~0;
257 	} else {
258 		error = pcbmap(dep, de_clcount(pmp, length) - 1, 0,
259 		    &eofentry, 0);
260 		if (error) {
261 			MSDOSFS_DPRINTF(("detrunc(): pcbmap fails %d\n",
262 			    error));
263 			return (error);
264 		}
265 	}
266 
267 	fc_purge(dep, de_clcount(pmp, length));
268 
269 	/*
270 	 * If the new length is not a multiple of the cluster size then we
271 	 * must zero the tail end of the new last cluster in case it
272 	 * becomes part of the file again because of a seek.
273 	 */
274 	if ((boff = length & pmp->pm_crbomask) != 0) {
275 		if (isadir) {
276 			bn = cntobn(pmp, eofentry);
277 			error = bread((void *)pmp->pm_devvp, bn,
278 			    pmp->pm_bpcluster, 0, &bp);
279 			if (error) {
280 				brelse(bp);
281 				MSDOSFS_DPRINTF(("detrunc(): bread fails %d\n",
282 				    error));
283 
284 				return (error);
285 			}
286 			memset(bp->b_data + boff, 0, pmp->pm_bpcluster - boff);
287 			bwrite(bp);
288 		}
289 	}
290 
291 	/*
292 	 * Write out the updated directory entry.  Even if the update fails
293 	 * we free the trailing clusters.
294 	 */
295 	dep->de_FileSize = length;
296 	if (!isadir)
297 		dep->de_flag |= DE_UPDATE|DE_MODIFIED;
298 	MSDOSFS_DPRINTF(("detrunc(): allerror %d, eofentry %lu\n",
299 	    allerror, eofentry));
300 
301 	/*
302 	 * If we need to break the cluster chain for the file then do it
303 	 * now.
304 	 */
305 	if (eofentry != ~0) {
306 		error = fatentry(FAT_GET_AND_SET, pmp, eofentry,
307 				 &chaintofree, CLUST_EOFE);
308 		if (error) {
309 			MSDOSFS_DPRINTF(("detrunc(): fatentry errors %d\n",
310 			    error));
311 			return (error);
312 		}
313 		fc_setcache(dep, FC_LASTFC, de_cluster(pmp, length - 1),
314 		    eofentry);
315 	}
316 
317 	/*
318 	 * Now free the clusters removed from the file because of the
319 	 * truncation.
320 	 */
321 	if (chaintofree != 0 && !MSDOSFSEOF(pmp, chaintofree))
322 		freeclusterchain(pmp, chaintofree);
323 
324 	return (allerror);
325 }
326 
327 /*
328  * Extend the file described by dep to length specified by length.
329  */
330 int
331 deextend(struct denode *dep, u_long length, struct ucred *cred)
332 {
333 	struct msdosfsmount *pmp = dep->de_pmp;
334 	u_long count;
335 	int error;
336 
337 	/*
338 	 * The root of a DOS filesystem cannot be extended.
339 	 */
340 	if (dep->de_vnode != NULL && !FAT32(pmp))
341 		return (EINVAL);
342 
343 	/*
344 	 * Directories cannot be extended.
345 	 */
346 	if (dep->de_Attributes & ATTR_DIRECTORY)
347 		return (EISDIR);
348 
349 	if (length <= dep->de_FileSize)
350 		return (E2BIG);
351 
352 	/*
353 	 * Compute the number of clusters to allocate.
354 	 */
355 	count = de_clcount(pmp, length) - de_clcount(pmp, dep->de_FileSize);
356 	if (count > 0) {
357 		if (count > pmp->pm_freeclustercount)
358 			return (ENOSPC);
359 		error = m_extendfile(dep, count, NULL, NULL, DE_CLEAR);
360 		if (error) {
361 			/* truncate the added clusters away again */
362 			(void) detrunc(dep, dep->de_FileSize, 0, cred);
363 			return (error);
364 		}
365 	}
366 
367 	/*
368 	 * Zero extend file range; ubc_zerorange() uses ubc_alloc() and a
369 	 * memset(); we set the write size so ubc won't read in file data that
370 	 * is zero'd later.
371 	 */
372 	dep->de_FileSize = length;
373 	dep->de_flag |= DE_UPDATE | DE_MODIFIED;
374 	return 0;
375 }
376