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>
30 #include <asm/system.h>
31 #include <asm/uaccess.h>
35 #include "smb_mount.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_i_callback(struct rcu_head
*head
)
67 struct inode
*inode
= container_of(head
, struct inode
, i_rcu
);
68 INIT_LIST_HEAD(&inode
->i_dentry
);
69 kmem_cache_free(smb_inode_cachep
, SMB_I(inode
));
72 static void smb_destroy_inode(struct inode
*inode
)
74 call_rcu(&inode
->i_rcu
, smb_i_callback
);
77 static void init_once(void *foo
)
79 struct smb_inode_info
*ei
= (struct smb_inode_info
*) foo
;
81 inode_init_once(&ei
->vfs_inode
);
84 static int init_inodecache(void)
86 smb_inode_cachep
= kmem_cache_create("smb_inode_cache",
87 sizeof(struct smb_inode_info
),
88 0, (SLAB_RECLAIM_ACCOUNT
|
91 if (smb_inode_cachep
== NULL
)
96 static void destroy_inodecache(void)
98 kmem_cache_destroy(smb_inode_cachep
);
101 static int smb_remount(struct super_block
*sb
, int *flags
, char *data
)
103 *flags
|= MS_NODIRATIME
;
107 static const struct super_operations smb_sops
=
109 .alloc_inode
= smb_alloc_inode
,
110 .destroy_inode
= smb_destroy_inode
,
111 .drop_inode
= generic_delete_inode
,
112 .evict_inode
= smb_evict_inode
,
113 .put_super
= smb_put_super
,
114 .statfs
= smb_statfs
,
115 .show_options
= smb_show_options
,
116 .remount_fs
= smb_remount
,
120 /* We are always generating a new inode here */
122 smb_iget(struct super_block
*sb
, struct smb_fattr
*fattr
)
124 struct smb_sb_info
*server
= SMB_SB(sb
);
125 struct inode
*result
;
127 DEBUG1("smb_iget: %p\n", fattr
);
129 result
= new_inode(sb
);
132 result
->i_ino
= fattr
->f_ino
;
133 SMB_I(result
)->open
= 0;
134 SMB_I(result
)->fileid
= 0;
135 SMB_I(result
)->access
= 0;
136 SMB_I(result
)->flags
= 0;
137 SMB_I(result
)->closed
= 0;
138 SMB_I(result
)->openers
= 0;
139 smb_set_inode_attr(result
, fattr
);
140 if (S_ISREG(result
->i_mode
)) {
141 result
->i_op
= &smb_file_inode_operations
;
142 result
->i_fop
= &smb_file_operations
;
143 result
->i_data
.a_ops
= &smb_file_aops
;
144 } else if (S_ISDIR(result
->i_mode
)) {
145 if (server
->opt
.capabilities
& SMB_CAP_UNIX
)
146 result
->i_op
= &smb_dir_inode_operations_unix
;
148 result
->i_op
= &smb_dir_inode_operations
;
149 result
->i_fop
= &smb_dir_operations
;
150 } else if (S_ISLNK(result
->i_mode
)) {
151 result
->i_op
= &smb_link_inode_operations
;
153 init_special_inode(result
, result
->i_mode
, fattr
->f_rdev
);
155 insert_inode_hash(result
);
160 * Copy the inode data to a smb_fattr structure.
163 smb_get_inode_attr(struct inode
*inode
, struct smb_fattr
*fattr
)
165 memset(fattr
, 0, sizeof(struct smb_fattr
));
166 fattr
->f_mode
= inode
->i_mode
;
167 fattr
->f_nlink
= inode
->i_nlink
;
168 fattr
->f_ino
= inode
->i_ino
;
169 fattr
->f_uid
= inode
->i_uid
;
170 fattr
->f_gid
= inode
->i_gid
;
171 fattr
->f_size
= inode
->i_size
;
172 fattr
->f_mtime
= inode
->i_mtime
;
173 fattr
->f_ctime
= inode
->i_ctime
;
174 fattr
->f_atime
= inode
->i_atime
;
175 fattr
->f_blocks
= inode
->i_blocks
;
177 fattr
->attr
= SMB_I(inode
)->attr
;
179 * Keep the attributes in sync with the inode permissions.
181 if (fattr
->f_mode
& S_IWUSR
)
182 fattr
->attr
&= ~aRONLY
;
184 fattr
->attr
|= aRONLY
;
188 * Update the inode, possibly causing it to invalidate its pages if mtime/size
189 * is different from last time.
192 smb_set_inode_attr(struct inode
*inode
, struct smb_fattr
*fattr
)
194 struct smb_inode_info
*ei
= SMB_I(inode
);
197 * A size change should have a different mtime, or same mtime
198 * but different size.
200 time_t last_time
= inode
->i_mtime
.tv_sec
;
201 loff_t last_sz
= inode
->i_size
;
203 inode
->i_mode
= fattr
->f_mode
;
204 inode
->i_nlink
= fattr
->f_nlink
;
205 inode
->i_uid
= fattr
->f_uid
;
206 inode
->i_gid
= fattr
->f_gid
;
207 inode
->i_ctime
= fattr
->f_ctime
;
208 inode
->i_blocks
= fattr
->f_blocks
;
209 inode
->i_size
= fattr
->f_size
;
210 inode
->i_mtime
= fattr
->f_mtime
;
211 inode
->i_atime
= fattr
->f_atime
;
212 ei
->attr
= fattr
->attr
;
215 * Update the "last time refreshed" field for revalidation.
217 ei
->oldmtime
= jiffies
;
219 if (inode
->i_mtime
.tv_sec
!= last_time
|| inode
->i_size
!= last_sz
) {
220 VERBOSE("%ld changed, old=%ld, new=%ld, oz=%ld, nz=%ld\n",
222 (long) last_time
, (long) inode
->i_mtime
.tv_sec
,
223 (long) last_sz
, (long) inode
->i_size
);
225 if (!S_ISDIR(inode
->i_mode
))
226 invalidate_remote_inode(inode
);
231 * This is called if the connection has gone bad ...
232 * try to kill off all the current inodes.
235 smb_invalidate_inodes(struct smb_sb_info
*server
)
238 shrink_dcache_sb(SB_of(server
));
242 * This is called to update the inode attributes after
243 * we've made changes to a file or directory.
246 smb_refresh_inode(struct dentry
*dentry
)
248 struct inode
*inode
= dentry
->d_inode
;
250 struct smb_fattr fattr
;
252 error
= smb_proc_getattr(dentry
, &fattr
);
254 smb_renew_times(dentry
);
256 * Check whether the type part of the mode changed,
257 * and don't update the attributes if it did.
259 * And don't dick with the root inode
261 if (inode
->i_ino
== 2)
263 if (S_ISLNK(inode
->i_mode
))
264 return error
; /* VFS will deal with it */
266 if ((inode
->i_mode
& S_IFMT
) == (fattr
.f_mode
& S_IFMT
)) {
267 smb_set_inode_attr(inode
, &fattr
);
270 * Big trouble! The inode has become a new object,
271 * so any operations attempted on it are invalid.
273 * To limit damage, mark the inode as bad so that
274 * subsequent lookup validations will fail.
276 PARANOIA("%s/%s changed mode, %07o to %07o\n",
278 inode
->i_mode
, fattr
.f_mode
);
280 fattr
.f_mode
= inode
->i_mode
; /* save mode */
281 make_bad_inode(inode
);
282 inode
->i_mode
= fattr
.f_mode
; /* restore mode */
284 * No need to worry about unhashing the dentry: the
285 * lookup validation will see that the inode is bad.
286 * But we do want to invalidate the caches ...
288 if (!S_ISDIR(inode
->i_mode
))
289 invalidate_remote_inode(inode
);
291 smb_invalid_dir_cache(inode
);
299 * This is called when we want to check whether the inode
300 * has changed on the server. If it has changed, we must
301 * invalidate our local caches.
304 smb_revalidate_inode(struct dentry
*dentry
)
306 struct smb_sb_info
*s
= server_from_dentry(dentry
);
307 struct inode
*inode
= dentry
->d_inode
;
310 DEBUG1("smb_revalidate_inode\n");
314 * Check whether we've recently refreshed the inode.
316 if (time_before(jiffies
, SMB_I(inode
)->oldmtime
+ SMB_MAX_AGE(s
))) {
317 VERBOSE("up-to-date, ino=%ld, jiffies=%lu, oldtime=%lu\n",
318 inode
->i_ino
, jiffies
, SMB_I(inode
)->oldmtime
);
322 error
= smb_refresh_inode(dentry
);
329 * This routine is called when i_nlink == 0 and i_count goes to 0.
330 * All blocking cleanup operations need to go here to avoid races.
333 smb_evict_inode(struct inode
*ino
)
335 DEBUG1("ino=%ld\n", ino
->i_ino
);
336 truncate_inode_pages(&ino
->i_data
, 0);
340 PARANOIA("could not close inode %ld\n", ino
->i_ino
);
344 static struct option opts
[] = {
345 { "version", 0, 'v' },
346 { "win95", SMB_MOUNT_WIN95
, 1 },
347 { "oldattr", SMB_MOUNT_OLDATTR
, 1 },
348 { "dirattr", SMB_MOUNT_DIRATTR
, 1 },
349 { "case", SMB_MOUNT_CASE
, 1 },
352 { "file_mode", 0, 'f' },
353 { "dir_mode", 0, 'd' },
354 { "iocharset", 0, 'i' },
355 { "codepage", 0, 'c' },
361 parse_options(struct smb_mount_data_kernel
*mnt
, char *options
)
370 while ( (c
= smb_getopt("smbfs", &options
, opts
,
371 &optopt
, &optarg
, &flags
, &value
)) > 0) {
373 VERBOSE("'%s' -> '%s'\n", optopt
, optarg
? optarg
: "<none>");
376 /* got a "flag" option */
379 if (value
!= SMB_MOUNT_VERSION
) {
380 printk ("smbfs: Bad mount version %ld, expected %d\n",
381 value
, SMB_MOUNT_VERSION
);
384 mnt
->version
= value
;
388 flags
|= SMB_MOUNT_UID
;
392 flags
|= SMB_MOUNT_GID
;
395 mnt
->file_mode
= (value
& S_IRWXUGO
) | S_IFREG
;
396 flags
|= SMB_MOUNT_FMODE
;
399 mnt
->dir_mode
= (value
& S_IRWXUGO
) | S_IFDIR
;
400 flags
|= SMB_MOUNT_DMODE
;
403 strlcpy(mnt
->codepage
.local_name
, optarg
,
407 strlcpy(mnt
->codepage
.remote_name
, optarg
,
414 printk ("smbfs: Unrecognized mount option %s\n",
424 * smb_show_options() is for displaying mount options in /proc/mounts.
425 * It tries to avoid showing settings that were not changed from their
429 smb_show_options(struct seq_file
*s
, struct vfsmount
*m
)
431 struct smb_mount_data_kernel
*mnt
= SMB_SB(m
->mnt_sb
)->mnt
;
434 for (i
= 0; opts
[i
].name
!= NULL
; i
++)
435 if (mnt
->flags
& opts
[i
].flag
)
436 seq_printf(s
, ",%s", opts
[i
].name
);
438 if (mnt
->flags
& SMB_MOUNT_UID
)
439 seq_printf(s
, ",uid=%d", mnt
->uid
);
440 if (mnt
->flags
& SMB_MOUNT_GID
)
441 seq_printf(s
, ",gid=%d", mnt
->gid
);
442 if (mnt
->mounted_uid
!= 0)
443 seq_printf(s
, ",mounted_uid=%d", mnt
->mounted_uid
);
446 * Defaults for file_mode and dir_mode are unknown to us; they
447 * depend on the current umask of the user doing the mount.
449 if (mnt
->flags
& SMB_MOUNT_FMODE
)
450 seq_printf(s
, ",file_mode=%04o", mnt
->file_mode
& S_IRWXUGO
);
451 if (mnt
->flags
& SMB_MOUNT_DMODE
)
452 seq_printf(s
, ",dir_mode=%04o", mnt
->dir_mode
& S_IRWXUGO
);
454 if (strcmp(mnt
->codepage
.local_name
, CONFIG_NLS_DEFAULT
))
455 seq_printf(s
, ",iocharset=%s", mnt
->codepage
.local_name
);
456 if (strcmp(mnt
->codepage
.remote_name
, SMB_NLS_REMOTE
))
457 seq_printf(s
, ",codepage=%s", mnt
->codepage
.remote_name
);
459 if (mnt
->ttl
!= SMB_TTL_DEFAULT
)
460 seq_printf(s
, ",ttl=%d", mnt
->ttl
);
466 smb_unload_nls(struct smb_sb_info
*server
)
468 unload_nls(server
->remote_nls
);
469 unload_nls(server
->local_nls
);
473 smb_put_super(struct super_block
*sb
)
475 struct smb_sb_info
*server
= SMB_SB(sb
);
479 smb_lock_server(server
);
480 server
->state
= CONN_INVALID
;
481 smbiod_unregister_server(server
);
483 smb_close_socket(server
);
485 if (server
->conn_pid
)
486 kill_pid(server
->conn_pid
, SIGTERM
, 1);
488 bdi_destroy(&server
->bdi
);
490 smb_unload_nls(server
);
491 sb
->s_fs_info
= NULL
;
492 smb_unlock_server(server
);
493 put_pid(server
->conn_pid
);
499 static int smb_fill_super(struct super_block
*sb
, void *raw_data
, int silent
)
501 struct smb_sb_info
*server
;
502 struct smb_mount_data_kernel
*mnt
;
503 struct smb_mount_data
*oldmnt
;
504 struct inode
*root_inode
;
505 struct smb_fattr root
;
508 static int warn_count
;
512 if (warn_count
< 5) {
514 printk(KERN_EMERG
"smbfs is deprecated and will be removed"
515 " from the 2.6.37 kernel. Please migrate to cifs\n");
521 oldmnt
= (struct smb_mount_data
*) raw_data
;
522 ver
= oldmnt
->version
;
523 if (ver
!= SMB_MOUNT_OLDVERSION
&& cpu_to_be32(ver
) != SMB_MOUNT_ASCII
)
526 sb
->s_flags
|= MS_NODIRATIME
;
527 sb
->s_blocksize
= 1024; /* Eh... Is this correct? */
528 sb
->s_blocksize_bits
= 10;
529 sb
->s_magic
= SMB_SUPER_MAGIC
;
530 sb
->s_op
= &smb_sops
;
531 sb
->s_time_gran
= 100;
533 server
= kzalloc(sizeof(struct smb_sb_info
), GFP_KERNEL
);
536 sb
->s_fs_info
= server
;
538 if (bdi_setup_and_register(&server
->bdi
, "smbfs", BDI_CAP_MAP_COPY
))
541 sb
->s_bdi
= &server
->bdi
;
543 server
->super_block
= sb
;
545 server
->sock_file
= NULL
;
546 init_waitqueue_head(&server
->conn_wq
);
547 sema_init(&server
->sem
, 1);
548 INIT_LIST_HEAD(&server
->entry
);
549 INIT_LIST_HEAD(&server
->xmitq
);
550 INIT_LIST_HEAD(&server
->recvq
);
551 server
->conn_error
= 0;
552 server
->conn_pid
= NULL
;
553 server
->state
= CONN_INVALID
; /* no connection yet */
554 server
->generation
= 0;
556 /* Allocate the global temp buffer and some superblock helper structs */
557 /* FIXME: move these to the smb_sb_info struct */
558 VERBOSE("alloc chunk = %lu\n", sizeof(struct smb_ops
) +
559 sizeof(struct smb_mount_data_kernel
));
560 mem
= kmalloc(sizeof(struct smb_ops
) +
561 sizeof(struct smb_mount_data_kernel
), GFP_KERNEL
);
566 smb_install_null_ops(server
->ops
);
567 server
->mnt
= mem
+ sizeof(struct smb_ops
);
569 /* Setup NLS stuff */
570 server
->remote_nls
= NULL
;
571 server
->local_nls
= NULL
;
575 memset(mnt
, 0, sizeof(struct smb_mount_data_kernel
));
576 strlcpy(mnt
->codepage
.local_name
, CONFIG_NLS_DEFAULT
,
578 strlcpy(mnt
->codepage
.remote_name
, SMB_NLS_REMOTE
,
581 mnt
->ttl
= SMB_TTL_DEFAULT
;
582 if (ver
== SMB_MOUNT_OLDVERSION
) {
583 mnt
->version
= oldmnt
->version
;
585 SET_UID(mnt
->uid
, oldmnt
->uid
);
586 SET_GID(mnt
->gid
, oldmnt
->gid
);
588 mnt
->file_mode
= (oldmnt
->file_mode
& S_IRWXUGO
) | S_IFREG
;
589 mnt
->dir_mode
= (oldmnt
->dir_mode
& S_IRWXUGO
) | S_IFDIR
;
591 mnt
->flags
= (oldmnt
->file_mode
>> 9) | SMB_MOUNT_UID
|
592 SMB_MOUNT_GID
| SMB_MOUNT_FMODE
| SMB_MOUNT_DMODE
;
594 mnt
->file_mode
= S_IRWXU
| S_IRGRP
| S_IXGRP
|
595 S_IROTH
| S_IXOTH
| S_IFREG
;
596 mnt
->dir_mode
= S_IRWXU
| S_IRGRP
| S_IXGRP
|
597 S_IROTH
| S_IXOTH
| S_IFDIR
;
598 if (parse_options(mnt
, raw_data
))
601 mnt
->mounted_uid
= current_uid();
602 smb_setcodepage(server
, &mnt
->codepage
);
605 * Display the enabled options
606 * Note: smb_proc_getattr uses these in 2.4 (but was changed in 2.2)
608 if (mnt
->flags
& SMB_MOUNT_OLDATTR
)
609 printk("SMBFS: Using core getattr (Win 95 speedup)\n");
610 else if (mnt
->flags
& SMB_MOUNT_DIRATTR
)
611 printk("SMBFS: Using dir ff getattr\n");
613 if (smbiod_register_server(server
) < 0) {
614 printk(KERN_ERR
"smbfs: failed to start smbiod\n");
619 * Keep the super block locked while we get the root inode.
621 smb_init_root_dirent(server
, &root
, sb
);
622 root_inode
= smb_iget(sb
, &root
);
626 sb
->s_root
= d_alloc_root(root_inode
);
630 smb_new_dentry(sb
->s_root
);
638 smb_unload_nls(server
);
642 bdi_destroy(&server
->bdi
);
645 printk(KERN_ERR
"smb_fill_super: allocation failure\n");
646 sb
->s_fs_info
= NULL
;
650 printk(KERN_ERR
"smbfs: mount_data version %d is not supported\n", ver
);
653 printk(KERN_ERR
"smb_fill_super: missing data argument\n");
658 printk(KERN_ERR
"smb_fill_super: cannot allocate struct smb_sb_info\n");
664 smb_statfs(struct dentry
*dentry
, struct kstatfs
*buf
)
670 result
= smb_proc_dskattr(dentry
, buf
);
674 buf
->f_type
= SMB_SUPER_MAGIC
;
675 buf
->f_namelen
= SMB_MAXPATHLEN
;
679 int smb_getattr(struct vfsmount
*mnt
, struct dentry
*dentry
, struct kstat
*stat
)
681 int err
= smb_revalidate_inode(dentry
);
683 generic_fillattr(dentry
->d_inode
, stat
);
688 smb_notify_change(struct dentry
*dentry
, struct iattr
*attr
)
690 struct inode
*inode
= dentry
->d_inode
;
691 struct smb_sb_info
*server
= server_from_dentry(dentry
);
692 unsigned int mask
= (S_IFREG
| S_IFDIR
| S_IRWXUGO
);
693 int error
, changed
, refresh
= 0;
694 struct smb_fattr fattr
;
698 error
= smb_revalidate_inode(dentry
);
702 if ((error
= inode_change_ok(inode
, attr
)) < 0)
706 if ((attr
->ia_valid
& ATTR_UID
) && (attr
->ia_uid
!= server
->mnt
->uid
))
709 if ((attr
->ia_valid
& ATTR_GID
) && (attr
->ia_uid
!= server
->mnt
->gid
))
712 if ((attr
->ia_valid
& ATTR_MODE
) && (attr
->ia_mode
& ~mask
))
715 if ((attr
->ia_valid
& ATTR_SIZE
) != 0) {
716 VERBOSE("changing %s/%s, old size=%ld, new size=%ld\n",
718 (long) inode
->i_size
, (long) attr
->ia_size
);
720 filemap_write_and_wait(inode
->i_mapping
);
722 error
= smb_open(dentry
, O_WRONLY
);
725 error
= server
->ops
->truncate(inode
, attr
->ia_size
);
728 truncate_setsize(inode
, attr
->ia_size
);
732 if (server
->opt
.capabilities
& SMB_CAP_UNIX
) {
733 /* For now we don't want to set the size with setattr_unix */
734 attr
->ia_valid
&= ~ATTR_SIZE
;
735 /* FIXME: only call if we actually want to set something? */
736 error
= smb_proc_setattr_unix(dentry
, attr
, 0, 0);
744 * Initialize the fattr and check for changed fields.
745 * Note: CTIME under SMB is creation time rather than
746 * change time, so we don't attempt to change it.
748 smb_get_inode_attr(inode
, &fattr
);
751 if ((attr
->ia_valid
& ATTR_MTIME
) != 0) {
752 fattr
.f_mtime
= attr
->ia_mtime
;
755 if ((attr
->ia_valid
& ATTR_ATIME
) != 0) {
756 fattr
.f_atime
= attr
->ia_atime
;
757 /* Earlier protocols don't have an access time */
758 if (server
->opt
.protocol
>= SMB_PROTOCOL_LANMAN2
)
762 error
= smb_proc_settime(dentry
, &fattr
);
769 * Check for mode changes ... we're extremely limited in
770 * what can be set for SMB servers: just the read-only bit.
772 if ((attr
->ia_valid
& ATTR_MODE
) != 0) {
773 VERBOSE("%s/%s mode change, old=%x, new=%x\n",
774 DENTRY_PATH(dentry
), fattr
.f_mode
, attr
->ia_mode
);
776 if (attr
->ia_mode
& S_IWUSR
) {
777 if (fattr
.attr
& aRONLY
) {
778 fattr
.attr
&= ~aRONLY
;
782 if (!(fattr
.attr
& aRONLY
)) {
783 fattr
.attr
|= aRONLY
;
788 error
= smb_proc_setattr(dentry
, &fattr
);
798 smb_refresh_inode(dentry
);
803 static struct dentry
*smb_mount(struct file_system_type
*fs_type
,
804 int flags
, const char *dev_name
, void *data
)
806 return mount_nodev(fs_type
, flags
, data
, smb_fill_super
);
809 static struct file_system_type smb_fs_type
= {
810 .owner
= THIS_MODULE
,
813 .kill_sb
= kill_anon_super
,
814 .fs_flags
= FS_BINARY_MOUNTDATA
,
817 static int __init
init_smb_fs(void)
820 DEBUG1("registering ...\n");
822 err
= init_inodecache();
825 err
= smb_init_request_cache();
828 err
= register_filesystem(&smb_fs_type
);
833 smb_destroy_request_cache();
835 destroy_inodecache();
840 static void __exit
exit_smb_fs(void)
842 DEBUG1("unregistering ...\n");
843 unregister_filesystem(&smb_fs_type
);
844 smb_destroy_request_cache();
845 destroy_inodecache();
848 module_init(init_smb_fs
)
849 module_exit(exit_smb_fs
)
850 MODULE_LICENSE("GPL");