Commit | Line | Data |
---|---|---|
274dcf55 MM |
1 | /* |
2 | * (C) 2001 Clemson University and The University of Chicago | |
3 | * | |
4 | * Changes by Acxiom Corporation to add proc file handler for pvfs2 client | |
5 | * parameters, Copyright Acxiom Corporation, 2005. | |
6 | * | |
7 | * See COPYING in top-level directory. | |
8 | */ | |
9 | ||
10 | #include "protocol.h" | |
575e9461 MM |
11 | #include "orangefs-kernel.h" |
12 | #include "orangefs-debugfs.h" | |
13 | #include "orangefs-sysfs.h" | |
274dcf55 | 14 | |
8bb8aefd YL |
15 | /* ORANGEFS_VERSION is a ./configure define */ |
16 | #ifndef ORANGEFS_VERSION | |
4c27b327 | 17 | #define ORANGEFS_VERSION "upstream" |
274dcf55 MM |
18 | #endif |
19 | ||
20 | /* | |
21 | * global variables declared here | |
22 | */ | |
23 | ||
889d5f1b | 24 | struct orangefs_stats orangefs_stats; |
274dcf55 MM |
25 | |
26 | /* the size of the hash tables for ops in progress */ | |
27 | int hash_table_size = 509; | |
28 | ||
29 | static ulong module_parm_debug_mask; | |
44f46410 | 30 | __u64 orangefs_gossip_debug_mask; |
8bb8aefd YL |
31 | int op_timeout_secs = ORANGEFS_DEFAULT_OP_TIMEOUT_SECS; |
32 | int slot_timeout_secs = ORANGEFS_DEFAULT_SLOT_TIMEOUT_SECS; | |
1d503617 MB |
33 | int orangefs_dcache_timeout_msecs = 50; |
34 | int orangefs_getattr_timeout_msecs = 50; | |
274dcf55 MM |
35 | |
36 | MODULE_LICENSE("GPL"); | |
8bb8aefd YL |
37 | MODULE_AUTHOR("ORANGEFS Development Team"); |
38 | MODULE_DESCRIPTION("The Linux Kernel VFS interface to ORANGEFS"); | |
39 | MODULE_PARM_DESC(module_parm_debug_mask, "debugging level (see orangefs-debug.h for values)"); | |
274dcf55 MM |
40 | MODULE_PARM_DESC(op_timeout_secs, "Operation timeout in seconds"); |
41 | MODULE_PARM_DESC(slot_timeout_secs, "Slot timeout in seconds"); | |
42 | MODULE_PARM_DESC(hash_table_size, | |
43 | "size of hash table for operations in progress"); | |
44 | ||
8bb8aefd | 45 | static struct file_system_type orangefs_fs_type = { |
274dcf55 | 46 | .name = "pvfs2", |
8bb8aefd YL |
47 | .mount = orangefs_mount, |
48 | .kill_sb = orangefs_kill_sb, | |
274dcf55 MM |
49 | .owner = THIS_MODULE, |
50 | }; | |
51 | ||
52 | module_param(hash_table_size, int, 0); | |
cb987f3c | 53 | module_param(module_parm_debug_mask, ulong, 0644); |
274dcf55 MM |
54 | module_param(op_timeout_secs, int, 0); |
55 | module_param(slot_timeout_secs, int, 0); | |
56 | ||
274dcf55 | 57 | /* |
54804949 MM |
58 | * Blocks non-priority requests from being queued for servicing. This |
59 | * could be used for protecting the request list data structure, but | |
60 | * for now it's only being used to stall the op addition to the request | |
61 | * list | |
62 | */ | |
1d503617 | 63 | DEFINE_MUTEX(orangefs_request_mutex); |
274dcf55 MM |
64 | |
65 | /* hash table for storing operations waiting for matching downcall */ | |
1d503617 MB |
66 | struct list_head *orangefs_htable_ops_in_progress; |
67 | DEFINE_SPINLOCK(orangefs_htable_ops_in_progress_lock); | |
274dcf55 MM |
68 | |
69 | /* list for queueing upcall operations */ | |
8bb8aefd | 70 | LIST_HEAD(orangefs_request_list); |
274dcf55 | 71 | |
8bb8aefd YL |
72 | /* used to protect the above orangefs_request_list */ |
73 | DEFINE_SPINLOCK(orangefs_request_list_lock); | |
274dcf55 MM |
74 | |
75 | /* used for incoming request notification */ | |
8bb8aefd | 76 | DECLARE_WAIT_QUEUE_HEAD(orangefs_request_list_waitq); |
274dcf55 | 77 | |
8bb8aefd | 78 | static int __init orangefs_init(void) |
274dcf55 MM |
79 | { |
80 | int ret = -1; | |
81 | __u32 i = 0; | |
82 | ||
8bb8aefd | 83 | ret = bdi_init(&orangefs_backing_dev_info); |
274dcf55 MM |
84 | |
85 | if (ret) | |
86 | return ret; | |
87 | ||
88 | if (op_timeout_secs < 0) | |
89 | op_timeout_secs = 0; | |
90 | ||
91 | if (slot_timeout_secs < 0) | |
92 | slot_timeout_secs = 0; | |
93 | ||
94 | /* initialize global book keeping data structures */ | |
95 | ret = op_cache_initialize(); | |
96 | if (ret < 0) | |
97 | goto err; | |
98 | ||
8bb8aefd | 99 | ret = orangefs_inode_cache_initialize(); |
274dcf55 | 100 | if (ret < 0) |
2d4cae0d | 101 | goto cleanup_op; |
274dcf55 | 102 | |
1d503617 | 103 | orangefs_htable_ops_in_progress = |
274dcf55 | 104 | kcalloc(hash_table_size, sizeof(struct list_head), GFP_KERNEL); |
1d503617 | 105 | if (!orangefs_htable_ops_in_progress) { |
274dcf55 MM |
106 | gossip_err("Failed to initialize op hashtable"); |
107 | ret = -ENOMEM; | |
2f83ace3 | 108 | goto cleanup_inode; |
274dcf55 MM |
109 | } |
110 | ||
111 | /* initialize a doubly linked at each hash table index */ | |
112 | for (i = 0; i < hash_table_size; i++) | |
1d503617 | 113 | INIT_LIST_HEAD(&orangefs_htable_ops_in_progress[i]); |
274dcf55 MM |
114 | |
115 | ret = fsid_key_table_initialize(); | |
116 | if (ret < 0) | |
117 | goto cleanup_progress_table; | |
118 | ||
119 | /* | |
120 | * Build the contents of /sys/kernel/debug/orangefs/debug-help | |
121 | * from the keywords in the kernel keyword/mask array. | |
122 | * | |
123 | * The keywords in the client keyword/mask array are | |
124 | * unknown at boot time. | |
125 | * | |
126 | * orangefs_prepare_debugfs_help_string will be used again | |
dc033621 | 127 | * later to rebuild the debug-help-string after the client starts |
274dcf55 MM |
128 | * and passes along the needed info. The argument signifies |
129 | * which time orangefs_prepare_debugfs_help_string is being | |
130 | * called. | |
274dcf55 MM |
131 | */ |
132 | ret = orangefs_prepare_debugfs_help_string(1); | |
133 | if (ret) | |
1a0ce16d | 134 | goto cleanup_key_table; |
2180c52c | 135 | |
44f46410 | 136 | ret = orangefs_debugfs_init(module_parm_debug_mask); |
2180c52c MM |
137 | if (ret) |
138 | goto debugfs_init_failed; | |
274dcf55 | 139 | |
2180c52c MM |
140 | ret = orangefs_sysfs_init(); |
141 | if (ret) | |
142 | goto sysfs_init_failed; | |
274dcf55 | 143 | |
2f83ace3 MB |
144 | /* Initialize the orangefsdev subsystem. */ |
145 | ret = orangefs_dev_init(); | |
146 | if (ret < 0) { | |
147 | gossip_err("%s: could not initialize device subsystem %d!\n", | |
148 | __func__, | |
149 | ret); | |
150 | goto cleanup_device; | |
151 | } | |
152 | ||
8bb8aefd | 153 | ret = register_filesystem(&orangefs_fs_type); |
274dcf55 | 154 | if (ret == 0) { |
dc033621 MM |
155 | pr_info("%s: module version %s loaded\n", |
156 | __func__, | |
157 | ORANGEFS_VERSION); | |
2180c52c MM |
158 | ret = 0; |
159 | goto out; | |
274dcf55 MM |
160 | } |
161 | ||
274dcf55 | 162 | orangefs_sysfs_exit(); |
274dcf55 | 163 | |
2f83ace3 MB |
164 | cleanup_device: |
165 | orangefs_dev_cleanup(); | |
166 | ||
2180c52c MM |
167 | sysfs_init_failed: |
168 | ||
2180c52c MM |
169 | debugfs_init_failed: |
170 | orangefs_debugfs_cleanup(); | |
171 | ||
1a0ce16d MM |
172 | cleanup_key_table: |
173 | fsid_key_table_finalize(); | |
2180c52c | 174 | |
274dcf55 | 175 | cleanup_progress_table: |
1d503617 | 176 | kfree(orangefs_htable_ops_in_progress); |
274dcf55 | 177 | |
274dcf55 | 178 | cleanup_inode: |
8bb8aefd | 179 | orangefs_inode_cache_finalize(); |
274dcf55 | 180 | |
274dcf55 MM |
181 | cleanup_op: |
182 | op_cache_finalize(); | |
183 | ||
184 | err: | |
8bb8aefd | 185 | bdi_destroy(&orangefs_backing_dev_info); |
274dcf55 MM |
186 | |
187 | out: | |
188 | return ret; | |
189 | } | |
190 | ||
8bb8aefd | 191 | static void __exit orangefs_exit(void) |
274dcf55 MM |
192 | { |
193 | int i = 0; | |
8bb8aefd | 194 | gossip_debug(GOSSIP_INIT_DEBUG, "orangefs: orangefs_exit called\n"); |
274dcf55 | 195 | |
8bb8aefd YL |
196 | unregister_filesystem(&orangefs_fs_type); |
197 | orangefs_debugfs_cleanup(); | |
274dcf55 MM |
198 | orangefs_sysfs_exit(); |
199 | fsid_key_table_finalize(); | |
8bb8aefd | 200 | orangefs_dev_cleanup(); |
96acf9d6 | 201 | BUG_ON(!list_empty(&orangefs_request_list)); |
274dcf55 | 202 | for (i = 0; i < hash_table_size; i++) |
1d503617 | 203 | BUG_ON(!list_empty(&orangefs_htable_ops_in_progress[i])); |
274dcf55 | 204 | |
8bb8aefd | 205 | orangefs_inode_cache_finalize(); |
274dcf55 MM |
206 | op_cache_finalize(); |
207 | ||
1d503617 | 208 | kfree(orangefs_htable_ops_in_progress); |
274dcf55 | 209 | |
8bb8aefd | 210 | bdi_destroy(&orangefs_backing_dev_info); |
274dcf55 | 211 | |
8bb8aefd | 212 | pr_info("orangefs: module version %s unloaded\n", ORANGEFS_VERSION); |
274dcf55 MM |
213 | } |
214 | ||
215 | /* | |
216 | * What we do in this function is to walk the list of operations | |
217 | * that are in progress in the hash table and mark them as purged as well. | |
218 | */ | |
219 | void purge_inprogress_ops(void) | |
220 | { | |
221 | int i; | |
222 | ||
223 | for (i = 0; i < hash_table_size; i++) { | |
8bb8aefd YL |
224 | struct orangefs_kernel_op_s *op; |
225 | struct orangefs_kernel_op_s *next; | |
274dcf55 | 226 | |
1d503617 | 227 | spin_lock(&orangefs_htable_ops_in_progress_lock); |
274dcf55 MM |
228 | list_for_each_entry_safe(op, |
229 | next, | |
1d503617 | 230 | &orangefs_htable_ops_in_progress[i], |
274dcf55 | 231 | list) { |
274dcf55 | 232 | set_op_state_purged(op); |
9d9e7ba9 MM |
233 | gossip_debug(GOSSIP_DEV_DEBUG, |
234 | "%s: op:%s: op_state:%d: process:%s:\n", | |
235 | __func__, | |
236 | get_opname_string(op), | |
237 | op->op_state, | |
238 | current->comm); | |
274dcf55 | 239 | } |
1d503617 | 240 | spin_unlock(&orangefs_htable_ops_in_progress_lock); |
274dcf55 MM |
241 | } |
242 | } | |
243 | ||
8bb8aefd YL |
244 | module_init(orangefs_init); |
245 | module_exit(orangefs_exit); |