xref: /freebsd/lib/libufs/block.c (revision bcedb9c0916d542e7c0e60f4f69abf4a1c538c9a)
120938dbfSJuli Mallett /*
220938dbfSJuli Mallett  * Copyright (c) 2002 Juli Mallett.  All rights reserved.
320938dbfSJuli Mallett  *
420938dbfSJuli Mallett  * This software was written by Juli Mallett <jmallett@FreeBSD.org> for the
520938dbfSJuli Mallett  * FreeBSD project.  Redistribution and use in source and binary forms, with
620938dbfSJuli Mallett  * or without modification, are permitted provided that the following
720938dbfSJuli Mallett  * conditions are met:
820938dbfSJuli Mallett  *
920938dbfSJuli Mallett  * 1. Redistribution of source code must retain the above copyright notice,
1020938dbfSJuli Mallett  *    this list of conditions and the following disclaimer.
1120938dbfSJuli Mallett  * 2. Redistribution in binary form must reproduce the above copyright
1220938dbfSJuli Mallett  *    notice, this list of conditions and the following disclaimer in the
1320938dbfSJuli Mallett  *    documentation and/or other materials provided with the distribution.
1420938dbfSJuli Mallett  *
1520938dbfSJuli Mallett  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
1620938dbfSJuli Mallett  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
1720938dbfSJuli Mallett  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
1820938dbfSJuli Mallett  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
1920938dbfSJuli Mallett  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
2020938dbfSJuli Mallett  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
2120938dbfSJuli Mallett  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
2220938dbfSJuli Mallett  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
2320938dbfSJuli Mallett  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
2420938dbfSJuli Mallett  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
2520938dbfSJuli Mallett  * POSSIBILITY OF SUCH DAMAGE.
2620938dbfSJuli Mallett  */
2720938dbfSJuli Mallett 
2820938dbfSJuli Mallett #include <sys/cdefs.h>
2920938dbfSJuli Mallett __FBSDID("$FreeBSD$");
3020938dbfSJuli Mallett 
3120938dbfSJuli Mallett #include <sys/param.h>
3220938dbfSJuli Mallett #include <sys/mount.h>
3320a0f65bSPoul-Henning Kamp #include <sys/disk.h>
3420938dbfSJuli Mallett #include <sys/disklabel.h>
3520938dbfSJuli Mallett #include <sys/stat.h>
3620938dbfSJuli Mallett 
3720938dbfSJuli Mallett #include <ufs/ufs/ufsmount.h>
3820938dbfSJuli Mallett #include <ufs/ufs/dinode.h>
3920938dbfSJuli Mallett #include <ufs/ffs/fs.h>
4020938dbfSJuli Mallett 
4120938dbfSJuli Mallett #include <errno.h>
423ff1f264SJuli Mallett #include <fcntl.h>
4320938dbfSJuli Mallett #include <stdio.h>
44ed1eac71SPoul-Henning Kamp #include <stdlib.h>
4520938dbfSJuli Mallett #include <string.h>
4620938dbfSJuli Mallett #include <unistd.h>
4720938dbfSJuli Mallett 
4820938dbfSJuli Mallett #include <libufs.h>
4920938dbfSJuli Mallett 
5020938dbfSJuli Mallett ssize_t
5120938dbfSJuli Mallett bread(struct uufsd *disk, ufs2_daddr_t blockno, void *data, size_t size)
5220938dbfSJuli Mallett {
53ed1eac71SPoul-Henning Kamp 	void *p2;
5420938dbfSJuli Mallett 	ssize_t cnt;
5520938dbfSJuli Mallett 
5649b2a686SJuli Mallett 	ERROR(disk, NULL);
5720938dbfSJuli Mallett 
58ed1eac71SPoul-Henning Kamp 	p2 = data;
5920938dbfSJuli Mallett 	/*
60ed1eac71SPoul-Henning Kamp 	 * XXX: various disk controllers require alignment of our buffer
61ed1eac71SPoul-Henning Kamp 	 * XXX: which is stricter than struct alignment.
62ed1eac71SPoul-Henning Kamp 	 * XXX: Bounce the buffer if not 64 byte aligned.
63ed1eac71SPoul-Henning Kamp 	 * XXX: this can be removed if/when the kernel is fixed
6420938dbfSJuli Mallett 	 */
65ed1eac71SPoul-Henning Kamp 	if (((intptr_t)data) & 0x3f) {
66ed1eac71SPoul-Henning Kamp 		p2 = malloc(size);
6706f53575SXin LI 		if (p2 == NULL) {
68ed1eac71SPoul-Henning Kamp 			ERROR(disk, "allocate bounce buffer");
6906f53575SXin LI 			goto fail;
7006f53575SXin LI 		}
71ed1eac71SPoul-Henning Kamp 	}
72ed1eac71SPoul-Henning Kamp 	cnt = pread(disk->d_fd, p2, size, (off_t)(blockno * disk->d_bsize));
73a506dcdaSJuli Mallett 	if (cnt == -1) {
74a506dcdaSJuli Mallett 		ERROR(disk, "read error from block device");
75a506dcdaSJuli Mallett 		goto fail;
76a506dcdaSJuli Mallett 	}
77a506dcdaSJuli Mallett 	if (cnt == 0) {
78a506dcdaSJuli Mallett 		ERROR(disk, "end of file from block device");
79a506dcdaSJuli Mallett 		goto fail;
80a506dcdaSJuli Mallett 	}
81a506dcdaSJuli Mallett 	if ((size_t)cnt != size) {
82a506dcdaSJuli Mallett 		ERROR(disk, "short read or read error from block device");
83a506dcdaSJuli Mallett 		goto fail;
8420938dbfSJuli Mallett 	}
85ed1eac71SPoul-Henning Kamp 	if (p2 != data) {
86ed1eac71SPoul-Henning Kamp 		memcpy(data, p2, size);
87ed1eac71SPoul-Henning Kamp 		free(p2);
88ed1eac71SPoul-Henning Kamp 	}
891081253fSJuli Mallett 	return (cnt);
90ed1eac71SPoul-Henning Kamp fail:	memset(data, 0, size);
91ed1eac71SPoul-Henning Kamp 	if (p2 != data) {
92ed1eac71SPoul-Henning Kamp 		free(p2);
93ed1eac71SPoul-Henning Kamp 	}
941081253fSJuli Mallett 	return (-1);
9520938dbfSJuli Mallett }
9620938dbfSJuli Mallett 
9720938dbfSJuli Mallett ssize_t
9820938dbfSJuli Mallett bwrite(struct uufsd *disk, ufs2_daddr_t blockno, const void *data, size_t size)
9920938dbfSJuli Mallett {
10020938dbfSJuli Mallett 	ssize_t cnt;
1017dc95357SJuli Mallett 	int rv;
102ed1eac71SPoul-Henning Kamp 	void *p2 = NULL;
10320938dbfSJuli Mallett 
10449b2a686SJuli Mallett 	ERROR(disk, NULL);
10520938dbfSJuli Mallett 
1067dc95357SJuli Mallett 	rv = ufs_disk_write(disk);
1077dc95357SJuli Mallett 	if (rv == -1) {
1083ff1f264SJuli Mallett 		ERROR(disk, "failed to open disk for writing");
1091081253fSJuli Mallett 		return (-1);
1103ff1f264SJuli Mallett 	}
1113ff1f264SJuli Mallett 
112ed1eac71SPoul-Henning Kamp 	/*
113ed1eac71SPoul-Henning Kamp 	 * XXX: various disk controllers require alignment of our buffer
114ed1eac71SPoul-Henning Kamp 	 * XXX: which is stricter than struct alignment.
115ed1eac71SPoul-Henning Kamp 	 * XXX: Bounce the buffer if not 64 byte aligned.
116ed1eac71SPoul-Henning Kamp 	 * XXX: this can be removed if/when the kernel is fixed
117ed1eac71SPoul-Henning Kamp 	 */
118ed1eac71SPoul-Henning Kamp 	if (((intptr_t)data) & 0x3f) {
119ed1eac71SPoul-Henning Kamp 		p2 = malloc(size);
12006f53575SXin LI 		if (p2 == NULL) {
121ed1eac71SPoul-Henning Kamp 			ERROR(disk, "allocate bounce buffer");
12206f53575SXin LI 			return (-1);
12306f53575SXin LI 		}
124ed1eac71SPoul-Henning Kamp 		memcpy(p2, data, size);
125ed1eac71SPoul-Henning Kamp 		data = p2;
126ed1eac71SPoul-Henning Kamp 	}
12720938dbfSJuli Mallett 	cnt = pwrite(disk->d_fd, data, size, (off_t)(blockno * disk->d_bsize));
128ed1eac71SPoul-Henning Kamp 	if (p2 != NULL)
129ed1eac71SPoul-Henning Kamp 		free(p2);
130a506dcdaSJuli Mallett 	if (cnt == -1) {
1315b3a32e4SJuli Mallett 		ERROR(disk, "write error to block device");
1321081253fSJuli Mallett 		return (-1);
133a506dcdaSJuli Mallett 	}
134a506dcdaSJuli Mallett 	if ((size_t)cnt != size) {
13549b2a686SJuli Mallett 		ERROR(disk, "short write to block device");
1361081253fSJuli Mallett 		return (-1);
13720938dbfSJuli Mallett 	}
13820938dbfSJuli Mallett 
1391081253fSJuli Mallett 	return (cnt);
14020938dbfSJuli Mallett }
14120a0f65bSPoul-Henning Kamp 
142*bcedb9c0SRobert Millan #ifdef __FreeBSD_kernel__
143*bcedb9c0SRobert Millan 
144*bcedb9c0SRobert Millan static int
145*bcedb9c0SRobert Millan berase_helper(struct uufsd *disk, ufs2_daddr_t blockno, ufs2_daddr_t size)
146*bcedb9c0SRobert Millan {
147*bcedb9c0SRobert Millan 	off_t ioarg[2];
148*bcedb9c0SRobert Millan 
149*bcedb9c0SRobert Millan 	ioarg[0] = blockno * disk->d_bsize;
150*bcedb9c0SRobert Millan 	ioarg[1] = size;
151*bcedb9c0SRobert Millan 	return (ioctl(disk->d_fd, DIOCGDELETE, ioarg));
152*bcedb9c0SRobert Millan }
153*bcedb9c0SRobert Millan 
154*bcedb9c0SRobert Millan #else
155*bcedb9c0SRobert Millan 
156*bcedb9c0SRobert Millan static int
157*bcedb9c0SRobert Millan berase_helper(struct uufsd *disk, ufs2_daddr_t blockno, ufs2_daddr_t size)
158*bcedb9c0SRobert Millan {
159*bcedb9c0SRobert Millan 	char *zero_chunk;
160*bcedb9c0SRobert Millan 	off_t offset, zero_chunk_size, pwrite_size;
161*bcedb9c0SRobert Millan 	int rv;
162*bcedb9c0SRobert Millan 
163*bcedb9c0SRobert Millan 	offset = blockno * disk->d_bsize;
164*bcedb9c0SRobert Millan 	zero_chunk_size = 65536 * disk->d_bsize;
165*bcedb9c0SRobert Millan 	zero_chunk = calloc(1, zero_chunk_size);
166*bcedb9c0SRobert Millan 	if (zero_chunk == NULL) {
167*bcedb9c0SRobert Millan 		ERROR(disk, "failed to allocate memory");
168*bcedb9c0SRobert Millan 		return (-1);
169*bcedb9c0SRobert Millan 	}
170*bcedb9c0SRobert Millan 	while (size > 0) {
171*bcedb9c0SRobert Millan 		pwrite_size = size;
172*bcedb9c0SRobert Millan 		if (pwrite_size > zero_chunk_size)
173*bcedb9c0SRobert Millan 			pwrite_size = zero_chunk_size;
174*bcedb9c0SRobert Millan 		rv = pwrite(disk->d_fd, zero_chunk, pwrite_size, offset);
175*bcedb9c0SRobert Millan 		if (rv == -1) {
176*bcedb9c0SRobert Millan 			ERROR(disk, "failed writing to disk");
177*bcedb9c0SRobert Millan 			break;
178*bcedb9c0SRobert Millan 		}
179*bcedb9c0SRobert Millan 		size -= rv;
180*bcedb9c0SRobert Millan 		offset += rv;
181*bcedb9c0SRobert Millan 		rv = 0;
182*bcedb9c0SRobert Millan 	}
183*bcedb9c0SRobert Millan 	free(zero_chunk);
184*bcedb9c0SRobert Millan 	return (rv);
185*bcedb9c0SRobert Millan }
186*bcedb9c0SRobert Millan 
187*bcedb9c0SRobert Millan #endif
188*bcedb9c0SRobert Millan 
18920a0f65bSPoul-Henning Kamp int
19020a0f65bSPoul-Henning Kamp berase(struct uufsd *disk, ufs2_daddr_t blockno, ufs2_daddr_t size)
19120a0f65bSPoul-Henning Kamp {
19220a0f65bSPoul-Henning Kamp 	int rv;
19320a0f65bSPoul-Henning Kamp 
19420a0f65bSPoul-Henning Kamp 	ERROR(disk, NULL);
19520a0f65bSPoul-Henning Kamp 	rv = ufs_disk_write(disk);
19620a0f65bSPoul-Henning Kamp 	if (rv == -1) {
19720a0f65bSPoul-Henning Kamp 		ERROR(disk, "failed to open disk for writing");
19820a0f65bSPoul-Henning Kamp 		return(rv);
19920a0f65bSPoul-Henning Kamp 	}
200*bcedb9c0SRobert Millan 	return (berase_helper(disk, blockno, size));
20120a0f65bSPoul-Henning Kamp }
202