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