4 * Copyright (C) 1995, 1996 by Paal-Kr. Engstad and Volker Lendecke
5 * Copyright (C) 1997 by Volker Lendecke
7 * Please add a note about your changes to smbfs in the ChangeLog file.
10 #include <linux/module.h>
11 #include <linux/time.h>
12 #include <linux/kernel.h>
14 #include <linux/string.h>
15 #include <linux/stat.h>
16 #include <linux/errno.h>
17 #include <linux/slab.h>
18 #include <linux/init.h>
19 #include <linux/file.h>
20 #include <linux/dcache.h>
21 #include <linux/smp_lock.h>
22 #include <linux/nls.h>
23 #include <linux/seq_file.h>
24 #include <linux/mount.h>
25 #include <linux/net.h>
26 #include <linux/vfs.h>
27 #include <linux/highuid.h>
28 #include <linux/sched.h>
29 #include <linux/smb_fs.h>
30 #include <linux/smbno.h>
31 #include <linux/smb_mount.h>
33 #include <asm/system.h>
34 #include <asm/uaccess.h>
36 #include "smb_debug.h"
40 /* Always pick a default string */
41 #ifdef CONFIG_SMB_NLS_REMOTE
42 #define SMB_NLS_REMOTE CONFIG_SMB_NLS_REMOTE
44 #define SMB_NLS_REMOTE ""
47 #define SMB_TTL_DEFAULT 1000
49 static void smb_evict_inode(struct inode
*);
50 static void smb_put_super(struct super_block
*);
51 static int smb_statfs(struct dentry
*, struct kstatfs
*);
52 static int smb_show_options(struct seq_file
*, struct vfsmount
*);
54 static struct kmem_cache
*smb_inode_cachep
;
56 static struct inode
*smb_alloc_inode(struct super_block
*sb
)
58 struct smb_inode_info
*ei
;
59 ei
= (struct smb_inode_info
*)kmem_cache_alloc(smb_inode_cachep
, GFP_KERNEL
);
62 return &ei
->vfs_inode
;
65 static void smb_destroy_inode(struct inode
*inode
)
67 kmem_cache_free(smb_inode_cachep
, SMB_I(inode
));
70 static void init_once(void *foo
)
72 struct smb_inode_info
*ei
= (struct smb_inode_info
*) foo
;
74 inode_init_once(&ei
->vfs_inode
);
77 static int init_inodecache(void)
79 smb_inode_cachep
= kmem_cache_create("smb_inode_cache",
80 sizeof(struct smb_inode_info
),
81 0, (SLAB_RECLAIM_ACCOUNT
|
84 if (smb_inode_cachep
== NULL
)
89 static void destroy_inodecache(void)
91 kmem_cache_destroy(smb_inode_cachep
);
94 static int smb_remount(struct super_block
*sb
, int *flags
, char *data
)
96 *flags
|= MS_NODIRATIME
;
100 static const struct super_operations smb_sops
=
102 .alloc_inode
= smb_alloc_inode
,
103 .destroy_inode
= smb_destroy_inode
,
104 .drop_inode
= generic_delete_inode
,
105 .evict_inode
= smb_evict_inode
,
106 .put_super
= smb_put_super
,
107 .statfs
= smb_statfs
,
108 .show_options
= smb_show_options
,
109 .remount_fs
= smb_remount
,
113 /* We are always generating a new inode here */
115 smb_iget(struct super_block
*sb
, struct smb_fattr
*fattr
)
117 struct smb_sb_info
*server
= SMB_SB(sb
);
118 struct inode
*result
;
120 DEBUG1("smb_iget: %p\n", fattr
);
122 result
= new_inode(sb
);
125 result
->i_ino
= fattr
->f_ino
;
126 SMB_I(result
)->open
= 0;
127 SMB_I(result
)->fileid
= 0;
128 SMB_I(result
)->access
= 0;
129 SMB_I(result
)->flags
= 0;
130 SMB_I(result
)->closed
= 0;
131 SMB_I(result
)->openers
= 0;
132 smb_set_inode_attr(result
, fattr
);
133 if (S_ISREG(result
->i_mode
)) {
134 result
->i_op
= &smb_file_inode_operations
;
135 result
->i_fop
= &smb_file_operations
;
136 result
->i_data
.a_ops
= &smb_file_aops
;
137 } else if (S_ISDIR(result
->i_mode
)) {
138 if (server
->opt
.capabilities
& SMB_CAP_UNIX
)
139 result
->i_op
= &smb_dir_inode_operations_unix
;
141 result
->i_op
= &smb_dir_inode_operations
;
142 result
->i_fop
= &smb_dir_operations
;
143 } else if (S_ISLNK(result
->i_mode
)) {
144 result
->i_op
= &smb_link_inode_operations
;
146 init_special_inode(result
, result
->i_mode
, fattr
->f_rdev
);
148 insert_inode_hash(result
);
153 * Copy the inode data to a smb_fattr structure.
156 smb_get_inode_attr(struct inode
*inode
, struct smb_fattr
*fattr
)
158 memset(fattr
, 0, sizeof(struct smb_fattr
));
159 fattr
->f_mode
= inode
->i_mode
;
160 fattr
->f_nlink
= inode
->i_nlink
;
161 fattr
->f_ino
= inode
->i_ino
;
162 fattr
->f_uid
= inode
->i_uid
;
163 fattr
->f_gid
= inode
->i_gid
;
164 fattr
->f_size
= inode
->i_size
;
165 fattr
->f_mtime
= inode
->i_mtime
;
166 fattr
->f_ctime
= inode
->i_ctime
;
167 fattr
->f_atime
= inode
->i_atime
;
168 fattr
->f_blocks
= inode
->i_blocks
;
170 fattr
->attr
= SMB_I(inode
)->attr
;
172 * Keep the attributes in sync with the inode permissions.
174 if (fattr
->f_mode
& S_IWUSR
)
175 fattr
->attr
&= ~aRONLY
;
177 fattr
->attr
|= aRONLY
;
181 * Update the inode, possibly causing it to invalidate its pages if mtime/size
182 * is different from last time.
185 smb_set_inode_attr(struct inode
*inode
, struct smb_fattr
*fattr
)
187 struct smb_inode_info
*ei
= SMB_I(inode
);
190 * A size change should have a different mtime, or same mtime
191 * but different size.
193 time_t last_time
= inode
->i_mtime
.tv_sec
;
194 loff_t last_sz
= inode
->i_size
;
196 inode
->i_mode
= fattr
->f_mode
;
197 inode
->i_nlink
= fattr
->f_nlink
;
198 inode
->i_uid
= fattr
->f_uid
;
199 inode
->i_gid
= fattr
->f_gid
;
200 inode
->i_ctime
= fattr
->f_ctime
;
201 inode
->i_blocks
= fattr
->f_blocks
;
202 inode
->i_size
= fattr
->f_size
;
203 inode
->i_mtime
= fattr
->f_mtime
;
204 inode
->i_atime
= fattr
->f_atime
;
205 ei
->attr
= fattr
->attr
;
208 * Update the "last time refreshed" field for revalidation.
210 ei
->oldmtime
= jiffies
;
212 if (inode
->i_mtime
.tv_sec
!= last_time
|| inode
->i_size
!= last_sz
) {
213 VERBOSE("%ld changed, old=%ld, new=%ld, oz=%ld, nz=%ld\n",
215 (long) last_time
, (long) inode
->i_mtime
.tv_sec
,
216 (long) last_sz
, (long) inode
->i_size
);
218 if (!S_ISDIR(inode
->i_mode
))
219 invalidate_remote_inode(inode
);
224 * This is called if the connection has gone bad ...
225 * try to kill off all the current inodes.
228 smb_invalidate_inodes(struct smb_sb_info
*server
)
231 shrink_dcache_sb(SB_of(server
));
232 invalidate_inodes(SB_of(server
));
236 * This is called to update the inode attributes after
237 * we've made changes to a file or directory.
240 smb_refresh_inode(struct dentry
*dentry
)
242 struct inode
*inode
= dentry
->d_inode
;
244 struct smb_fattr fattr
;
246 error
= smb_proc_getattr(dentry
, &fattr
);
248 smb_renew_times(dentry
);
250 * Check whether the type part of the mode changed,
251 * and don't update the attributes if it did.
253 * And don't dick with the root inode
255 if (inode
->i_ino
== 2)
257 if (S_ISLNK(inode
->i_mode
))
258 return error
; /* VFS will deal with it */
260 if ((inode
->i_mode
& S_IFMT
) == (fattr
.f_mode
& S_IFMT
)) {
261 smb_set_inode_attr(inode
, &fattr
);
264 * Big trouble! The inode has become a new object,
265 * so any operations attempted on it are invalid.
267 * To limit damage, mark the inode as bad so that
268 * subsequent lookup validations will fail.
270 PARANOIA("%s/%s changed mode, %07o to %07o\n",
272 inode
->i_mode
, fattr
.f_mode
);
274 fattr
.f_mode
= inode
->i_mode
; /* save mode */
275 make_bad_inode(inode
);
276 inode
->i_mode
= fattr
.f_mode
; /* restore mode */
278 * No need to worry about unhashing the dentry: the
279 * lookup validation will see that the inode is bad.
280 * But we do want to invalidate the caches ...
282 if (!S_ISDIR(inode
->i_mode
))
283 invalidate_remote_inode(inode
);
285 smb_invalid_dir_cache(inode
);
293 * This is called when we want to check whether the inode
294 * has changed on the server. If it has changed, we must
295 * invalidate our local caches.
298 smb_revalidate_inode(struct dentry
*dentry
)
300 struct smb_sb_info
*s
= server_from_dentry(dentry
);
301 struct inode
*inode
= dentry
->d_inode
;
304 DEBUG1("smb_revalidate_inode\n");
308 * Check whether we've recently refreshed the inode.
310 if (time_before(jiffies
, SMB_I(inode
)->oldmtime
+ SMB_MAX_AGE(s
))) {
311 VERBOSE("up-to-date, ino=%ld, jiffies=%lu, oldtime=%lu\n",
312 inode
->i_ino
, jiffies
, SMB_I(inode
)->oldmtime
);
316 error
= smb_refresh_inode(dentry
);
323 * This routine is called when i_nlink == 0 and i_count goes to 0.
324 * All blocking cleanup operations need to go here to avoid races.
327 smb_evict_inode(struct inode
*ino
)
329 DEBUG1("ino=%ld\n", ino
->i_ino
);
330 truncate_inode_pages(&ino
->i_data
, 0);
334 PARANOIA("could not close inode %ld\n", ino
->i_ino
);
338 static struct option opts
[] = {
339 { "version", 0, 'v' },
340 { "win95", SMB_MOUNT_WIN95
, 1 },
341 { "oldattr", SMB_MOUNT_OLDATTR
, 1 },
342 { "dirattr", SMB_MOUNT_DIRATTR
, 1 },
343 { "case", SMB_MOUNT_CASE
, 1 },
346 { "file_mode", 0, 'f' },
347 { "dir_mode", 0, 'd' },
348 { "iocharset", 0, 'i' },
349 { "codepage", 0, 'c' },
355 parse_options(struct smb_mount_data_kernel
*mnt
, char *options
)
364 while ( (c
= smb_getopt("smbfs", &options
, opts
,
365 &optopt
, &optarg
, &flags
, &value
)) > 0) {
367 VERBOSE("'%s' -> '%s'\n", optopt
, optarg
? optarg
: "<none>");
370 /* got a "flag" option */
373 if (value
!= SMB_MOUNT_VERSION
) {
374 printk ("smbfs: Bad mount version %ld, expected %d\n",
375 value
, SMB_MOUNT_VERSION
);
378 mnt
->version
= value
;
382 flags
|= SMB_MOUNT_UID
;
386 flags
|= SMB_MOUNT_GID
;
389 mnt
->file_mode
= (value
& S_IRWXUGO
) | S_IFREG
;
390 flags
|= SMB_MOUNT_FMODE
;
393 mnt
->dir_mode
= (value
& S_IRWXUGO
) | S_IFDIR
;
394 flags
|= SMB_MOUNT_DMODE
;
397 strlcpy(mnt
->codepage
.local_name
, optarg
,
401 strlcpy(mnt
->codepage
.remote_name
, optarg
,
408 printk ("smbfs: Unrecognized mount option %s\n",
418 * smb_show_options() is for displaying mount options in /proc/mounts.
419 * It tries to avoid showing settings that were not changed from their
423 smb_show_options(struct seq_file
*s
, struct vfsmount
*m
)
425 struct smb_mount_data_kernel
*mnt
= SMB_SB(m
->mnt_sb
)->mnt
;
428 for (i
= 0; opts
[i
].name
!= NULL
; i
++)
429 if (mnt
->flags
& opts
[i
].flag
)
430 seq_printf(s
, ",%s", opts
[i
].name
);
432 if (mnt
->flags
& SMB_MOUNT_UID
)
433 seq_printf(s
, ",uid=%d", mnt
->uid
);
434 if (mnt
->flags
& SMB_MOUNT_GID
)
435 seq_printf(s
, ",gid=%d", mnt
->gid
);
436 if (mnt
->mounted_uid
!= 0)
437 seq_printf(s
, ",mounted_uid=%d", mnt
->mounted_uid
);
440 * Defaults for file_mode and dir_mode are unknown to us; they
441 * depend on the current umask of the user doing the mount.
443 if (mnt
->flags
& SMB_MOUNT_FMODE
)
444 seq_printf(s
, ",file_mode=%04o", mnt
->file_mode
& S_IRWXUGO
);
445 if (mnt
->flags
& SMB_MOUNT_DMODE
)
446 seq_printf(s
, ",dir_mode=%04o", mnt
->dir_mode
& S_IRWXUGO
);
448 if (strcmp(mnt
->codepage
.local_name
, CONFIG_NLS_DEFAULT
))
449 seq_printf(s
, ",iocharset=%s", mnt
->codepage
.local_name
);
450 if (strcmp(mnt
->codepage
.remote_name
, SMB_NLS_REMOTE
))
451 seq_printf(s
, ",codepage=%s", mnt
->codepage
.remote_name
);
453 if (mnt
->ttl
!= SMB_TTL_DEFAULT
)
454 seq_printf(s
, ",ttl=%d", mnt
->ttl
);
460 smb_unload_nls(struct smb_sb_info
*server
)
462 unload_nls(server
->remote_nls
);
463 unload_nls(server
->local_nls
);
467 smb_put_super(struct super_block
*sb
)
469 struct smb_sb_info
*server
= SMB_SB(sb
);
473 smb_lock_server(server
);
474 server
->state
= CONN_INVALID
;
475 smbiod_unregister_server(server
);
477 smb_close_socket(server
);
479 if (server
->conn_pid
)
480 kill_pid(server
->conn_pid
, SIGTERM
, 1);
482 bdi_destroy(&server
->bdi
);
484 smb_unload_nls(server
);
485 sb
->s_fs_info
= NULL
;
486 smb_unlock_server(server
);
487 put_pid(server
->conn_pid
);
493 static int smb_fill_super(struct super_block
*sb
, void *raw_data
, int silent
)
495 struct smb_sb_info
*server
;
496 struct smb_mount_data_kernel
*mnt
;
497 struct smb_mount_data
*oldmnt
;
498 struct inode
*root_inode
;
499 struct smb_fattr root
;
502 static int warn_count
;
506 if (warn_count
< 5) {
508 printk(KERN_EMERG
"smbfs is deprecated and will be removed"
509 " from the 2.6.27 kernel. Please migrate to cifs\n");
515 oldmnt
= (struct smb_mount_data
*) raw_data
;
516 ver
= oldmnt
->version
;
517 if (ver
!= SMB_MOUNT_OLDVERSION
&& cpu_to_be32(ver
) != SMB_MOUNT_ASCII
)
520 sb
->s_flags
|= MS_NODIRATIME
;
521 sb
->s_blocksize
= 1024; /* Eh... Is this correct? */
522 sb
->s_blocksize_bits
= 10;
523 sb
->s_magic
= SMB_SUPER_MAGIC
;
524 sb
->s_op
= &smb_sops
;
525 sb
->s_time_gran
= 100;
527 server
= kzalloc(sizeof(struct smb_sb_info
), GFP_KERNEL
);
530 sb
->s_fs_info
= server
;
532 if (bdi_setup_and_register(&server
->bdi
, "smbfs", BDI_CAP_MAP_COPY
))
535 sb
->s_bdi
= &server
->bdi
;
537 server
->super_block
= sb
;
539 server
->sock_file
= NULL
;
540 init_waitqueue_head(&server
->conn_wq
);
541 init_MUTEX(&server
->sem
);
542 INIT_LIST_HEAD(&server
->entry
);
543 INIT_LIST_HEAD(&server
->xmitq
);
544 INIT_LIST_HEAD(&server
->recvq
);
545 server
->conn_error
= 0;
546 server
->conn_pid
= NULL
;
547 server
->state
= CONN_INVALID
; /* no connection yet */
548 server
->generation
= 0;
550 /* Allocate the global temp buffer and some superblock helper structs */
551 /* FIXME: move these to the smb_sb_info struct */
552 VERBOSE("alloc chunk = %lu\n", sizeof(struct smb_ops
) +
553 sizeof(struct smb_mount_data_kernel
));
554 mem
= kmalloc(sizeof(struct smb_ops
) +
555 sizeof(struct smb_mount_data_kernel
), GFP_KERNEL
);
560 smb_install_null_ops(server
->ops
);
561 server
->mnt
= mem
+ sizeof(struct smb_ops
);
563 /* Setup NLS stuff */
564 server
->remote_nls
= NULL
;
565 server
->local_nls
= NULL
;
569 memset(mnt
, 0, sizeof(struct smb_mount_data_kernel
));
570 strlcpy(mnt
->codepage
.local_name
, CONFIG_NLS_DEFAULT
,
572 strlcpy(mnt
->codepage
.remote_name
, SMB_NLS_REMOTE
,
575 mnt
->ttl
= SMB_TTL_DEFAULT
;
576 if (ver
== SMB_MOUNT_OLDVERSION
) {
577 mnt
->version
= oldmnt
->version
;
579 SET_UID(mnt
->uid
, oldmnt
->uid
);
580 SET_GID(mnt
->gid
, oldmnt
->gid
);
582 mnt
->file_mode
= (oldmnt
->file_mode
& S_IRWXUGO
) | S_IFREG
;
583 mnt
->dir_mode
= (oldmnt
->dir_mode
& S_IRWXUGO
) | S_IFDIR
;
585 mnt
->flags
= (oldmnt
->file_mode
>> 9) | SMB_MOUNT_UID
|
586 SMB_MOUNT_GID
| SMB_MOUNT_FMODE
| SMB_MOUNT_DMODE
;
588 mnt
->file_mode
= S_IRWXU
| S_IRGRP
| S_IXGRP
|
589 S_IROTH
| S_IXOTH
| S_IFREG
;
590 mnt
->dir_mode
= S_IRWXU
| S_IRGRP
| S_IXGRP
|
591 S_IROTH
| S_IXOTH
| S_IFDIR
;
592 if (parse_options(mnt
, raw_data
))
595 mnt
->mounted_uid
= current_uid();
596 smb_setcodepage(server
, &mnt
->codepage
);
599 * Display the enabled options
600 * Note: smb_proc_getattr uses these in 2.4 (but was changed in 2.2)
602 if (mnt
->flags
& SMB_MOUNT_OLDATTR
)
603 printk("SMBFS: Using core getattr (Win 95 speedup)\n");
604 else if (mnt
->flags
& SMB_MOUNT_DIRATTR
)
605 printk("SMBFS: Using dir ff getattr\n");
607 if (smbiod_register_server(server
) < 0) {
608 printk(KERN_ERR
"smbfs: failed to start smbiod\n");
613 * Keep the super block locked while we get the root inode.
615 smb_init_root_dirent(server
, &root
, sb
);
616 root_inode
= smb_iget(sb
, &root
);
620 sb
->s_root
= d_alloc_root(root_inode
);
624 smb_new_dentry(sb
->s_root
);
632 smb_unload_nls(server
);
636 bdi_destroy(&server
->bdi
);
639 printk(KERN_ERR
"smb_fill_super: allocation failure\n");
640 sb
->s_fs_info
= NULL
;
644 printk(KERN_ERR
"smbfs: mount_data version %d is not supported\n", ver
);
647 printk(KERN_ERR
"smb_fill_super: missing data argument\n");
652 printk(KERN_ERR
"smb_fill_super: cannot allocate struct smb_sb_info\n");
658 smb_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
664 result
= smb_proc_dskattr(dentry
, buf
);
668 buf
->f_type
= SMB_SUPER_MAGIC
;
669 buf
->f_namelen
= SMB_MAXPATHLEN
;
673 int smb_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
, struct kstat
*stat
)
675 int err
= smb_revalidate_inode(dentry
);
677 generic_fillattr(dentry
->d_inode
, stat
);
682 smb_notify_change(struct dentry
*dentry
, struct iattr
*attr
)
684 struct inode
*inode
= dentry
->d_inode
;
685 struct smb_sb_info
*server
= server_from_dentry(dentry
);
686 unsigned int mask
= (S_IFREG
| S_IFDIR
| S_IRWXUGO
);
687 int error
, changed
, refresh
= 0;
688 struct smb_fattr fattr
;
692 error
= smb_revalidate_inode(dentry
);
696 if ((error
= inode_change_ok(inode
, attr
)) < 0)
700 if ((attr
->ia_valid
& ATTR_UID
) && (attr
->ia_uid
!= server
->mnt
->uid
))
703 if ((attr
->ia_valid
& ATTR_GID
) && (attr
->ia_uid
!= server
->mnt
->gid
))
706 if ((attr
->ia_valid
& ATTR_MODE
) && (attr
->ia_mode
& ~mask
))
709 if ((attr
->ia_valid
& ATTR_SIZE
) != 0) {
710 VERBOSE("changing %s/%s, old size=%ld, new size=%ld\n",
712 (long) inode
->i_size
, (long) attr
->ia_size
);
714 filemap_write_and_wait(inode
->i_mapping
);
716 error
= smb_open(dentry
, O_WRONLY
);
719 error
= server
->ops
->truncate(inode
, attr
->ia_size
);
722 truncate_setsize(inode
, attr
->ia_size
);
726 if (server
->opt
.capabilities
& SMB_CAP_UNIX
) {
727 /* For now we don't want to set the size with setattr_unix */
728 attr
->ia_valid
&= ~ATTR_SIZE
;
729 /* FIXME: only call if we actually want to set something? */
730 error
= smb_proc_setattr_unix(dentry
, attr
, 0, 0);
738 * Initialize the fattr and check for changed fields.
739 * Note: CTIME under SMB is creation time rather than
740 * change time, so we don't attempt to change it.
742 smb_get_inode_attr(inode
, &fattr
);
745 if ((attr
->ia_valid
& ATTR_MTIME
) != 0) {
746 fattr
.f_mtime
= attr
->ia_mtime
;
749 if ((attr
->ia_valid
& ATTR_ATIME
) != 0) {
750 fattr
.f_atime
= attr
->ia_atime
;
751 /* Earlier protocols don't have an access time */
752 if (server
->opt
.protocol
>= SMB_PROTOCOL_LANMAN2
)
756 error
= smb_proc_settime(dentry
, &fattr
);
763 * Check for mode changes ... we're extremely limited in
764 * what can be set for SMB servers: just the read-only bit.
766 if ((attr
->ia_valid
& ATTR_MODE
) != 0) {
767 VERBOSE("%s/%s mode change, old=%x, new=%x\n",
768 DENTRY_PATH(dentry
), fattr
.f_mode
, attr
->ia_mode
);
770 if (attr
->ia_mode
& S_IWUSR
) {
771 if (fattr
.attr
& aRONLY
) {
772 fattr
.attr
&= ~aRONLY
;
776 if (!(fattr
.attr
& aRONLY
)) {
777 fattr
.attr
|= aRONLY
;
782 error
= smb_proc_setattr(dentry
, &fattr
);
792 smb_refresh_inode(dentry
);
797 static int smb_get_sb(struct file_system_type
*fs_type
,
798 int flags
, const char *dev_name
, void *data
, struct vfsmount
*mnt
)
800 return get_sb_nodev(fs_type
, flags
, data
, smb_fill_super
, mnt
);
803 static struct file_system_type smb_fs_type
= {
804 .owner
= THIS_MODULE
,
806 .get_sb
= smb_get_sb
,
807 .kill_sb
= kill_anon_super
,
808 .fs_flags
= FS_BINARY_MOUNTDATA
,
811 static int __init
init_smb_fs(void)
814 DEBUG1("registering ...\n");
816 err
= init_inodecache();
819 err
= smb_init_request_cache();
822 err
= register_filesystem(&smb_fs_type
);
827 smb_destroy_request_cache();
829 destroy_inodecache();
834 static void __exit
exit_smb_fs(void)
836 DEBUG1("unregistering ...\n");
837 unregister_filesystem(&smb_fs_type
);
838 smb_destroy_request_cache();
839 destroy_inodecache();
842 module_init(init_smb_fs
)
843 module_exit(exit_smb_fs
)
844 MODULE_LICENSE("GPL");