1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2000-2001 Christoph Hellwig. 4 * Copyright (c) 2016 Krzysztof Blaszkowski 5 */ 6 7 /* 8 * Veritas filesystem driver - superblock related routines. 9 */ 10 #include <linux/init.h> 11 #include <linux/module.h> 12 13 #include <linux/blkdev.h> 14 #include <linux/fs.h> 15 #include <linux/buffer_head.h> 16 #include <linux/kernel.h> 17 #include <linux/slab.h> 18 #include <linux/stat.h> 19 #include <linux/vfs.h> 20 #include <linux/mount.h> 21 22 #include "vxfs.h" 23 #include "vxfs_extern.h" 24 #include "vxfs_dir.h" 25 #include "vxfs_inode.h" 26 27 28 MODULE_AUTHOR("Christoph Hellwig, Krzysztof Blaszkowski"); 29 MODULE_DESCRIPTION("Veritas Filesystem (VxFS) driver"); 30 MODULE_LICENSE("Dual BSD/GPL"); 31 32 static struct kmem_cache *vxfs_inode_cachep; 33 34 /** 35 * vxfs_put_super - free superblock resources 36 * @sbp: VFS superblock. 37 * 38 * Description: 39 * vxfs_put_super frees all resources allocated for @sbp 40 * after the last instance of the filesystem is unmounted. 41 */ 42 43 static void 44 vxfs_put_super(struct super_block *sbp) 45 { 46 struct vxfs_sb_info *infp = VXFS_SBI(sbp); 47 48 iput(infp->vsi_fship); 49 iput(infp->vsi_ilist); 50 iput(infp->vsi_stilist); 51 52 brelse(infp->vsi_bp); 53 kfree(infp); 54 } 55 56 /** 57 * vxfs_statfs - get filesystem information 58 * @dentry: VFS dentry to locate superblock 59 * @bufp: output buffer 60 * 61 * Description: 62 * vxfs_statfs fills the statfs buffer @bufp with information 63 * about the filesystem described by @dentry. 64 * 65 * Returns: 66 * Zero. 67 * 68 * Locking: 69 * No locks held. 70 * 71 * Notes: 72 * This is everything but complete... 73 */ 74 static int 75 vxfs_statfs(struct dentry *dentry, struct kstatfs *bufp) 76 { 77 struct vxfs_sb_info *infp = VXFS_SBI(dentry->d_sb); 78 struct vxfs_sb *raw_sb = infp->vsi_raw; 79 u64 id = huge_encode_dev(dentry->d_sb->s_bdev->bd_dev); 80 81 bufp->f_type = VXFS_SUPER_MAGIC; 82 bufp->f_bsize = dentry->d_sb->s_blocksize; 83 bufp->f_blocks = fs32_to_cpu(infp, raw_sb->vs_dsize); 84 bufp->f_bfree = fs32_to_cpu(infp, raw_sb->vs_free); 85 bufp->f_bavail = 0; 86 bufp->f_files = 0; 87 bufp->f_ffree = fs32_to_cpu(infp, raw_sb->vs_ifree); 88 bufp->f_fsid = u64_to_fsid(id); 89 bufp->f_namelen = VXFS_NAMELEN; 90 91 return 0; 92 } 93 94 static int vxfs_remount(struct super_block *sb, int *flags, char *data) 95 { 96 sync_filesystem(sb); 97 *flags |= SB_RDONLY; 98 return 0; 99 } 100 101 static struct inode *vxfs_alloc_inode(struct super_block *sb) 102 { 103 struct vxfs_inode_info *vi; 104 105 vi = alloc_inode_sb(sb, vxfs_inode_cachep, GFP_KERNEL); 106 if (!vi) 107 return NULL; 108 inode_init_once(&vi->vfs_inode); 109 return &vi->vfs_inode; 110 } 111 112 static void vxfs_free_inode(struct inode *inode) 113 { 114 kmem_cache_free(vxfs_inode_cachep, VXFS_INO(inode)); 115 } 116 117 static const struct super_operations vxfs_super_ops = { 118 .alloc_inode = vxfs_alloc_inode, 119 .free_inode = vxfs_free_inode, 120 .evict_inode = vxfs_evict_inode, 121 .put_super = vxfs_put_super, 122 .statfs = vxfs_statfs, 123 .remount_fs = vxfs_remount, 124 }; 125 126 static int vxfs_try_sb_magic(struct super_block *sbp, int silent, 127 unsigned blk, __fs32 magic) 128 { 129 struct buffer_head *bp; 130 struct vxfs_sb *rsbp; 131 struct vxfs_sb_info *infp = VXFS_SBI(sbp); 132 int rc = -ENOMEM; 133 134 bp = sb_bread(sbp, blk); 135 do { 136 if (!bp || !buffer_mapped(bp)) { 137 if (!silent) { 138 printk(KERN_WARNING 139 "vxfs: unable to read disk superblock at %u\n", 140 blk); 141 } 142 break; 143 } 144 145 rc = -EINVAL; 146 rsbp = (struct vxfs_sb *)bp->b_data; 147 if (rsbp->vs_magic != magic) { 148 if (!silent) 149 printk(KERN_NOTICE 150 "vxfs: WRONG superblock magic %08x at %u\n", 151 rsbp->vs_magic, blk); 152 break; 153 } 154 155 rc = 0; 156 infp->vsi_raw = rsbp; 157 infp->vsi_bp = bp; 158 } while (0); 159 160 if (rc) { 161 infp->vsi_raw = NULL; 162 infp->vsi_bp = NULL; 163 brelse(bp); 164 } 165 166 return rc; 167 } 168 169 /** 170 * vxfs_fill_super - read superblock into memory and initialize filesystem 171 * @sbp: VFS superblock (to fill) 172 * @dp: fs private mount data 173 * @silent: do not complain loudly when sth is wrong 174 * 175 * Description: 176 * We are called on the first mount of a filesystem to read the 177 * superblock into memory and do some basic setup. 178 * 179 * Returns: 180 * The superblock on success, else %NULL. 181 * 182 * Locking: 183 * We are under @sbp->s_lock. 184 */ 185 static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent) 186 { 187 struct vxfs_sb_info *infp; 188 struct vxfs_sb *rsbp; 189 u_long bsize; 190 struct inode *root; 191 int ret = -EINVAL; 192 u32 j; 193 194 sbp->s_flags |= SB_RDONLY; 195 196 infp = kzalloc(sizeof(*infp), GFP_KERNEL); 197 if (!infp) { 198 printk(KERN_WARNING "vxfs: unable to allocate incore superblock\n"); 199 return -ENOMEM; 200 } 201 202 bsize = sb_min_blocksize(sbp, BLOCK_SIZE); 203 if (!bsize) { 204 printk(KERN_WARNING "vxfs: unable to set blocksize\n"); 205 goto out; 206 } 207 208 sbp->s_op = &vxfs_super_ops; 209 sbp->s_fs_info = infp; 210 sbp->s_time_min = 0; 211 sbp->s_time_max = U32_MAX; 212 213 if (!vxfs_try_sb_magic(sbp, silent, 1, 214 (__force __fs32)cpu_to_le32(VXFS_SUPER_MAGIC))) { 215 /* Unixware, x86 */ 216 infp->byte_order = VXFS_BO_LE; 217 } else if (!vxfs_try_sb_magic(sbp, silent, 8, 218 (__force __fs32)cpu_to_be32(VXFS_SUPER_MAGIC))) { 219 /* HP-UX, parisc */ 220 infp->byte_order = VXFS_BO_BE; 221 } else { 222 if (!silent) 223 printk(KERN_NOTICE "vxfs: can't find superblock.\n"); 224 goto out; 225 } 226 227 rsbp = infp->vsi_raw; 228 j = fs32_to_cpu(infp, rsbp->vs_version); 229 if ((j < 2 || j > 4) && !silent) { 230 printk(KERN_NOTICE "vxfs: unsupported VxFS version (%d)\n", j); 231 goto out; 232 } 233 234 #ifdef DIAGNOSTIC 235 printk(KERN_DEBUG "vxfs: supported VxFS version (%d)\n", j); 236 printk(KERN_DEBUG "vxfs: blocksize: %d\n", 237 fs32_to_cpu(infp, rsbp->vs_bsize)); 238 #endif 239 240 sbp->s_magic = fs32_to_cpu(infp, rsbp->vs_magic); 241 242 infp->vsi_oltext = fs32_to_cpu(infp, rsbp->vs_oltext[0]); 243 infp->vsi_oltsize = fs32_to_cpu(infp, rsbp->vs_oltsize); 244 245 j = fs32_to_cpu(infp, rsbp->vs_bsize); 246 if (!sb_set_blocksize(sbp, j)) { 247 printk(KERN_WARNING "vxfs: unable to set final block size\n"); 248 goto out; 249 } 250 251 if (vxfs_read_olt(sbp, bsize)) { 252 printk(KERN_WARNING "vxfs: unable to read olt\n"); 253 goto out; 254 } 255 256 if (vxfs_read_fshead(sbp)) { 257 printk(KERN_WARNING "vxfs: unable to read fshead\n"); 258 goto out; 259 } 260 261 root = vxfs_iget(sbp, VXFS_ROOT_INO); 262 if (IS_ERR(root)) { 263 ret = PTR_ERR(root); 264 goto out; 265 } 266 sbp->s_root = d_make_root(root); 267 if (!sbp->s_root) { 268 printk(KERN_WARNING "vxfs: unable to get root dentry.\n"); 269 goto out_free_ilist; 270 } 271 272 return 0; 273 274 out_free_ilist: 275 iput(infp->vsi_fship); 276 iput(infp->vsi_ilist); 277 iput(infp->vsi_stilist); 278 out: 279 brelse(infp->vsi_bp); 280 kfree(infp); 281 return ret; 282 } 283 284 /* 285 * The usual module blurb. 286 */ 287 static struct dentry *vxfs_mount(struct file_system_type *fs_type, 288 int flags, const char *dev_name, void *data) 289 { 290 return mount_bdev(fs_type, flags, dev_name, data, vxfs_fill_super); 291 } 292 293 static struct file_system_type vxfs_fs_type = { 294 .owner = THIS_MODULE, 295 .name = "vxfs", 296 .mount = vxfs_mount, 297 .kill_sb = kill_block_super, 298 .fs_flags = FS_REQUIRES_DEV, 299 }; 300 MODULE_ALIAS_FS("vxfs"); /* makes mount -t vxfs autoload the module */ 301 MODULE_ALIAS("vxfs"); 302 303 static int __init 304 vxfs_init(void) 305 { 306 int rv; 307 308 vxfs_inode_cachep = kmem_cache_create_usercopy("vxfs_inode", 309 sizeof(struct vxfs_inode_info), 0, 310 SLAB_RECLAIM_ACCOUNT, 311 offsetof(struct vxfs_inode_info, vii_immed.vi_immed), 312 sizeof_field(struct vxfs_inode_info, 313 vii_immed.vi_immed), 314 NULL); 315 if (!vxfs_inode_cachep) 316 return -ENOMEM; 317 rv = register_filesystem(&vxfs_fs_type); 318 if (rv < 0) 319 kmem_cache_destroy(vxfs_inode_cachep); 320 return rv; 321 } 322 323 static void __exit 324 vxfs_cleanup(void) 325 { 326 unregister_filesystem(&vxfs_fs_type); 327 /* 328 * Make sure all delayed rcu free inodes are flushed before we 329 * destroy cache. 330 */ 331 rcu_barrier(); 332 kmem_cache_destroy(vxfs_inode_cachep); 333 } 334 335 module_init(vxfs_init); 336 module_exit(vxfs_cleanup); 337