vxfs_super.c 7.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284
  1. /*
  2. * Copyright (c) 2000-2001 Christoph Hellwig.
  3. * All rights reserved.
  4. *
  5. * Redistribution and use in source and binary forms, with or without
  6. * modification, are permitted provided that the following conditions
  7. * are met:
  8. * 1. Redistributions of source code must retain the above copyright
  9. * notice, this list of conditions, and the following disclaimer,
  10. * without modification.
  11. * 2. The name of the author may not be used to endorse or promote products
  12. * derived from this software without specific prior written permission.
  13. *
  14. * Alternatively, this software may be distributed under the terms of the
  15. * GNU General Public License ("GPL").
  16. *
  17. * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20. * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  21. * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27. * SUCH DAMAGE.
  28. */
  29. /*
  30. * Veritas filesystem driver - superblock related routines.
  31. */
  32. #include <linux/init.h>
  33. #include <linux/module.h>
  34. #include <linux/blkdev.h>
  35. #include <linux/fs.h>
  36. #include <linux/buffer_head.h>
  37. #include <linux/kernel.h>
  38. #include <linux/slab.h>
  39. #include <linux/stat.h>
  40. #include <linux/vfs.h>
  41. #include <linux/mount.h>
  42. #include "vxfs.h"
  43. #include "vxfs_extern.h"
  44. #include "vxfs_dir.h"
  45. #include "vxfs_inode.h"
  46. MODULE_AUTHOR("Christoph Hellwig");
  47. MODULE_DESCRIPTION("Veritas Filesystem (VxFS) driver");
  48. MODULE_LICENSE("Dual BSD/GPL");
  49. MODULE_ALIAS("vxfs"); /* makes mount -t vxfs autoload the module */
  50. static void vxfs_put_super(struct super_block *);
  51. static int vxfs_statfs(struct dentry *, struct kstatfs *);
  52. static int vxfs_remount(struct super_block *, int *, char *);
  53. static const struct super_operations vxfs_super_ops = {
  54. .read_inode = vxfs_read_inode,
  55. .clear_inode = vxfs_clear_inode,
  56. .put_super = vxfs_put_super,
  57. .statfs = vxfs_statfs,
  58. .remount_fs = vxfs_remount,
  59. };
  60. /**
  61. * vxfs_put_super - free superblock resources
  62. * @sbp: VFS superblock.
  63. *
  64. * Description:
  65. * vxfs_put_super frees all resources allocated for @sbp
  66. * after the last instance of the filesystem is unmounted.
  67. */
  68. static void
  69. vxfs_put_super(struct super_block *sbp)
  70. {
  71. struct vxfs_sb_info *infp = VXFS_SBI(sbp);
  72. vxfs_put_fake_inode(infp->vsi_fship);
  73. vxfs_put_fake_inode(infp->vsi_ilist);
  74. vxfs_put_fake_inode(infp->vsi_stilist);
  75. brelse(infp->vsi_bp);
  76. kfree(infp);
  77. }
  78. /**
  79. * vxfs_statfs - get filesystem information
  80. * @dentry: VFS dentry to locate superblock
  81. * @bufp: output buffer
  82. *
  83. * Description:
  84. * vxfs_statfs fills the statfs buffer @bufp with information
  85. * about the filesystem described by @dentry.
  86. *
  87. * Returns:
  88. * Zero.
  89. *
  90. * Locking:
  91. * No locks held.
  92. *
  93. * Notes:
  94. * This is everything but complete...
  95. */
  96. static int
  97. vxfs_statfs(struct dentry *dentry, struct kstatfs *bufp)
  98. {
  99. struct vxfs_sb_info *infp = VXFS_SBI(dentry->d_sb);
  100. bufp->f_type = VXFS_SUPER_MAGIC;
  101. bufp->f_bsize = dentry->d_sb->s_blocksize;
  102. bufp->f_blocks = infp->vsi_raw->vs_dsize;
  103. bufp->f_bfree = infp->vsi_raw->vs_free;
  104. bufp->f_bavail = 0;
  105. bufp->f_files = 0;
  106. bufp->f_ffree = infp->vsi_raw->vs_ifree;
  107. bufp->f_namelen = VXFS_NAMELEN;
  108. return 0;
  109. }
  110. static int vxfs_remount(struct super_block *sb, int *flags, char *data)
  111. {
  112. *flags |= MS_RDONLY;
  113. return 0;
  114. }
  115. /**
  116. * vxfs_read_super - read superblock into memory and initalize filesystem
  117. * @sbp: VFS superblock (to fill)
  118. * @dp: fs private mount data
  119. * @silent: do not complain loudly when sth is wrong
  120. *
  121. * Description:
  122. * We are called on the first mount of a filesystem to read the
  123. * superblock into memory and do some basic setup.
  124. *
  125. * Returns:
  126. * The superblock on success, else %NULL.
  127. *
  128. * Locking:
  129. * We are under the bkl and @sbp->s_lock.
  130. */
  131. static int vxfs_fill_super(struct super_block *sbp, void *dp, int silent)
  132. {
  133. struct vxfs_sb_info *infp;
  134. struct vxfs_sb *rsbp;
  135. struct buffer_head *bp = NULL;
  136. u_long bsize;
  137. struct inode *root;
  138. sbp->s_flags |= MS_RDONLY;
  139. infp = kzalloc(sizeof(*infp), GFP_KERNEL);
  140. if (!infp) {
  141. printk(KERN_WARNING "vxfs: unable to allocate incore superblock\n");
  142. return -ENOMEM;
  143. }
  144. bsize = sb_min_blocksize(sbp, BLOCK_SIZE);
  145. if (!bsize) {
  146. printk(KERN_WARNING "vxfs: unable to set blocksize\n");
  147. goto out;
  148. }
  149. bp = sb_bread(sbp, 1);
  150. if (!bp || !buffer_mapped(bp)) {
  151. if (!silent) {
  152. printk(KERN_WARNING
  153. "vxfs: unable to read disk superblock\n");
  154. }
  155. goto out;
  156. }
  157. rsbp = (struct vxfs_sb *)bp->b_data;
  158. if (rsbp->vs_magic != VXFS_SUPER_MAGIC) {
  159. if (!silent)
  160. printk(KERN_NOTICE "vxfs: WRONG superblock magic\n");
  161. goto out;
  162. }
  163. if ((rsbp->vs_version < 2 || rsbp->vs_version > 4) && !silent) {
  164. printk(KERN_NOTICE "vxfs: unsupported VxFS version (%d)\n",
  165. rsbp->vs_version);
  166. goto out;
  167. }
  168. #ifdef DIAGNOSTIC
  169. printk(KERN_DEBUG "vxfs: supported VxFS version (%d)\n", rsbp->vs_version);
  170. printk(KERN_DEBUG "vxfs: blocksize: %d\n", rsbp->vs_bsize);
  171. #endif
  172. sbp->s_magic = rsbp->vs_magic;
  173. sbp->s_fs_info = infp;
  174. infp->vsi_raw = rsbp;
  175. infp->vsi_bp = bp;
  176. infp->vsi_oltext = rsbp->vs_oltext[0];
  177. infp->vsi_oltsize = rsbp->vs_oltsize;
  178. if (!sb_set_blocksize(sbp, rsbp->vs_bsize)) {
  179. printk(KERN_WARNING "vxfs: unable to set final block size\n");
  180. goto out;
  181. }
  182. if (vxfs_read_olt(sbp, bsize)) {
  183. printk(KERN_WARNING "vxfs: unable to read olt\n");
  184. goto out;
  185. }
  186. if (vxfs_read_fshead(sbp)) {
  187. printk(KERN_WARNING "vxfs: unable to read fshead\n");
  188. goto out;
  189. }
  190. sbp->s_op = &vxfs_super_ops;
  191. root = iget(sbp, VXFS_ROOT_INO);
  192. sbp->s_root = d_alloc_root(root);
  193. if (!sbp->s_root) {
  194. iput(root);
  195. printk(KERN_WARNING "vxfs: unable to get root dentry.\n");
  196. goto out_free_ilist;
  197. }
  198. return 0;
  199. out_free_ilist:
  200. vxfs_put_fake_inode(infp->vsi_fship);
  201. vxfs_put_fake_inode(infp->vsi_ilist);
  202. vxfs_put_fake_inode(infp->vsi_stilist);
  203. out:
  204. brelse(bp);
  205. kfree(infp);
  206. return -EINVAL;
  207. }
  208. /*
  209. * The usual module blurb.
  210. */
  211. static int vxfs_get_sb(struct file_system_type *fs_type,
  212. int flags, const char *dev_name, void *data, struct vfsmount *mnt)
  213. {
  214. return get_sb_bdev(fs_type, flags, dev_name, data, vxfs_fill_super,
  215. mnt);
  216. }
  217. static struct file_system_type vxfs_fs_type = {
  218. .owner = THIS_MODULE,
  219. .name = "vxfs",
  220. .get_sb = vxfs_get_sb,
  221. .kill_sb = kill_block_super,
  222. .fs_flags = FS_REQUIRES_DEV,
  223. };
  224. static int __init
  225. vxfs_init(void)
  226. {
  227. int rv;
  228. vxfs_inode_cachep = kmem_cache_create("vxfs_inode",
  229. sizeof(struct vxfs_inode_info), 0,
  230. SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL, NULL);
  231. if (!vxfs_inode_cachep)
  232. return -ENOMEM;
  233. rv = register_filesystem(&vxfs_fs_type);
  234. if (rv < 0)
  235. kmem_cache_destroy(vxfs_inode_cachep);
  236. return rv;
  237. }
  238. static void __exit
  239. vxfs_cleanup(void)
  240. {
  241. unregister_filesystem(&vxfs_fs_type);
  242. kmem_cache_destroy(vxfs_inode_cachep);
  243. }
  244. module_init(vxfs_init);
  245. module_exit(vxfs_cleanup);