LXR linux/drivers/staging/lustre/lustre/llite/super25.c

   1/*
   2 * GPL HEADER START
   3 *
   4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5 *
   6 * This program is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License version 2 only,
   8 * as published by the Free Software Foundation.
   9 *
  10 * This program is distributed in the hope that it will be useful, but
  11 * WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 * General Public License version 2 for more details (a copy is included
  14 * in the LICENSE file that accompanied this code).
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * version 2 along with this program; If not, see
  18 * http://www.gnu.org/licenses/gpl-2.0.html
  19 *
  20 * GPL HEADER END
  21 */
  22/*
  23 * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  24 * Use is subject to license terms.
  25 *
  26 * Copyright (c) 2011, Intel Corporation.
  27 */
  28/*
  29 * This file is part of Lustre, http://www.lustre.org/
  30 * Lustre is a trademark of Sun Microsystems, Inc.
  31 */
  32
  33#define DEBUG_SUBSYSTEM S_LLITE
  34
  35#include <linux/module.h>
  36#include <linux/types.h>
  37#include "../include/lustre_ha.h"
  38#include "../include/lustre_dlm.h"
  39#include <linux/init.h>
  40#include <linux/fs.h>
  41#include "../include/lprocfs_status.h"
  42#include "llite_internal.h"
  43
  44static struct kmem_cache *ll_inode_cachep;
  45
  46static struct inode *ll_alloc_inode(struct super_block *sb)
  47{
  48        struct ll_inode_info *lli;
  49
  50        ll_stats_ops_tally(ll_s2sbi(sb), LPROC_LL_ALLOC_INODE, 1);
  51        lli = kmem_cache_zalloc(ll_inode_cachep, GFP_NOFS);
  52        if (!lli)
  53                return NULL;
  54
  55        inode_init_once(&lli->lli_vfs_inode);
  56        return &lli->lli_vfs_inode;
  57}
  58
  59static void ll_inode_destroy_callback(struct rcu_head *head)
  60{
  61        struct inode *inode = container_of(head, struct inode, i_rcu);
  62        struct ll_inode_info *ptr = ll_i2info(inode);
  63
  64        kmem_cache_free(ll_inode_cachep, ptr);
  65}
  66
  67static void ll_destroy_inode(struct inode *inode)
  68{
  69        call_rcu(&inode->i_rcu, ll_inode_destroy_callback);
  70}
  71
  72/* exported operations */
  73struct super_operations lustre_super_operations = {
  74        .alloc_inode   = ll_alloc_inode,
  75        .destroy_inode = ll_destroy_inode,
  76        .evict_inode   = ll_delete_inode,
  77        .put_super     = ll_put_super,
  78        .statfs = ll_statfs,
  79        .umount_begin  = ll_umount_begin,
  80        .remount_fs    = ll_remount_fs,
  81        .show_options  = ll_show_options,
  82};
  83MODULE_ALIAS_FS("lustre");
  84
  85static int __init lustre_init(void)
  86{
  87        struct lnet_process_id lnet_id;
  88        struct timespec64 ts;
  89        int i, rc, seed[2];
  90
  91        BUILD_BUG_ON(sizeof(LUSTRE_VOLATILE_HDR) != LUSTRE_VOLATILE_HDR_LEN + 1);
  92
  93        /* print an address of _any_ initialized kernel symbol from this
  94         * module, to allow debugging with gdb that doesn't support data
  95         * symbols from modules.
  96         */
  97        CDEBUG(D_INFO, "Lustre client module (%p).\n",
  98               &lustre_super_operations);
  99
 100        rc = -ENOMEM;
 101        ll_inode_cachep = kmem_cache_create("lustre_inode_cache",
 102                                            sizeof(struct ll_inode_info), 0,
 103                                            SLAB_HWCACHE_ALIGN | SLAB_ACCOUNT,
 104                                            NULL);
 105        if (!ll_inode_cachep)
 106                goto out_cache;
 107
 108        ll_file_data_slab = kmem_cache_create("ll_file_data",
 109                                              sizeof(struct ll_file_data), 0,
 110                                              SLAB_HWCACHE_ALIGN, NULL);
 111        if (!ll_file_data_slab)
 112                goto out_cache;
 113
 114        llite_root = debugfs_create_dir("llite", debugfs_lustre_root);
 115        if (IS_ERR_OR_NULL(llite_root)) {
 116                rc = llite_root ? PTR_ERR(llite_root) : -ENOMEM;
 117                llite_root = NULL;
 118                goto out_cache;
 119        }
 120
 121        llite_kset = kset_create_and_add("llite", NULL, lustre_kobj);
 122        if (!llite_kset) {
 123                rc = -ENOMEM;
 124                goto out_debugfs;
 125        }
 126
 127        cfs_get_random_bytes(seed, sizeof(seed));
 128
 129        /* Nodes with small feet have little entropy. The NID for this
 130         * node gives the most entropy in the low bits
 131         */
 132        for (i = 0;; i++) {
 133                if (LNetGetId(i, &lnet_id) == -ENOENT)
 134                        break;
 135
 136                if (LNET_NETTYP(LNET_NIDNET(lnet_id.nid)) != LOLND)
 137                        seed[0] ^= LNET_NIDADDR(lnet_id.nid);
 138        }
 139
 140        ktime_get_ts64(&ts);
 141        cfs_srand(ts.tv_sec ^ seed[0], ts.tv_nsec ^ seed[1]);
 142
 143        rc = vvp_global_init();
 144        if (rc != 0)
 145                goto out_sysfs;
 146
 147        cl_inode_fini_env = cl_env_alloc(&cl_inode_fini_refcheck,
 148                                         LCT_REMEMBER | LCT_NOREF);
 149        if (IS_ERR(cl_inode_fini_env)) {
 150                rc = PTR_ERR(cl_inode_fini_env);
 151                goto out_vvp;
 152        }
 153
 154        cl_inode_fini_env->le_ctx.lc_cookie = 0x4;
 155
 156        rc = ll_xattr_init();
 157        if (rc != 0)
 158                goto out_inode_fini_env;
 159
 160        lustre_register_client_fill_super(ll_fill_super);
 161        lustre_register_kill_super_cb(ll_kill_super);
 162        lustre_register_client_process_config(ll_process_config);
 163
 164        return 0;
 165
 166out_inode_fini_env:
 167        cl_env_put(cl_inode_fini_env, &cl_inode_fini_refcheck);
 168out_vvp:
 169        vvp_global_fini();
 170out_sysfs:
 171        kset_unregister(llite_kset);
 172out_debugfs:
 173        debugfs_remove(llite_root);
 174out_cache:
 175        kmem_cache_destroy(ll_inode_cachep);
 176        kmem_cache_destroy(ll_file_data_slab);
 177        return rc;
 178}
 179
 180static void __exit lustre_exit(void)
 181{
 182        lustre_register_client_fill_super(NULL);
 183        lustre_register_kill_super_cb(NULL);
 184        lustre_register_client_process_config(NULL);
 185
 186        debugfs_remove(llite_root);
 187        kset_unregister(llite_kset);
 188
 189        ll_xattr_fini();
 190        cl_env_put(cl_inode_fini_env, &cl_inode_fini_refcheck);
 191        vvp_global_fini();
 192
 193        kmem_cache_destroy(ll_inode_cachep);
 194        kmem_cache_destroy(ll_file_data_slab);
 195}
 196
 197MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
 198MODULE_DESCRIPTION("Lustre Client File System");
 199MODULE_VERSION(LUSTRE_VERSION_STRING);
 200MODULE_LICENSE("GPL");
 201
 202module_init(lustre_init);
 203module_exit(lustre_exit);
 204