1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * (C) 2001 Clemson University and The University of Chicago
4  *
5  * See COPYING in top-level directory.
6  */
7 
8 #include "protocol.h"
9 #include "orangefs-kernel.h"
10 #include "orangefs-bufmap.h"
11 
12 #include <linux/parser.h>
13 
14 /* a cache for orangefs-inode objects (i.e. orangefs inode private data) */
15 static struct kmem_cache *orangefs_inode_cache;
16 
17 /* list for storing orangefs specific superblocks in use */
18 LIST_HEAD(orangefs_superblocks);
19 
20 DEFINE_SPINLOCK(orangefs_superblocks_lock);
21 
22 enum {
23 	Opt_intr,
24 	Opt_acl,
25 	Opt_local_lock,
26 
27 	Opt_err
28 };
29 
30 static const match_table_t tokens = {
31 	{ Opt_acl,		"acl" },
32 	{ Opt_intr,		"intr" },
33 	{ Opt_local_lock,	"local_lock" },
34 	{ Opt_err,	NULL }
35 };
36 
37 uint64_t orangefs_features;
38 
orangefs_show_options(struct seq_file * m,struct dentry * root)39 static int orangefs_show_options(struct seq_file *m, struct dentry *root)
40 {
41 	struct orangefs_sb_info_s *orangefs_sb = ORANGEFS_SB(root->d_sb);
42 
43 	if (root->d_sb->s_flags & SB_POSIXACL)
44 		seq_puts(m, ",acl");
45 	if (orangefs_sb->flags & ORANGEFS_OPT_INTR)
46 		seq_puts(m, ",intr");
47 	if (orangefs_sb->flags & ORANGEFS_OPT_LOCAL_LOCK)
48 		seq_puts(m, ",local_lock");
49 	return 0;
50 }
51 
parse_mount_options(struct super_block * sb,char * options,int silent)52 static int parse_mount_options(struct super_block *sb, char *options,
53 		int silent)
54 {
55 	struct orangefs_sb_info_s *orangefs_sb = ORANGEFS_SB(sb);
56 	substring_t args[MAX_OPT_ARGS];
57 	char *p;
58 
59 	/*
60 	 * Force any potential flags that might be set from the mount
61 	 * to zero, ie, initialize to unset.
62 	 */
63 	sb->s_flags &= ~SB_POSIXACL;
64 	orangefs_sb->flags &= ~ORANGEFS_OPT_INTR;
65 	orangefs_sb->flags &= ~ORANGEFS_OPT_LOCAL_LOCK;
66 
67 	while ((p = strsep(&options, ",")) != NULL) {
68 		int token;
69 
70 		if (!*p)
71 			continue;
72 
73 		token = match_token(p, tokens, args);
74 		switch (token) {
75 		case Opt_acl:
76 			sb->s_flags |= SB_POSIXACL;
77 			break;
78 		case Opt_intr:
79 			orangefs_sb->flags |= ORANGEFS_OPT_INTR;
80 			break;
81 		case Opt_local_lock:
82 			orangefs_sb->flags |= ORANGEFS_OPT_LOCAL_LOCK;
83 			break;
84 		default:
85 			goto fail;
86 		}
87 	}
88 
89 	return 0;
90 fail:
91 	if (!silent)
92 		gossip_err("Error: mount option [%s] is not supported.\n", p);
93 	return -EINVAL;
94 }
95 
orangefs_inode_cache_ctor(void * req)96 static void orangefs_inode_cache_ctor(void *req)
97 {
98 	struct orangefs_inode_s *orangefs_inode = req;
99 
100 	inode_init_once(&orangefs_inode->vfs_inode);
101 	init_rwsem(&orangefs_inode->xattr_sem);
102 }
103 
orangefs_alloc_inode(struct super_block * sb)104 static struct inode *orangefs_alloc_inode(struct super_block *sb)
105 {
106 	struct orangefs_inode_s *orangefs_inode;
107 
108 	orangefs_inode = kmem_cache_alloc(orangefs_inode_cache, GFP_KERNEL);
109 	if (!orangefs_inode)
110 		return NULL;
111 
112 	/*
113 	 * We want to clear everything except for rw_semaphore and the
114 	 * vfs_inode.
115 	 */
116 	memset(&orangefs_inode->refn.khandle, 0, 16);
117 	orangefs_inode->refn.fs_id = ORANGEFS_FS_ID_NULL;
118 	orangefs_inode->last_failed_block_index_read = 0;
119 	memset(orangefs_inode->link_target, 0, sizeof(orangefs_inode->link_target));
120 
121 	gossip_debug(GOSSIP_SUPER_DEBUG,
122 		     "orangefs_alloc_inode: allocated %p\n",
123 		     &orangefs_inode->vfs_inode);
124 	return &orangefs_inode->vfs_inode;
125 }
126 
orangefs_i_callback(struct rcu_head * head)127 static void orangefs_i_callback(struct rcu_head *head)
128 {
129 	struct inode *inode = container_of(head, struct inode, i_rcu);
130 	struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
131 	kmem_cache_free(orangefs_inode_cache, orangefs_inode);
132 }
133 
orangefs_destroy_inode(struct inode * inode)134 static void orangefs_destroy_inode(struct inode *inode)
135 {
136 	struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode);
137 
138 	gossip_debug(GOSSIP_SUPER_DEBUG,
139 			"%s: deallocated %p destroying inode %pU\n",
140 			__func__, orangefs_inode, get_khandle_from_ino(inode));
141 
142 	call_rcu(&inode->i_rcu, orangefs_i_callback);
143 }
144 
145 /*
146  * NOTE: information filled in here is typically reflected in the
147  * output of the system command 'df'
148 */
orangefs_statfs(struct dentry * dentry,struct kstatfs * buf)149 static int orangefs_statfs(struct dentry *dentry, struct kstatfs *buf)
150 {
151 	int ret = -ENOMEM;
152 	struct orangefs_kernel_op_s *new_op = NULL;
153 	int flags = 0;
154 	struct super_block *sb = NULL;
155 
156 	sb = dentry->d_sb;
157 
158 	gossip_debug(GOSSIP_SUPER_DEBUG,
159 			"%s: called on sb %p (fs_id is %d)\n",
160 			__func__,
161 			sb,
162 			(int)(ORANGEFS_SB(sb)->fs_id));
163 
164 	new_op = op_alloc(ORANGEFS_VFS_OP_STATFS);
165 	if (!new_op)
166 		return ret;
167 	new_op->upcall.req.statfs.fs_id = ORANGEFS_SB(sb)->fs_id;
168 
169 	if (ORANGEFS_SB(sb)->flags & ORANGEFS_OPT_INTR)
170 		flags = ORANGEFS_OP_INTERRUPTIBLE;
171 
172 	ret = service_operation(new_op, "orangefs_statfs", flags);
173 
174 	if (new_op->downcall.status < 0)
175 		goto out_op_release;
176 
177 	gossip_debug(GOSSIP_SUPER_DEBUG,
178 		     "%s: got %ld blocks available | "
179 		     "%ld blocks total | %ld block size | "
180 		     "%ld files total | %ld files avail\n",
181 		     __func__,
182 		     (long)new_op->downcall.resp.statfs.blocks_avail,
183 		     (long)new_op->downcall.resp.statfs.blocks_total,
184 		     (long)new_op->downcall.resp.statfs.block_size,
185 		     (long)new_op->downcall.resp.statfs.files_total,
186 		     (long)new_op->downcall.resp.statfs.files_avail);
187 
188 	buf->f_type = sb->s_magic;
189 	memcpy(&buf->f_fsid, &ORANGEFS_SB(sb)->fs_id, sizeof(buf->f_fsid));
190 	buf->f_bsize = new_op->downcall.resp.statfs.block_size;
191 	buf->f_namelen = ORANGEFS_NAME_MAX;
192 
193 	buf->f_blocks = (sector_t) new_op->downcall.resp.statfs.blocks_total;
194 	buf->f_bfree = (sector_t) new_op->downcall.resp.statfs.blocks_avail;
195 	buf->f_bavail = (sector_t) new_op->downcall.resp.statfs.blocks_avail;
196 	buf->f_files = (sector_t) new_op->downcall.resp.statfs.files_total;
197 	buf->f_ffree = (sector_t) new_op->downcall.resp.statfs.files_avail;
198 	buf->f_frsize = 0;
199 
200 out_op_release:
201 	op_release(new_op);
202 	gossip_debug(GOSSIP_SUPER_DEBUG, "%s: returning %d\n", __func__, ret);
203 	return ret;
204 }
205 
206 /*
207  * Remount as initiated by VFS layer.  We just need to reparse the mount
208  * options, no need to signal pvfs2-client-core about it.
209  */
orangefs_remount_fs(struct super_block * sb,int * flags,char * data)210 static int orangefs_remount_fs(struct super_block *sb, int *flags, char *data)
211 {
212 	gossip_debug(GOSSIP_SUPER_DEBUG, "orangefs_remount_fs: called\n");
213 	return parse_mount_options(sb, data, 1);
214 }
215 
216 /*
217  * Remount as initiated by pvfs2-client-core on restart.  This is used to
218  * repopulate mount information left from previous pvfs2-client-core.
219  *
220  * the idea here is that given a valid superblock, we're
221  * re-initializing the user space client with the initial mount
222  * information specified when the super block was first initialized.
223  * this is very different than the first initialization/creation of a
224  * superblock.  we use the special service_priority_operation to make
225  * sure that the mount gets ahead of any other pending operation that
226  * is waiting for servicing.  this means that the pvfs2-client won't
227  * fail to start several times for all other pending operations before
228  * the client regains all of the mount information from us.
229  * NOTE: this function assumes that the request_mutex is already acquired!
230  */
orangefs_remount(struct orangefs_sb_info_s * orangefs_sb)231 int orangefs_remount(struct orangefs_sb_info_s *orangefs_sb)
232 {
233 	struct orangefs_kernel_op_s *new_op;
234 	int ret = -EINVAL;
235 
236 	gossip_debug(GOSSIP_SUPER_DEBUG, "orangefs_remount: called\n");
237 
238 	new_op = op_alloc(ORANGEFS_VFS_OP_FS_MOUNT);
239 	if (!new_op)
240 		return -ENOMEM;
241 	strncpy(new_op->upcall.req.fs_mount.orangefs_config_server,
242 		orangefs_sb->devname,
243 		ORANGEFS_MAX_SERVER_ADDR_LEN);
244 
245 	gossip_debug(GOSSIP_SUPER_DEBUG,
246 		     "Attempting ORANGEFS Remount via host %s\n",
247 		     new_op->upcall.req.fs_mount.orangefs_config_server);
248 
249 	/*
250 	 * we assume that the calling function has already acquired the
251 	 * request_mutex to prevent other operations from bypassing
252 	 * this one
253 	 */
254 	ret = service_operation(new_op, "orangefs_remount",
255 		ORANGEFS_OP_PRIORITY | ORANGEFS_OP_NO_MUTEX);
256 	gossip_debug(GOSSIP_SUPER_DEBUG,
257 		     "orangefs_remount: mount got return value of %d\n",
258 		     ret);
259 	if (ret == 0) {
260 		/*
261 		 * store the id assigned to this sb -- it's just a
262 		 * short-lived mapping that the system interface uses
263 		 * to map this superblock to a particular mount entry
264 		 */
265 		orangefs_sb->id = new_op->downcall.resp.fs_mount.id;
266 		orangefs_sb->mount_pending = 0;
267 	}
268 
269 	op_release(new_op);
270 
271 	if (orangefs_userspace_version >= 20906) {
272 		new_op = op_alloc(ORANGEFS_VFS_OP_FEATURES);
273 		if (!new_op)
274 			return -ENOMEM;
275 		new_op->upcall.req.features.features = 0;
276 		ret = service_operation(new_op, "orangefs_features",
277 		    ORANGEFS_OP_PRIORITY | ORANGEFS_OP_NO_MUTEX);
278 		if (!ret)
279 			orangefs_features =
280 			    new_op->downcall.resp.features.features;
281 		else
282 			orangefs_features = 0;
283 		op_release(new_op);
284 	} else {
285 		orangefs_features = 0;
286 	}
287 
288 	return ret;
289 }
290 
fsid_key_table_initialize(void)291 int fsid_key_table_initialize(void)
292 {
293 	return 0;
294 }
295 
fsid_key_table_finalize(void)296 void fsid_key_table_finalize(void)
297 {
298 }
299 
300 static const struct super_operations orangefs_s_ops = {
301 	.alloc_inode = orangefs_alloc_inode,
302 	.destroy_inode = orangefs_destroy_inode,
303 	.drop_inode = generic_delete_inode,
304 	.statfs = orangefs_statfs,
305 	.remount_fs = orangefs_remount_fs,
306 	.show_options = orangefs_show_options,
307 };
308 
orangefs_fh_to_dentry(struct super_block * sb,struct fid * fid,int fh_len,int fh_type)309 static struct dentry *orangefs_fh_to_dentry(struct super_block *sb,
310 				  struct fid *fid,
311 				  int fh_len,
312 				  int fh_type)
313 {
314 	struct orangefs_object_kref refn;
315 
316 	if (fh_len < 5 || fh_type > 2)
317 		return NULL;
318 
319 	ORANGEFS_khandle_from(&(refn.khandle), fid->raw, 16);
320 	refn.fs_id = (u32) fid->raw[4];
321 	gossip_debug(GOSSIP_SUPER_DEBUG,
322 		     "fh_to_dentry: handle %pU, fs_id %d\n",
323 		     &refn.khandle,
324 		     refn.fs_id);
325 
326 	return d_obtain_alias(orangefs_iget(sb, &refn));
327 }
328 
orangefs_encode_fh(struct inode * inode,__u32 * fh,int * max_len,struct inode * parent)329 static int orangefs_encode_fh(struct inode *inode,
330 		    __u32 *fh,
331 		    int *max_len,
332 		    struct inode *parent)
333 {
334 	int len = parent ? 10 : 5;
335 	int type = 1;
336 	struct orangefs_object_kref refn;
337 
338 	if (*max_len < len) {
339 		gossip_err("fh buffer is too small for encoding\n");
340 		*max_len = len;
341 		type = 255;
342 		goto out;
343 	}
344 
345 	refn = ORANGEFS_I(inode)->refn;
346 	ORANGEFS_khandle_to(&refn.khandle, fh, 16);
347 	fh[4] = refn.fs_id;
348 
349 	gossip_debug(GOSSIP_SUPER_DEBUG,
350 		     "Encoding fh: handle %pU, fsid %u\n",
351 		     &refn.khandle,
352 		     refn.fs_id);
353 
354 
355 	if (parent) {
356 		refn = ORANGEFS_I(parent)->refn;
357 		ORANGEFS_khandle_to(&refn.khandle, (char *) fh + 20, 16);
358 		fh[9] = refn.fs_id;
359 
360 		type = 2;
361 		gossip_debug(GOSSIP_SUPER_DEBUG,
362 			     "Encoding parent: handle %pU, fsid %u\n",
363 			     &refn.khandle,
364 			     refn.fs_id);
365 	}
366 	*max_len = len;
367 
368 out:
369 	return type;
370 }
371 
372 static const struct export_operations orangefs_export_ops = {
373 	.encode_fh = orangefs_encode_fh,
374 	.fh_to_dentry = orangefs_fh_to_dentry,
375 };
376 
orangefs_unmount(int id,__s32 fs_id,const char * devname)377 static int orangefs_unmount(int id, __s32 fs_id, const char *devname)
378 {
379 	struct orangefs_kernel_op_s *op;
380 	int r;
381 	op = op_alloc(ORANGEFS_VFS_OP_FS_UMOUNT);
382 	if (!op)
383 		return -ENOMEM;
384 	op->upcall.req.fs_umount.id = id;
385 	op->upcall.req.fs_umount.fs_id = fs_id;
386 	strncpy(op->upcall.req.fs_umount.orangefs_config_server,
387 	    devname, ORANGEFS_MAX_SERVER_ADDR_LEN - 1);
388 	r = service_operation(op, "orangefs_fs_umount", 0);
389 	/* Not much to do about an error here. */
390 	if (r)
391 		gossip_err("orangefs_unmount: service_operation %d\n", r);
392 	op_release(op);
393 	return r;
394 }
395 
orangefs_fill_sb(struct super_block * sb,struct orangefs_fs_mount_response * fs_mount,void * data,int silent)396 static int orangefs_fill_sb(struct super_block *sb,
397 		struct orangefs_fs_mount_response *fs_mount,
398 		void *data, int silent)
399 {
400 	int ret = -EINVAL;
401 	struct inode *root = NULL;
402 	struct dentry *root_dentry = NULL;
403 	struct orangefs_object_kref root_object;
404 
405 	/* alloc and init our private orangefs sb info */
406 	sb->s_fs_info = kzalloc(sizeof(struct orangefs_sb_info_s), GFP_KERNEL);
407 	if (!ORANGEFS_SB(sb))
408 		return -ENOMEM;
409 	ORANGEFS_SB(sb)->sb = sb;
410 
411 	ORANGEFS_SB(sb)->root_khandle = fs_mount->root_khandle;
412 	ORANGEFS_SB(sb)->fs_id = fs_mount->fs_id;
413 	ORANGEFS_SB(sb)->id = fs_mount->id;
414 
415 	if (data) {
416 		ret = parse_mount_options(sb, data, silent);
417 		if (ret)
418 			return ret;
419 	}
420 
421 	/* Hang the xattr handlers off the superblock */
422 	sb->s_xattr = orangefs_xattr_handlers;
423 	sb->s_magic = ORANGEFS_SUPER_MAGIC;
424 	sb->s_op = &orangefs_s_ops;
425 	sb->s_d_op = &orangefs_dentry_operations;
426 
427 	sb->s_blocksize = PAGE_SIZE;
428 	sb->s_blocksize_bits = PAGE_SHIFT;
429 	sb->s_maxbytes = MAX_LFS_FILESIZE;
430 
431 	root_object.khandle = ORANGEFS_SB(sb)->root_khandle;
432 	root_object.fs_id = ORANGEFS_SB(sb)->fs_id;
433 	gossip_debug(GOSSIP_SUPER_DEBUG,
434 		     "get inode %pU, fsid %d\n",
435 		     &root_object.khandle,
436 		     root_object.fs_id);
437 
438 	root = orangefs_iget(sb, &root_object);
439 	if (IS_ERR(root))
440 		return PTR_ERR(root);
441 
442 	gossip_debug(GOSSIP_SUPER_DEBUG,
443 		     "Allocated root inode [%p] with mode %x\n",
444 		     root,
445 		     root->i_mode);
446 
447 	/* allocates and places root dentry in dcache */
448 	root_dentry = d_make_root(root);
449 	if (!root_dentry)
450 		return -ENOMEM;
451 
452 	sb->s_export_op = &orangefs_export_ops;
453 	sb->s_root = root_dentry;
454 	return 0;
455 }
456 
orangefs_mount(struct file_system_type * fst,int flags,const char * devname,void * data)457 struct dentry *orangefs_mount(struct file_system_type *fst,
458 			   int flags,
459 			   const char *devname,
460 			   void *data)
461 {
462 	int ret = -EINVAL;
463 	struct super_block *sb = ERR_PTR(-EINVAL);
464 	struct orangefs_kernel_op_s *new_op;
465 	struct dentry *d = ERR_PTR(-EINVAL);
466 
467 	gossip_debug(GOSSIP_SUPER_DEBUG,
468 		     "orangefs_mount: called with devname %s\n",
469 		     devname);
470 
471 	if (!devname) {
472 		gossip_err("ERROR: device name not specified.\n");
473 		return ERR_PTR(-EINVAL);
474 	}
475 
476 	new_op = op_alloc(ORANGEFS_VFS_OP_FS_MOUNT);
477 	if (!new_op)
478 		return ERR_PTR(-ENOMEM);
479 
480 	strncpy(new_op->upcall.req.fs_mount.orangefs_config_server,
481 		devname,
482 		ORANGEFS_MAX_SERVER_ADDR_LEN - 1);
483 
484 	gossip_debug(GOSSIP_SUPER_DEBUG,
485 		     "Attempting ORANGEFS Mount via host %s\n",
486 		     new_op->upcall.req.fs_mount.orangefs_config_server);
487 
488 	ret = service_operation(new_op, "orangefs_mount", 0);
489 	gossip_debug(GOSSIP_SUPER_DEBUG,
490 		     "orangefs_mount: mount got return value of %d\n", ret);
491 	if (ret)
492 		goto free_op;
493 
494 	if (new_op->downcall.resp.fs_mount.fs_id == ORANGEFS_FS_ID_NULL) {
495 		gossip_err("ERROR: Retrieved null fs_id\n");
496 		ret = -EINVAL;
497 		goto free_op;
498 	}
499 
500 	sb = sget(fst, NULL, set_anon_super, flags, NULL);
501 
502 	if (IS_ERR(sb)) {
503 		d = ERR_CAST(sb);
504 		orangefs_unmount(new_op->downcall.resp.fs_mount.id,
505 		    new_op->downcall.resp.fs_mount.fs_id, devname);
506 		goto free_op;
507 	}
508 
509 	ret = orangefs_fill_sb(sb,
510 	      &new_op->downcall.resp.fs_mount, data,
511 	      flags & SB_SILENT ? 1 : 0);
512 
513 	if (ret) {
514 		d = ERR_PTR(ret);
515 		goto free_sb_and_op;
516 	}
517 
518 	/*
519 	 * on successful mount, store the devname and data
520 	 * used
521 	 */
522 	strncpy(ORANGEFS_SB(sb)->devname,
523 		devname,
524 		ORANGEFS_MAX_SERVER_ADDR_LEN - 1);
525 
526 	/* mount_pending must be cleared */
527 	ORANGEFS_SB(sb)->mount_pending = 0;
528 
529 	/*
530 	 * finally, add this sb to our list of known orangefs
531 	 * sb's
532 	 */
533 	gossip_debug(GOSSIP_SUPER_DEBUG,
534 		     "Adding SB %p to orangefs superblocks\n",
535 		     ORANGEFS_SB(sb));
536 	spin_lock(&orangefs_superblocks_lock);
537 	list_add_tail(&ORANGEFS_SB(sb)->list, &orangefs_superblocks);
538 	spin_unlock(&orangefs_superblocks_lock);
539 	op_release(new_op);
540 
541 	/* Must be removed from the list now. */
542 	ORANGEFS_SB(sb)->no_list = 0;
543 
544 	if (orangefs_userspace_version >= 20906) {
545 		new_op = op_alloc(ORANGEFS_VFS_OP_FEATURES);
546 		if (!new_op)
547 			return ERR_PTR(-ENOMEM);
548 		new_op->upcall.req.features.features = 0;
549 		ret = service_operation(new_op, "orangefs_features", 0);
550 		orangefs_features = new_op->downcall.resp.features.features;
551 		op_release(new_op);
552 	} else {
553 		orangefs_features = 0;
554 	}
555 
556 	return dget(sb->s_root);
557 
558 free_sb_and_op:
559 	/* Will call orangefs_kill_sb with sb not in list. */
560 	ORANGEFS_SB(sb)->no_list = 1;
561 	/* ORANGEFS_VFS_OP_FS_UMOUNT is done by orangefs_kill_sb. */
562 	deactivate_locked_super(sb);
563 free_op:
564 	gossip_err("orangefs_mount: mount request failed with %d\n", ret);
565 	if (ret == -EINVAL) {
566 		gossip_err("Ensure that all orangefs-servers have the same FS configuration files\n");
567 		gossip_err("Look at pvfs2-client-core log file (typically /tmp/pvfs2-client.log) for more details\n");
568 	}
569 
570 	op_release(new_op);
571 
572 	return d;
573 }
574 
orangefs_kill_sb(struct super_block * sb)575 void orangefs_kill_sb(struct super_block *sb)
576 {
577 	int r;
578 	gossip_debug(GOSSIP_SUPER_DEBUG, "orangefs_kill_sb: called\n");
579 
580 	/* provided sb cleanup */
581 	kill_anon_super(sb);
582 
583 	if (!ORANGEFS_SB(sb)) {
584 		mutex_lock(&orangefs_request_mutex);
585 		mutex_unlock(&orangefs_request_mutex);
586 		return;
587 	}
588 	/*
589 	 * issue the unmount to userspace to tell it to remove the
590 	 * dynamic mount info it has for this superblock
591 	 */
592 	r = orangefs_unmount(ORANGEFS_SB(sb)->id, ORANGEFS_SB(sb)->fs_id,
593 	    ORANGEFS_SB(sb)->devname);
594 	if (!r)
595 		ORANGEFS_SB(sb)->mount_pending = 1;
596 
597 	if (!ORANGEFS_SB(sb)->no_list) {
598 		/* remove the sb from our list of orangefs specific sb's */
599 		spin_lock(&orangefs_superblocks_lock);
600 		/* not list_del_init */
601 		__list_del_entry(&ORANGEFS_SB(sb)->list);
602 		ORANGEFS_SB(sb)->list.prev = NULL;
603 		spin_unlock(&orangefs_superblocks_lock);
604 	}
605 
606 	/*
607 	 * make sure that ORANGEFS_DEV_REMOUNT_ALL loop that might've seen us
608 	 * gets completed before we free the dang thing.
609 	 */
610 	mutex_lock(&orangefs_request_mutex);
611 	mutex_unlock(&orangefs_request_mutex);
612 
613 	/* free the orangefs superblock private data */
614 	kfree(ORANGEFS_SB(sb));
615 }
616 
orangefs_inode_cache_initialize(void)617 int orangefs_inode_cache_initialize(void)
618 {
619 	orangefs_inode_cache = kmem_cache_create_usercopy(
620 					"orangefs_inode_cache",
621 					sizeof(struct orangefs_inode_s),
622 					0,
623 					ORANGEFS_CACHE_CREATE_FLAGS,
624 					offsetof(struct orangefs_inode_s,
625 						link_target),
626 					sizeof_field(struct orangefs_inode_s,
627 						link_target),
628 					orangefs_inode_cache_ctor);
629 
630 	if (!orangefs_inode_cache) {
631 		gossip_err("Cannot create orangefs_inode_cache\n");
632 		return -ENOMEM;
633 	}
634 	return 0;
635 }
636 
orangefs_inode_cache_finalize(void)637 int orangefs_inode_cache_finalize(void)
638 {
639 	kmem_cache_destroy(orangefs_inode_cache);
640 	return 0;
641 }
642