1 /* $NetBSD: v7fs_superblock.c,v 1.2 2011/07/18 21:51:49 apb Exp $ */ 2 3 /*- 4 * Copyright (c) 2011 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by UCHIYAMA Yasushi. 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 #if HAVE_NBTOOL_CONFIG_H 33 #include "nbtool_config.h" 34 #endif 35 36 #include <sys/cdefs.h> 37 __KERNEL_RCSID(0, "$NetBSD: v7fs_superblock.c,v 1.2 2011/07/18 21:51:49 apb Exp $"); 38 #if defined _KERNEL_OPT 39 #include "opt_v7fs.h" 40 #endif 41 42 #ifdef _KERNEL 43 #include <sys/systm.h> 44 #include <sys/param.h> /* errno */ 45 #else 46 #include <stdio.h> 47 #include <string.h> 48 #include <errno.h> 49 #endif 50 51 #include "v7fs.h" 52 #include "v7fs_impl.h" 53 #include "v7fs_endian.h" 54 #include "v7fs_superblock.h" 55 #include "v7fs_inode.h" 56 #include "v7fs_datablock.h" 57 58 #ifdef V7FS_SUPERBLOCK_DEBUG 59 #define DPRINTF(fmt, args...) printf("%s: " fmt, __func__, ##args) 60 #define DPRINTF_(fmt, args...) printf(fmt, ##args) 61 #else 62 #define DPRINTF(fmt, args...) ((void)0) 63 #define DPRINTF_(fmt, args...) ((void)0) 64 #endif 65 66 static void v7fs_superblock_endian_convert(struct v7fs_self *, 67 struct v7fs_superblock *, struct v7fs_superblock *); 68 static int v7fs_superblock_sanity(struct v7fs_self *); 69 70 /* Load superblock from disk. */ 71 int 72 v7fs_superblock_load(struct v7fs_self *fs) 73 { 74 struct v7fs_superblock *disksb; 75 void *buf; 76 int error; 77 78 if (!(buf = scratch_read(fs, V7FS_SUPERBLOCK_SECTOR))) 79 return EIO; 80 disksb = (struct v7fs_superblock *)buf; 81 v7fs_superblock_endian_convert(fs, &fs->superblock, disksb); 82 scratch_free(fs, buf); 83 84 if ((error = v7fs_superblock_sanity(fs))) 85 return error; 86 87 return 0; 88 } 89 90 /* Writeback superblock to disk. */ 91 int 92 v7fs_superblock_writeback(struct v7fs_self *fs) 93 { 94 struct v7fs_superblock *memsb = &fs->superblock; 95 struct v7fs_superblock *disksb; 96 void *buf; 97 int error = 0; 98 99 if (!memsb->modified) 100 return 0; 101 102 if (!(buf = scratch_read(fs, V7FS_SUPERBLOCK_SECTOR))) 103 return EIO; 104 disksb = (struct v7fs_superblock *)buf; 105 v7fs_superblock_endian_convert(fs, disksb, memsb); 106 if (!fs->io.write(fs->io.cookie, buf, V7FS_SUPERBLOCK_SECTOR)) 107 error = EIO; 108 scratch_free(fs, buf); 109 110 memsb->modified = 0; 111 DPRINTF("done. %d\n", error); 112 113 return error; 114 } 115 116 /* Check endian mismatch. */ 117 static int 118 v7fs_superblock_sanity(struct v7fs_self *fs) 119 { 120 const struct v7fs_superblock *sb = &fs->superblock; 121 void *buf = 0; 122 123 if ((sb->volume_size < 128) || /* smaller than 64KB. */ 124 (sb->datablock_start_sector > sb->volume_size) || 125 (sb->nfreeinode > V7FS_MAX_FREEINODE) || 126 (sb->nfreeblock > V7FS_MAX_FREEBLOCK) || 127 (sb->update_time < 0) || 128 (sb->total_freeblock > sb->volume_size) || 129 ((sb->nfreeinode == 0) && (sb->nfreeblock == 0) && 130 (sb->total_freeblock == 0) && (sb->total_freeinode == 0)) || 131 (!(buf = scratch_read(fs, sb->volume_size - 1)))) { 132 DPRINTF("invalid super block.\n"); 133 return EINVAL; 134 } 135 if (buf) 136 scratch_free(fs, buf); 137 138 return 0; 139 } 140 141 /* Fill free block to superblock cache. */ 142 int 143 v7fs_freeblock_update(struct v7fs_self *fs, v7fs_daddr_t blk) 144 { 145 /* Assume superblock is locked by caller. */ 146 struct v7fs_superblock *sb = &fs->superblock; 147 struct v7fs_freeblock *fb; 148 void *buf; 149 int error; 150 151 /* Read next freeblock table from disk. */ 152 if (!datablock_number_sanity(fs, blk) || !(buf = scratch_read(fs, blk))) 153 return EIO; 154 155 /* Update in-core superblock freelist. */ 156 fb = (struct v7fs_freeblock *)buf; 157 if ((error = v7fs_freeblock_endian_convert(fs, fb))) { 158 scratch_free(fs, buf); 159 return error; 160 } 161 DPRINTF("freeblock table#%d, nfree=%d\n", blk, fb->nfreeblock); 162 163 memcpy(sb->freeblock, fb->freeblock, sizeof(blk) * fb->nfreeblock); 164 sb->nfreeblock = fb->nfreeblock; 165 sb->modified = true; 166 scratch_free(fs, buf); 167 168 return 0; 169 } 170 171 int 172 v7fs_freeblock_endian_convert(struct v7fs_self *fs __unused, 173 struct v7fs_freeblock *fb __unused) 174 { 175 #ifdef V7FS_EI 176 int i; 177 int16_t nfree; 178 179 nfree = V7FS_VAL16(fs, fb->nfreeblock); 180 if (nfree <= 0 || nfree > V7FS_MAX_FREEBLOCK) { 181 DPRINTF("invalid freeblock list. %d (max=%d)\n", nfree, 182 V7FS_MAX_FREEBLOCK); 183 return ENOSPC; 184 } 185 fb->nfreeblock = nfree; 186 187 for (i = 0; i < nfree; i++) { 188 fb->freeblock[i] = V7FS_VAL32(fs, fb->freeblock[i]); 189 } 190 #endif /* V7FS_EI */ 191 192 return 0; 193 } 194 195 /* Fill free inode to superblock cache. */ 196 int 197 v7fs_freeinode_update(struct v7fs_self *fs) 198 { 199 /* Assume superblock is locked by caller. */ 200 struct v7fs_superblock *sb = &fs->superblock; 201 v7fs_ino_t *freeinode = sb->freeinode; 202 size_t i, j, k; 203 v7fs_ino_t ino; 204 205 /* Loop over all inode list. */ 206 for (i = V7FS_ILIST_SECTOR, ino = 1/* inode start from 1*/, k = 0; 207 i < sb->datablock_start_sector; i++) { 208 struct v7fs_inode_diskimage *di; 209 void *buf; 210 if (!(buf = scratch_read(fs, i))) { 211 DPRINTF("block %zu I/O error.\n", i); 212 ino += V7FS_INODE_PER_BLOCK; 213 continue; 214 } 215 di = (struct v7fs_inode_diskimage *)buf; 216 217 for (j = 0; 218 (j < V7FS_INODE_PER_BLOCK) && (k < V7FS_MAX_FREEINODE); 219 j++, di++, ino++) { 220 if (v7fs_inode_allocated(di)) 221 continue; 222 DPRINTF("free inode%d\n", ino); 223 freeinode[k++] = ino; 224 } 225 scratch_free(fs, buf); 226 } 227 sb->nfreeinode = k; 228 229 return 0; 230 } 231 232 static void 233 v7fs_superblock_endian_convert(struct v7fs_self *fs __unused, 234 struct v7fs_superblock *to, struct v7fs_superblock *from) 235 { 236 #ifdef V7FS_EI 237 #define conv16(m) (to->m = V7FS_VAL16(fs, from->m)) 238 #define conv32(m) (to->m = V7FS_VAL32(fs, from->m)) 239 int i; 240 241 conv16(datablock_start_sector); 242 conv32(volume_size); 243 conv16(nfreeblock); 244 v7fs_daddr_t *dfrom = from->freeblock; 245 v7fs_daddr_t *dto = to->freeblock; 246 for (i = 0; i < V7FS_MAX_FREEBLOCK; i++, dfrom++, dto++) 247 *dto = V7FS_VAL32(fs, *dfrom); 248 249 conv16(nfreeinode); 250 v7fs_ino_t *ifrom = from->freeinode; 251 v7fs_ino_t *ito = to->freeinode; 252 for (i = 0; i < V7FS_MAX_FREEINODE; i++, ifrom++, ito++) 253 *ito = V7FS_VAL16(fs, *ifrom); 254 255 conv32(update_time); 256 conv32(total_freeblock); 257 conv16(total_freeinode); 258 #undef conv16 259 #undef conv32 260 #else /* V7FS_EI */ 261 memcpy(to, from , sizeof(*to)); 262 #endif /* V7FS_EI */ 263 } 264