Whamcloud - gitweb
LU-6204 build: clean up kernel module metadata
[fs/lustre-release.git] / 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.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2014, Intel Corporation.
31  */
32 /*
33  * This file is part of Lustre, http://www.lustre.org/
34  * Lustre is a trademark of Sun Microsystems, Inc.
35  */
36
37 #define DEBUG_SUBSYSTEM S_LLITE
38
39 #include <linux/module.h>
40 #include <linux/types.h>
41 #include <linux/version.h>
42 #include <lustre_ha.h>
43 #include <lustre_dlm.h>
44 #include <linux/init.h>
45 #include <linux/fs.h>
46 #include <lprocfs_status.h>
47 #include "llite_internal.h"
48 #include "vvp_internal.h"
49
50 static struct kmem_cache *ll_inode_cachep;
51
52 static struct inode *ll_alloc_inode(struct super_block *sb)
53 {
54         struct ll_inode_info *lli;
55         ll_stats_ops_tally(ll_s2sbi(sb), LPROC_LL_ALLOC_INODE, 1);
56         OBD_SLAB_ALLOC_PTR_GFP(lli, ll_inode_cachep, GFP_NOFS);
57         if (lli == NULL)
58                 return NULL;
59
60         inode_init_once(&lli->lli_vfs_inode);
61         return &lli->lli_vfs_inode;
62 }
63
64 #ifdef HAVE_INODE_I_RCU
65 static void ll_inode_destroy_callback(struct rcu_head *head)
66 {
67         struct inode *inode = container_of(head, struct inode, i_rcu);
68         struct ll_inode_info *ptr = ll_i2info(inode);
69         OBD_SLAB_FREE_PTR(ptr, ll_inode_cachep);
70 }
71
72 static void ll_destroy_inode(struct inode *inode)
73 {
74         call_rcu(&inode->i_rcu, ll_inode_destroy_callback);
75 }
76 #else
77 static void ll_destroy_inode(struct inode *inode)
78 {
79         struct ll_inode_info *ptr = ll_i2info(inode);
80         OBD_SLAB_FREE_PTR(ptr, ll_inode_cachep);
81 }
82 #endif
83
84 /* exported operations */
85 struct super_operations lustre_super_operations =
86 {
87         .alloc_inode   = ll_alloc_inode,
88         .destroy_inode = ll_destroy_inode,
89 #ifdef HAVE_SBOPS_EVICT_INODE
90         .evict_inode   = ll_delete_inode,
91 #else
92         .clear_inode   = ll_clear_inode,
93         .delete_inode  = ll_delete_inode,
94 #endif
95         .put_super     = ll_put_super,
96         .statfs        = ll_statfs,
97         .umount_begin  = ll_umount_begin,
98         .remount_fs    = ll_remount_fs,
99         .show_options  = ll_show_options,
100 };
101
102
103 void lustre_register_client_process_config(int (*cpc)(struct lustre_cfg *lcfg));
104
105 static int __init lustre_init(void)
106 {
107         struct proc_dir_entry *entry;
108         lnet_process_id_t lnet_id;
109         struct timeval tv;
110         int i, rc, seed[2];
111
112         CLASSERT(sizeof(LUSTRE_VOLATILE_HDR) == LUSTRE_VOLATILE_HDR_LEN + 1);
113
114         /* print an address of _any_ initialized kernel symbol from this
115          * module, to allow debugging with gdb that doesn't support data
116          * symbols from modules.*/
117         CDEBUG(D_INFO, "Lustre client module (%p).\n",
118                &lustre_super_operations);
119
120         ll_inode_cachep = kmem_cache_create("lustre_inode_cache",
121                                             sizeof(struct ll_inode_info),
122                                             0, SLAB_HWCACHE_ALIGN, NULL);
123         if (ll_inode_cachep == NULL)
124                 GOTO(out_cache, rc = -ENOMEM);
125
126         ll_file_data_slab = kmem_cache_create("ll_file_data",
127                                                  sizeof(struct ll_file_data), 0,
128                                                  SLAB_HWCACHE_ALIGN, NULL);
129         if (ll_file_data_slab == NULL)
130                 GOTO(out_cache, rc = -ENOMEM);
131
132         ll_remote_perm_cachep = kmem_cache_create("ll_remote_perm_cache",
133                                                   sizeof(struct ll_remote_perm),
134                                                   0, 0, NULL);
135         if (ll_remote_perm_cachep == NULL)
136                 GOTO(out_cache, rc = -ENOMEM);
137
138         ll_rmtperm_hash_cachep = kmem_cache_create("ll_rmtperm_hash_cache",
139                                                    REMOTE_PERM_HASHSIZE *
140                                                    sizeof(struct list_head),
141                                                    0, 0, NULL);
142         if (ll_rmtperm_hash_cachep == NULL)
143                 GOTO(out_cache, rc = -ENOMEM);
144
145         entry = lprocfs_register("llite", proc_lustre_root, NULL, NULL);
146         if (IS_ERR(entry)) {
147                 rc = PTR_ERR(entry);
148                 CERROR("cannot register '/proc/fs/lustre/llite': rc = %d\n",
149                        rc);
150                 GOTO(out_cache, rc);
151         }
152
153         proc_lustre_fs_root = entry;
154
155         cfs_get_random_bytes(seed, sizeof(seed));
156
157         /* Nodes with small feet have little entropy. The NID for this
158          * node gives the most entropy in the low bits. */
159         for (i = 0;; i++) {
160                 if (LNetGetId(i, &lnet_id) == -ENOENT)
161                         break;
162
163                 if (LNET_NETTYP(LNET_NIDNET(lnet_id.nid)) != LOLND)
164                         seed[0] ^= LNET_NIDADDR(lnet_id.nid);
165         }
166
167         do_gettimeofday(&tv);
168         cfs_srand(tv.tv_sec ^ seed[0], tv.tv_usec ^ seed[1]);
169
170         rc = vvp_global_init();
171         if (rc != 0)
172                 GOTO(out_proc, rc);
173
174         cl_inode_fini_env = cl_env_alloc(&cl_inode_fini_refcheck,
175                                          LCT_REMEMBER | LCT_NOREF);
176         if (IS_ERR(cl_inode_fini_env))
177                 GOTO(out_vvp, rc = PTR_ERR(cl_inode_fini_env));
178
179         cl_inode_fini_env->le_ctx.lc_cookie = 0x4;
180
181         rc = ll_xattr_init();
182         if (rc != 0)
183                 GOTO(out_inode_fini_env, rc);
184
185         lustre_register_client_fill_super(ll_fill_super);
186         lustre_register_kill_super_cb(ll_kill_super);
187         lustre_register_client_process_config(ll_process_config);
188
189         RETURN(0);
190
191 out_inode_fini_env:
192         cl_env_put(cl_inode_fini_env, &cl_inode_fini_refcheck);
193 out_vvp:
194         vvp_global_fini();
195 out_proc:
196         lprocfs_remove(&proc_lustre_fs_root);
197 out_cache:
198         if (ll_inode_cachep != NULL)
199                 kmem_cache_destroy(ll_inode_cachep);
200
201         if (ll_file_data_slab != NULL)
202                 kmem_cache_destroy(ll_file_data_slab);
203
204         if (ll_remote_perm_cachep != NULL)
205                 kmem_cache_destroy(ll_remote_perm_cachep);
206
207         if (ll_rmtperm_hash_cachep != NULL)
208                 kmem_cache_destroy(ll_rmtperm_hash_cachep);
209
210         return rc;
211 }
212
213 static void __exit lustre_exit(void)
214 {
215         lustre_register_client_fill_super(NULL);
216         lustre_register_kill_super_cb(NULL);
217         lustre_register_client_process_config(NULL);
218
219         lprocfs_remove(&proc_lustre_fs_root);
220
221         ll_xattr_fini();
222         cl_env_put(cl_inode_fini_env, &cl_inode_fini_refcheck);
223         vvp_global_fini();
224
225         kmem_cache_destroy(ll_inode_cachep);
226         kmem_cache_destroy(ll_rmtperm_hash_cachep);
227         kmem_cache_destroy(ll_remote_perm_cachep);
228         kmem_cache_destroy(ll_file_data_slab);
229 }
230
231 MODULE_AUTHOR("OpenSFS, Inc. <http://www.lustre.org/>");
232 MODULE_DESCRIPTION("Lustre Client File System");
233 MODULE_VERSION(LUSTRE_VERSION_STRING);
234 MODULE_LICENSE("GPL");
235
236 module_init(lustre_init);
237 module_exit(lustre_exit);