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 <jmallett@FreeBSD.org> 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 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 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 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 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 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 (-1); 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 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