1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3 *
4 * Copyright (c) 2002 Juli Mallett. All rights reserved.
5 *
6 * This software was written by Juli Mallett <[email protected]> for the
7 * FreeBSD project. Redistribution and use in source and binary forms, with
8 * or without modification, are permitted provided that the following
9 * conditions are met:
10 *
11 * 1. Redistribution of source code must retain the above copyright notice,
12 * this list of conditions and the following disclaimer.
13 * 2. Redistribution in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
19 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
20 * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
21 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
22 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
23 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
25 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
26 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 #include <sys/cdefs.h>
31 __FBSDID("$FreeBSD$");
32
33 #include <sys/param.h>
34 #include <sys/mount.h>
35 #include <sys/disklabel.h>
36 #include <sys/stat.h>
37
38 #include <ufs/ufs/ufsmount.h>
39 #include <ufs/ufs/dinode.h>
40 #include <ufs/ffs/fs.h>
41
42 #include <errno.h>
43 #include <stdio.h>
44 #include <string.h>
45 #include <stdlib.h>
46 #include <unistd.h>
47
48 #include <libufs.h>
49
50 int
sbread(struct uufsd * disk)51 sbread(struct uufsd *disk)
52 {
53 struct fs *fs;
54
55 ERROR(disk, NULL);
56
57 if ((errno = sbget(disk->d_fd, &fs, STDSB)) != 0) {
58 switch (errno) {
59 case EIO:
60 ERROR(disk, "non-existent or truncated superblock");
61 break;
62 case ENOENT:
63 ERROR(disk, "no usable known superblock found");
64 break;
65 case ENOSPC:
66 ERROR(disk, "failed to allocate space for superblock "
67 "information");
68 break;
69 case EINVAL:
70 ERROR(disk, "The previous newfs operation on this "
71 "volume did not complete.\nYou must complete "
72 "newfs before using this volume.");
73 break;
74 default:
75 ERROR(disk, "unknown superblock read error");
76 errno = EIO;
77 break;
78 }
79 disk->d_ufs = 0;
80 return (-1);
81 }
82 memcpy(&disk->d_fs, fs, fs->fs_sbsize);
83 free(fs);
84 fs = &disk->d_fs;
85 if (fs->fs_magic == FS_UFS1_MAGIC)
86 disk->d_ufs = 1;
87 if (fs->fs_magic == FS_UFS2_MAGIC)
88 disk->d_ufs = 2;
89 disk->d_bsize = fs->fs_fsize / fsbtodb(fs, 1);
90 disk->d_sblock = fs->fs_sblockloc / disk->d_bsize;
91 disk->d_si = fs->fs_si;
92 return (0);
93 }
94
95 int
sbwrite(struct uufsd * disk,int all)96 sbwrite(struct uufsd *disk, int all)
97 {
98 struct fs *fs;
99 int rv;
100
101 ERROR(disk, NULL);
102
103 rv = ufs_disk_write(disk);
104 if (rv == -1) {
105 ERROR(disk, "failed to open disk for writing");
106 return (-1);
107 }
108
109 fs = &disk->d_fs;
110 if ((errno = sbput(disk->d_fd, fs, all ? fs->fs_ncg : 0)) != 0) {
111 switch (errno) {
112 case EIO:
113 ERROR(disk, "failed to write superblock");
114 break;
115 default:
116 ERROR(disk, "unknown superblock write error");
117 errno = EIO;
118 break;
119 }
120 return (-1);
121 }
122 return (0);
123 }
124
125 /*
126 * These are the low-level functions that actually read and write
127 * the superblock and its associated data. The actual work is done by
128 * the functions ffs_sbget and ffs_sbput in /sys/ufs/ffs/ffs_subr.c.
129 */
130 static int use_pread(void *devfd, off_t loc, void **bufp, int size);
131 static int use_pwrite(void *devfd, off_t loc, void *buf, int size);
132
133 /*
134 * Read a superblock from the devfd device allocating memory returned
135 * in fsp. Also read the superblock summary information.
136 */
137 int
sbget(int devfd,struct fs ** fsp,off_t sblockloc)138 sbget(int devfd, struct fs **fsp, off_t sblockloc)
139 {
140
141 return (ffs_sbget(&devfd, fsp, sblockloc, "user", use_pread));
142 }
143
144 /*
145 * A read function for use by user-level programs using libufs.
146 */
147 static int
use_pread(void * devfd,off_t loc,void ** bufp,int size)148 use_pread(void *devfd, off_t loc, void **bufp, int size)
149 {
150 int fd;
151
152 fd = *(int *)devfd;
153 if ((*bufp = malloc(size)) == NULL)
154 return (ENOSPC);
155 if (pread(fd, *bufp, size, loc) != size)
156 return (EIO);
157 return (0);
158 }
159
160 /*
161 * Write a superblock to the devfd device from the memory pointed to by fs.
162 * Also write out the superblock summary information but do not free the
163 * summary information memory.
164 *
165 * Additionally write out numaltwrite of the alternate superblocks. Use
166 * fs->fs_ncg to write out all of the alternate superblocks.
167 */
168 int
sbput(int devfd,struct fs * fs,int numaltwrite)169 sbput(int devfd, struct fs *fs, int numaltwrite)
170 {
171 struct csum *savedcsp;
172 off_t savedactualloc;
173 int i, error;
174
175 if ((error = ffs_sbput(&devfd, fs, fs->fs_sblockactualloc,
176 use_pwrite)) != 0)
177 return (error);
178 if (numaltwrite == 0)
179 return (0);
180 savedactualloc = fs->fs_sblockactualloc;
181 savedcsp = fs->fs_csp;
182 fs->fs_csp = NULL;
183 for (i = 0; i < numaltwrite; i++) {
184 fs->fs_sblockactualloc = dbtob(fsbtodb(fs, cgsblock(fs, i)));
185 if ((error = ffs_sbput(&devfd, fs, fs->fs_sblockactualloc,
186 use_pwrite)) != 0) {
187 fs->fs_sblockactualloc = savedactualloc;
188 fs->fs_csp = savedcsp;
189 return (error);
190 }
191 }
192 fs->fs_sblockactualloc = savedactualloc;
193 fs->fs_csp = savedcsp;
194 return (0);
195 }
196
197 /*
198 * A write function for use by user-level programs using sbput in libufs.
199 */
200 static int
use_pwrite(void * devfd,off_t loc,void * buf,int size)201 use_pwrite(void *devfd, off_t loc, void *buf, int size)
202 {
203 int fd;
204
205 fd = *(int *)devfd;
206 if (pwrite(fd, buf, size, loc) != size)
207 return (EIO);
208 return (0);
209 }
210