8f7451f3c8e62b12c526dda3362c63708bdc45b8
[sfrench/cifs-2.6.git] / fs / cifs / cifsfs.c
1 /*
2  *   fs/cifs/cifsfs.c
3  *
4  *   Copyright (C) International Business Machines  Corp., 2002,2008
5  *   Author(s): Steve French (sfrench@us.ibm.com)
6  *
7  *   Common Internet FileSystem (CIFS) client
8  *
9  *   This library is free software; you can redistribute it and/or modify
10  *   it under the terms of the GNU Lesser General Public License as published
11  *   by the Free Software Foundation; either version 2.1 of the License, or
12  *   (at your option) any later version.
13  *
14  *   This library is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
17  *   the GNU Lesser General Public License for more details.
18  *
19  *   You should have received a copy of the GNU Lesser General Public License
20  *   along with this library; if not, write to the Free Software
21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22  */
23
24 /* Note that BB means BUGBUG (ie something to fix eventually) */
25
26 #include <linux/module.h>
27 #include <linux/fs.h>
28 #include <linux/mount.h>
29 #include <linux/slab.h>
30 #include <linux/init.h>
31 #include <linux/list.h>
32 #include <linux/seq_file.h>
33 #include <linux/vfs.h>
34 #include <linux/mempool.h>
35 #include <linux/delay.h>
36 #include <linux/kthread.h>
37 #include <linux/freezer.h>
38 #include <net/ipv6.h>
39 #include "cifsfs.h"
40 #include "cifspdu.h"
41 #define DECLARE_GLOBALS_HERE
42 #include "cifsglob.h"
43 #include "cifsproto.h"
44 #include "cifs_debug.h"
45 #include "cifs_fs_sb.h"
46 #include <linux/mm.h>
47 #include <linux/key-type.h>
48 #include "cifs_spnego.h"
49 #include "fscache.h"
50 #define CIFS_MAGIC_NUMBER 0xFF534D42    /* the first four bytes of SMB PDUs */
51
52 int cifsFYI = 0;
53 int cifsERROR = 1;
54 int traceSMB = 0;
55 unsigned int oplockEnabled = 1;
56 unsigned int linuxExtEnabled = 1;
57 unsigned int lookupCacheEnabled = 1;
58 unsigned int multiuser_mount = 0;
59 unsigned int global_secflags = CIFSSEC_DEF;
60 /* unsigned int ntlmv2_support = 0; */
61 unsigned int sign_CIFS_PDUs = 1;
62 static const struct super_operations cifs_super_ops;
63 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
64 module_param(CIFSMaxBufSize, int, 0);
65 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
66                                  "Default: 16384 Range: 8192 to 130048");
67 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
68 module_param(cifs_min_rcv, int, 0);
69 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
70                                 "1 to 64");
71 unsigned int cifs_min_small = 30;
72 module_param(cifs_min_small, int, 0);
73 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
74                                  "Range: 2 to 256");
75 unsigned int cifs_max_pending = CIFS_MAX_REQ;
76 module_param(cifs_max_pending, int, 0);
77 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
78                                    "Default: 50 Range: 2 to 256");
79 unsigned short echo_retries = 5;
80 module_param(echo_retries, ushort, 0644);
81 MODULE_PARM_DESC(echo_retries, "Number of echo attempts before giving up and "
82                                "reconnecting server. Default: 5. 0 means "
83                                "never reconnect.");
84 extern mempool_t *cifs_sm_req_poolp;
85 extern mempool_t *cifs_req_poolp;
86 extern mempool_t *cifs_mid_poolp;
87
88 void
89 cifs_sb_active(struct super_block *sb)
90 {
91         struct cifs_sb_info *server = CIFS_SB(sb);
92
93         if (atomic_inc_return(&server->active) == 1)
94                 atomic_inc(&sb->s_active);
95 }
96
97 void
98 cifs_sb_deactive(struct super_block *sb)
99 {
100         struct cifs_sb_info *server = CIFS_SB(sb);
101
102         if (atomic_dec_and_test(&server->active))
103                 deactivate_super(sb);
104 }
105
106 static int
107 cifs_read_super(struct super_block *sb, struct smb_vol *volume_info,
108                 const char *devname, int silent)
109 {
110         struct inode *inode;
111         struct cifs_sb_info *cifs_sb;
112         int rc = 0;
113
114         cifs_sb = CIFS_SB(sb);
115
116         spin_lock_init(&cifs_sb->tlink_tree_lock);
117         cifs_sb->tlink_tree = RB_ROOT;
118
119         rc = cifs_mount(cifs_sb, volume_info);
120
121         if (rc) {
122                 if (!silent)
123                         cERROR(1, "cifs_mount failed w/return code = %d", rc);
124                 return rc;
125         }
126
127         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIXACL)
128                 sb->s_flags |= MS_POSIXACL;
129
130         if (cifs_sb_master_tcon(cifs_sb)->ses->capabilities & CAP_LARGE_FILES)
131                 sb->s_maxbytes = MAX_LFS_FILESIZE;
132         else
133                 sb->s_maxbytes = MAX_NON_LFS;
134
135         /* BB FIXME fix time_gran to be larger for LANMAN sessions */
136         sb->s_time_gran = 100;
137
138         sb->s_magic = CIFS_MAGIC_NUMBER;
139         sb->s_op = &cifs_super_ops;
140         sb->s_bdi = &cifs_sb->bdi;
141         sb->s_blocksize = CIFS_MAX_MSGSIZE;
142         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
143         inode = cifs_root_iget(sb);
144
145         if (IS_ERR(inode)) {
146                 rc = PTR_ERR(inode);
147                 inode = NULL;
148                 goto out_no_root;
149         }
150
151         sb->s_root = d_alloc_root(inode);
152
153         if (!sb->s_root) {
154                 rc = -ENOMEM;
155                 goto out_no_root;
156         }
157
158         /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */
159         if (cifs_sb_master_tcon(cifs_sb)->nocase)
160                 sb->s_d_op = &cifs_ci_dentry_ops;
161         else
162                 sb->s_d_op = &cifs_dentry_ops;
163
164 #ifdef CIFS_NFSD_EXPORT
165         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
166                 cFYI(1, "export ops supported");
167                 sb->s_export_op = &cifs_export_ops;
168         }
169 #endif /* CIFS_NFSD_EXPORT */
170
171         return 0;
172
173 out_no_root:
174         cERROR(1, "cifs_read_super: get root inode failed");
175         if (inode)
176                 iput(inode);
177
178         cifs_umount(sb, cifs_sb);
179         return rc;
180 }
181
182 static void
183 cifs_put_super(struct super_block *sb)
184 {
185         int rc = 0;
186         struct cifs_sb_info *cifs_sb;
187
188         cFYI(1, "In cifs_put_super");
189         cifs_sb = CIFS_SB(sb);
190         if (cifs_sb == NULL) {
191                 cFYI(1, "Empty cifs superblock info passed to unmount");
192                 return;
193         }
194
195         rc = cifs_umount(sb, cifs_sb);
196         if (rc)
197                 cERROR(1, "cifs_umount failed with return code %d", rc);
198 }
199
200 static void cifs_kill_sb(struct super_block *sb)
201 {
202         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
203         kill_anon_super(sb);
204         kfree(cifs_sb->mountdata);
205         unload_nls(cifs_sb->local_nls);
206         kfree(cifs_sb);
207 }
208
209 static int
210 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
211 {
212         struct super_block *sb = dentry->d_sb;
213         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
214         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
215         int rc = -EOPNOTSUPP;
216         int xid;
217
218         xid = GetXid();
219
220         buf->f_type = CIFS_MAGIC_NUMBER;
221
222         /*
223          * PATH_MAX may be too long - it would presumably be total path,
224          * but note that some servers (includinng Samba 3) have a shorter
225          * maximum path.
226          *
227          * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
228          */
229         buf->f_namelen = PATH_MAX;
230         buf->f_files = 0;       /* undefined */
231         buf->f_ffree = 0;       /* unlimited */
232
233         /*
234          * We could add a second check for a QFS Unix capability bit
235          */
236         if ((tcon->ses->capabilities & CAP_UNIX) &&
237             (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
238                 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
239
240         /*
241          * Only need to call the old QFSInfo if failed on newer one,
242          * e.g. by OS/2.
243          **/
244         if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
245                 rc = CIFSSMBQFSInfo(xid, tcon, buf);
246
247         /*
248          * Some old Windows servers also do not support level 103, retry with
249          * older level one if old server failed the previous call or we
250          * bypassed it because we detected that this was an older LANMAN sess
251          */
252         if (rc)
253                 rc = SMBOldQFSInfo(xid, tcon, buf);
254
255         FreeXid(xid);
256         return 0;
257 }
258
259 static int cifs_permission(struct inode *inode, int mask, unsigned int flags)
260 {
261         struct cifs_sb_info *cifs_sb;
262
263         cifs_sb = CIFS_SB(inode->i_sb);
264
265         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
266                 if ((mask & MAY_EXEC) && !execute_ok(inode))
267                         return -EACCES;
268                 else
269                         return 0;
270         } else /* file mode might have been restricted at mount time
271                 on the client (above and beyond ACL on servers) for
272                 servers which do not support setting and viewing mode bits,
273                 so allowing client to check permissions is useful */
274                 return generic_permission(inode, mask, flags, NULL);
275 }
276
277 static struct kmem_cache *cifs_inode_cachep;
278 static struct kmem_cache *cifs_req_cachep;
279 static struct kmem_cache *cifs_mid_cachep;
280 static struct kmem_cache *cifs_sm_req_cachep;
281 mempool_t *cifs_sm_req_poolp;
282 mempool_t *cifs_req_poolp;
283 mempool_t *cifs_mid_poolp;
284
285 static struct inode *
286 cifs_alloc_inode(struct super_block *sb)
287 {
288         struct cifsInodeInfo *cifs_inode;
289         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
290         if (!cifs_inode)
291                 return NULL;
292         cifs_inode->cifsAttrs = 0x20;   /* default */
293         cifs_inode->time = 0;
294         /* Until the file is open and we have gotten oplock
295         info back from the server, can not assume caching of
296         file data or metadata */
297         cifs_set_oplock_level(cifs_inode, 0);
298         cifs_inode->delete_pending = false;
299         cifs_inode->invalid_mapping = false;
300         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
301         cifs_inode->server_eof = 0;
302         cifs_inode->uniqueid = 0;
303         cifs_inode->createtime = 0;
304
305         /* Can not set i_flags here - they get immediately overwritten
306            to zero by the VFS */
307 /*      cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
308         INIT_LIST_HEAD(&cifs_inode->openFileList);
309         return &cifs_inode->vfs_inode;
310 }
311
312 static void cifs_i_callback(struct rcu_head *head)
313 {
314         struct inode *inode = container_of(head, struct inode, i_rcu);
315         INIT_LIST_HEAD(&inode->i_dentry);
316         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
317 }
318
319 static void
320 cifs_destroy_inode(struct inode *inode)
321 {
322         call_rcu(&inode->i_rcu, cifs_i_callback);
323 }
324
325 static void
326 cifs_evict_inode(struct inode *inode)
327 {
328         truncate_inode_pages(&inode->i_data, 0);
329         end_writeback(inode);
330         cifs_fscache_release_inode_cookie(inode);
331 }
332
333 static void
334 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
335 {
336         struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
337         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
338
339         seq_printf(s, ",addr=");
340
341         switch (server->dstaddr.ss_family) {
342         case AF_INET:
343                 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
344                 break;
345         case AF_INET6:
346                 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
347                 if (sa6->sin6_scope_id)
348                         seq_printf(s, "%%%u", sa6->sin6_scope_id);
349                 break;
350         default:
351                 seq_printf(s, "(unknown)");
352         }
353 }
354
355 static void
356 cifs_show_security(struct seq_file *s, struct TCP_Server_Info *server)
357 {
358         seq_printf(s, ",sec=");
359
360         switch (server->secType) {
361         case LANMAN:
362                 seq_printf(s, "lanman");
363                 break;
364         case NTLMv2:
365                 seq_printf(s, "ntlmv2");
366                 break;
367         case NTLM:
368                 seq_printf(s, "ntlm");
369                 break;
370         case Kerberos:
371                 seq_printf(s, "krb5");
372                 break;
373         case RawNTLMSSP:
374                 seq_printf(s, "ntlmssp");
375                 break;
376         default:
377                 /* shouldn't ever happen */
378                 seq_printf(s, "unknown");
379                 break;
380         }
381
382         if (server->sec_mode & (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
383                 seq_printf(s, "i");
384 }
385
386 /*
387  * cifs_show_options() is for displaying mount options in /proc/mounts.
388  * Not all settable options are displayed but most of the important
389  * ones are.
390  */
391 static int
392 cifs_show_options(struct seq_file *s, struct vfsmount *m)
393 {
394         struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
395         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
396         struct sockaddr *srcaddr;
397         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
398
399         cifs_show_security(s, tcon->ses->server);
400
401         seq_printf(s, ",unc=%s", tcon->treeName);
402
403         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
404                 seq_printf(s, ",multiuser");
405         else if (tcon->ses->user_name)
406                 seq_printf(s, ",username=%s", tcon->ses->user_name);
407
408         if (tcon->ses->domainName)
409                 seq_printf(s, ",domain=%s", tcon->ses->domainName);
410
411         if (srcaddr->sa_family != AF_UNSPEC) {
412                 struct sockaddr_in *saddr4;
413                 struct sockaddr_in6 *saddr6;
414                 saddr4 = (struct sockaddr_in *)srcaddr;
415                 saddr6 = (struct sockaddr_in6 *)srcaddr;
416                 if (srcaddr->sa_family == AF_INET6)
417                         seq_printf(s, ",srcaddr=%pI6c",
418                                    &saddr6->sin6_addr);
419                 else if (srcaddr->sa_family == AF_INET)
420                         seq_printf(s, ",srcaddr=%pI4",
421                                    &saddr4->sin_addr.s_addr);
422                 else
423                         seq_printf(s, ",srcaddr=BAD-AF:%i",
424                                    (int)(srcaddr->sa_family));
425         }
426
427         seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
428         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
429                 seq_printf(s, ",forceuid");
430         else
431                 seq_printf(s, ",noforceuid");
432
433         seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
434         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
435                 seq_printf(s, ",forcegid");
436         else
437                 seq_printf(s, ",noforcegid");
438
439         cifs_show_address(s, tcon->ses->server);
440
441         if (!tcon->unix_ext)
442                 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
443                                            cifs_sb->mnt_file_mode,
444                                            cifs_sb->mnt_dir_mode);
445         if (tcon->seal)
446                 seq_printf(s, ",seal");
447         if (tcon->nocase)
448                 seq_printf(s, ",nocase");
449         if (tcon->retry)
450                 seq_printf(s, ",hard");
451         if (tcon->unix_ext)
452                 seq_printf(s, ",unix");
453         else
454                 seq_printf(s, ",nounix");
455         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
456                 seq_printf(s, ",posixpaths");
457         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
458                 seq_printf(s, ",setuids");
459         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
460                 seq_printf(s, ",serverino");
461         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
462                 seq_printf(s, ",rwpidforward");
463         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL)
464                 seq_printf(s, ",forcemand");
465         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
466                 seq_printf(s, ",directio");
467         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
468                 seq_printf(s, ",nouser_xattr");
469         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
470                 seq_printf(s, ",mapchars");
471         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
472                 seq_printf(s, ",sfu");
473         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
474                 seq_printf(s, ",nobrl");
475         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
476                 seq_printf(s, ",cifsacl");
477         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
478                 seq_printf(s, ",dynperm");
479         if (m->mnt_sb->s_flags & MS_POSIXACL)
480                 seq_printf(s, ",acl");
481         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
482                 seq_printf(s, ",mfsymlinks");
483         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
484                 seq_printf(s, ",fsc");
485
486         seq_printf(s, ",rsize=%d", cifs_sb->rsize);
487         seq_printf(s, ",wsize=%d", cifs_sb->wsize);
488         /* convert actimeo and display it in seconds */
489                 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
490
491         return 0;
492 }
493
494 static void cifs_umount_begin(struct super_block *sb)
495 {
496         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
497         struct cifs_tcon *tcon;
498
499         if (cifs_sb == NULL)
500                 return;
501
502         tcon = cifs_sb_master_tcon(cifs_sb);
503
504         spin_lock(&cifs_tcp_ses_lock);
505         if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
506                 /* we have other mounts to same share or we have
507                    already tried to force umount this and woken up
508                    all waiting network requests, nothing to do */
509                 spin_unlock(&cifs_tcp_ses_lock);
510                 return;
511         } else if (tcon->tc_count == 1)
512                 tcon->tidStatus = CifsExiting;
513         spin_unlock(&cifs_tcp_ses_lock);
514
515         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
516         /* cancel_notify_requests(tcon); */
517         if (tcon->ses && tcon->ses->server) {
518                 cFYI(1, "wake up tasks now - umount begin not complete");
519                 wake_up_all(&tcon->ses->server->request_q);
520                 wake_up_all(&tcon->ses->server->response_q);
521                 msleep(1); /* yield */
522                 /* we have to kick the requests once more */
523                 wake_up_all(&tcon->ses->server->response_q);
524                 msleep(1);
525         }
526
527         return;
528 }
529
530 #ifdef CONFIG_CIFS_STATS2
531 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
532 {
533         /* BB FIXME */
534         return 0;
535 }
536 #endif
537
538 static int cifs_remount(struct super_block *sb, int *flags, char *data)
539 {
540         *flags |= MS_NODIRATIME;
541         return 0;
542 }
543
544 static int cifs_drop_inode(struct inode *inode)
545 {
546         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
547
548         /* no serverino => unconditional eviction */
549         return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
550                 generic_drop_inode(inode);
551 }
552
553 static const struct super_operations cifs_super_ops = {
554         .put_super = cifs_put_super,
555         .statfs = cifs_statfs,
556         .alloc_inode = cifs_alloc_inode,
557         .destroy_inode = cifs_destroy_inode,
558         .drop_inode     = cifs_drop_inode,
559         .evict_inode    = cifs_evict_inode,
560 /*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
561         function unless later we add lazy close of inodes or unless the
562         kernel forgets to call us with the same number of releases (closes)
563         as opens */
564         .show_options = cifs_show_options,
565         .umount_begin   = cifs_umount_begin,
566         .remount_fs = cifs_remount,
567 #ifdef CONFIG_CIFS_STATS2
568         .show_stats = cifs_show_stats,
569 #endif
570 };
571
572 /*
573  * Get root dentry from superblock according to prefix path mount option.
574  * Return dentry with refcount + 1 on success and NULL otherwise.
575  */
576 static struct dentry *
577 cifs_get_root(struct smb_vol *vol, struct super_block *sb)
578 {
579         int xid, rc;
580         struct inode *inode;
581         struct qstr name;
582         struct dentry *dparent = NULL, *dchild = NULL, *alias;
583         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
584         unsigned int i, full_len, len;
585         char *full_path = NULL, *pstart;
586         char sep;
587
588         full_path = cifs_build_path_to_root(vol, cifs_sb,
589                                             cifs_sb_master_tcon(cifs_sb));
590         if (full_path == NULL)
591                 return NULL;
592
593         cFYI(1, "Get root dentry for %s", full_path);
594
595         xid = GetXid();
596         sep = CIFS_DIR_SEP(cifs_sb);
597         dparent = dget(sb->s_root);
598         full_len = strlen(full_path);
599         full_path[full_len] = sep;
600         pstart = full_path + 1;
601
602         for (i = 1, len = 0; i <= full_len; i++) {
603                 if (full_path[i] != sep || !len) {
604                         len++;
605                         continue;
606                 }
607
608                 full_path[i] = 0;
609                 cFYI(1, "get dentry for %s", pstart);
610
611                 name.name = pstart;
612                 name.len = len;
613                 name.hash = full_name_hash(pstart, len);
614                 dchild = d_lookup(dparent, &name);
615                 if (dchild == NULL) {
616                         cFYI(1, "not exists");
617                         dchild = d_alloc(dparent, &name);
618                         if (dchild == NULL) {
619                                 dput(dparent);
620                                 dparent = NULL;
621                                 goto out;
622                         }
623                 }
624
625                 cFYI(1, "get inode");
626                 if (dchild->d_inode == NULL) {
627                         cFYI(1, "not exists");
628                         inode = NULL;
629                         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
630                                 rc = cifs_get_inode_info_unix(&inode, full_path,
631                                                               sb, xid);
632                         else
633                                 rc = cifs_get_inode_info(&inode, full_path,
634                                                          NULL, sb, xid, NULL);
635                         if (rc) {
636                                 dput(dchild);
637                                 dput(dparent);
638                                 dparent = NULL;
639                                 goto out;
640                         }
641                         alias = d_materialise_unique(dchild, inode);
642                         if (alias != NULL) {
643                                 dput(dchild);
644                                 if (IS_ERR(alias)) {
645                                         dput(dparent);
646                                         dparent = NULL;
647                                         goto out;
648                                 }
649                                 dchild = alias;
650                         }
651                 }
652                 cFYI(1, "parent %p, child %p", dparent, dchild);
653
654                 dput(dparent);
655                 dparent = dchild;
656                 len = 0;
657                 pstart = full_path + i + 1;
658                 full_path[i] = sep;
659         }
660 out:
661         _FreeXid(xid);
662         kfree(full_path);
663         return dparent;
664 }
665
666 static struct dentry *
667 cifs_do_mount(struct file_system_type *fs_type,
668               int flags, const char *dev_name, void *data)
669 {
670         int rc;
671         struct super_block *sb;
672         struct cifs_sb_info *cifs_sb;
673         struct smb_vol *volume_info;
674         struct cifs_mnt_data mnt_data;
675         struct dentry *root;
676
677         cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
678
679         rc = cifs_setup_volume_info(&volume_info, (char *)data, dev_name);
680         if (rc)
681                 return ERR_PTR(rc);
682
683         cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
684         if (cifs_sb == NULL) {
685                 root = ERR_PTR(-ENOMEM);
686                 unload_nls(volume_info->local_nls);
687                 goto out;
688         }
689
690         cifs_setup_cifs_sb(volume_info, cifs_sb);
691
692         mnt_data.vol = volume_info;
693         mnt_data.cifs_sb = cifs_sb;
694         mnt_data.flags = flags;
695
696         sb = sget(fs_type, cifs_match_super, set_anon_super, &mnt_data);
697         if (IS_ERR(sb)) {
698                 root = ERR_CAST(sb);
699                 goto out_cifs_sb;
700         }
701
702         if (sb->s_fs_info) {
703                 cFYI(1, "Use existing superblock");
704                 goto out_shared;
705         }
706
707         /*
708          * Copy mount params for use in submounts. Better to do
709          * the copy here and deal with the error before cleanup gets
710          * complicated post-mount.
711          */
712         cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
713         if (cifs_sb->mountdata == NULL) {
714                 root = ERR_PTR(-ENOMEM);
715                 goto out_super;
716         }
717
718         sb->s_flags = flags;
719         /* BB should we make this contingent on mount parm? */
720         sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
721         sb->s_fs_info = cifs_sb;
722
723         rc = cifs_read_super(sb, volume_info, dev_name,
724                              flags & MS_SILENT ? 1 : 0);
725         if (rc) {
726                 root = ERR_PTR(rc);
727                 goto out_super;
728         }
729
730         sb->s_flags |= MS_ACTIVE;
731
732         root = cifs_get_root(volume_info, sb);
733         if (root == NULL)
734                 goto out_super;
735
736         cFYI(1, "dentry root is: %p", root);
737         goto out;
738
739 out_shared:
740         root = cifs_get_root(volume_info, sb);
741         if (root)
742                 cFYI(1, "dentry root is: %p", root);
743         goto out;
744
745 out_super:
746         deactivate_locked_super(sb);
747         goto out;
748
749 out_cifs_sb:
750         unload_nls(cifs_sb->local_nls);
751         kfree(cifs_sb);
752
753 out:
754         cifs_cleanup_volume_info(&volume_info);
755         return root;
756 }
757
758 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
759                                    unsigned long nr_segs, loff_t pos)
760 {
761         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
762         ssize_t written;
763         int rc;
764
765         written = generic_file_aio_write(iocb, iov, nr_segs, pos);
766
767         if (CIFS_I(inode)->clientCanCacheAll)
768                 return written;
769
770         rc = filemap_fdatawrite(inode->i_mapping);
771         if (rc)
772                 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
773
774         return written;
775 }
776
777 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
778 {
779         /* origin == SEEK_END => we must revalidate the cached file length */
780         if (origin == SEEK_END) {
781                 int rc;
782                 struct inode *inode = file->f_path.dentry->d_inode;
783
784                 /*
785                  * We need to be sure that all dirty pages are written and the
786                  * server has the newest file length.
787                  */
788                 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
789                     inode->i_mapping->nrpages != 0) {
790                         rc = filemap_fdatawait(inode->i_mapping);
791                         if (rc) {
792                                 mapping_set_error(inode->i_mapping, rc);
793                                 return rc;
794                         }
795                 }
796                 /*
797                  * Some applications poll for the file length in this strange
798                  * way so we must seek to end on non-oplocked files by
799                  * setting the revalidate time to zero.
800                  */
801                 CIFS_I(inode)->time = 0;
802
803                 rc = cifs_revalidate_file_attr(file);
804                 if (rc < 0)
805                         return (loff_t)rc;
806         }
807         return generic_file_llseek_unlocked(file, offset, origin);
808 }
809
810 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
811 {
812         /* note that this is called by vfs setlease with lock_flocks held
813            to protect *lease from going away */
814         struct inode *inode = file->f_path.dentry->d_inode;
815         struct cifsFileInfo *cfile = file->private_data;
816
817         if (!(S_ISREG(inode->i_mode)))
818                 return -EINVAL;
819
820         /* check if file is oplocked */
821         if (((arg == F_RDLCK) &&
822                 (CIFS_I(inode)->clientCanCacheRead)) ||
823             ((arg == F_WRLCK) &&
824                 (CIFS_I(inode)->clientCanCacheAll)))
825                 return generic_setlease(file, arg, lease);
826         else if (tlink_tcon(cfile->tlink)->local_lease &&
827                  !CIFS_I(inode)->clientCanCacheRead)
828                 /* If the server claims to support oplock on this
829                    file, then we still need to check oplock even
830                    if the local_lease mount option is set, but there
831                    are servers which do not support oplock for which
832                    this mount option may be useful if the user
833                    knows that the file won't be changed on the server
834                    by anyone else */
835                 return generic_setlease(file, arg, lease);
836         else
837                 return -EAGAIN;
838 }
839
840 struct file_system_type cifs_fs_type = {
841         .owner = THIS_MODULE,
842         .name = "cifs",
843         .mount = cifs_do_mount,
844         .kill_sb = cifs_kill_sb,
845         /*  .fs_flags */
846 };
847 const struct inode_operations cifs_dir_inode_ops = {
848         .create = cifs_create,
849         .lookup = cifs_lookup,
850         .getattr = cifs_getattr,
851         .unlink = cifs_unlink,
852         .link = cifs_hardlink,
853         .mkdir = cifs_mkdir,
854         .rmdir = cifs_rmdir,
855         .rename = cifs_rename,
856         .permission = cifs_permission,
857 /*      revalidate:cifs_revalidate,   */
858         .setattr = cifs_setattr,
859         .symlink = cifs_symlink,
860         .mknod   = cifs_mknod,
861 #ifdef CONFIG_CIFS_XATTR
862         .setxattr = cifs_setxattr,
863         .getxattr = cifs_getxattr,
864         .listxattr = cifs_listxattr,
865         .removexattr = cifs_removexattr,
866 #endif
867 };
868
869 const struct inode_operations cifs_file_inode_ops = {
870 /*      revalidate:cifs_revalidate, */
871         .setattr = cifs_setattr,
872         .getattr = cifs_getattr, /* do we need this anymore? */
873         .rename = cifs_rename,
874         .permission = cifs_permission,
875 #ifdef CONFIG_CIFS_XATTR
876         .setxattr = cifs_setxattr,
877         .getxattr = cifs_getxattr,
878         .listxattr = cifs_listxattr,
879         .removexattr = cifs_removexattr,
880 #endif
881 };
882
883 const struct inode_operations cifs_symlink_inode_ops = {
884         .readlink = generic_readlink,
885         .follow_link = cifs_follow_link,
886         .put_link = cifs_put_link,
887         .permission = cifs_permission,
888         /* BB add the following two eventually */
889         /* revalidate: cifs_revalidate,
890            setattr:    cifs_notify_change, *//* BB do we need notify change */
891 #ifdef CONFIG_CIFS_XATTR
892         .setxattr = cifs_setxattr,
893         .getxattr = cifs_getxattr,
894         .listxattr = cifs_listxattr,
895         .removexattr = cifs_removexattr,
896 #endif
897 };
898
899 const struct file_operations cifs_file_ops = {
900         .read = do_sync_read,
901         .write = do_sync_write,
902         .aio_read = generic_file_aio_read,
903         .aio_write = cifs_file_aio_write,
904         .open = cifs_open,
905         .release = cifs_close,
906         .lock = cifs_lock,
907         .fsync = cifs_fsync,
908         .flush = cifs_flush,
909         .mmap  = cifs_file_mmap,
910         .splice_read = generic_file_splice_read,
911         .llseek = cifs_llseek,
912 #ifdef CONFIG_CIFS_POSIX
913         .unlocked_ioctl = cifs_ioctl,
914 #endif /* CONFIG_CIFS_POSIX */
915         .setlease = cifs_setlease,
916 };
917
918 const struct file_operations cifs_file_strict_ops = {
919         .read = do_sync_read,
920         .write = do_sync_write,
921         .aio_read = cifs_strict_readv,
922         .aio_write = cifs_strict_writev,
923         .open = cifs_open,
924         .release = cifs_close,
925         .lock = cifs_lock,
926         .fsync = cifs_strict_fsync,
927         .flush = cifs_flush,
928         .mmap = cifs_file_strict_mmap,
929         .splice_read = generic_file_splice_read,
930         .llseek = cifs_llseek,
931 #ifdef CONFIG_CIFS_POSIX
932         .unlocked_ioctl = cifs_ioctl,
933 #endif /* CONFIG_CIFS_POSIX */
934         .setlease = cifs_setlease,
935 };
936
937 const struct file_operations cifs_file_direct_ops = {
938         /* BB reevaluate whether they can be done with directio, no cache */
939         .read = do_sync_read,
940         .write = do_sync_write,
941         .aio_read = cifs_user_readv,
942         .aio_write = cifs_user_writev,
943         .open = cifs_open,
944         .release = cifs_close,
945         .lock = cifs_lock,
946         .fsync = cifs_fsync,
947         .flush = cifs_flush,
948         .mmap = cifs_file_mmap,
949         .splice_read = generic_file_splice_read,
950 #ifdef CONFIG_CIFS_POSIX
951         .unlocked_ioctl  = cifs_ioctl,
952 #endif /* CONFIG_CIFS_POSIX */
953         .llseek = cifs_llseek,
954         .setlease = cifs_setlease,
955 };
956
957 const struct file_operations cifs_file_nobrl_ops = {
958         .read = do_sync_read,
959         .write = do_sync_write,
960         .aio_read = generic_file_aio_read,
961         .aio_write = cifs_file_aio_write,
962         .open = cifs_open,
963         .release = cifs_close,
964         .fsync = cifs_fsync,
965         .flush = cifs_flush,
966         .mmap  = cifs_file_mmap,
967         .splice_read = generic_file_splice_read,
968         .llseek = cifs_llseek,
969 #ifdef CONFIG_CIFS_POSIX
970         .unlocked_ioctl = cifs_ioctl,
971 #endif /* CONFIG_CIFS_POSIX */
972         .setlease = cifs_setlease,
973 };
974
975 const struct file_operations cifs_file_strict_nobrl_ops = {
976         .read = do_sync_read,
977         .write = do_sync_write,
978         .aio_read = cifs_strict_readv,
979         .aio_write = cifs_strict_writev,
980         .open = cifs_open,
981         .release = cifs_close,
982         .fsync = cifs_strict_fsync,
983         .flush = cifs_flush,
984         .mmap = cifs_file_strict_mmap,
985         .splice_read = generic_file_splice_read,
986         .llseek = cifs_llseek,
987 #ifdef CONFIG_CIFS_POSIX
988         .unlocked_ioctl = cifs_ioctl,
989 #endif /* CONFIG_CIFS_POSIX */
990         .setlease = cifs_setlease,
991 };
992
993 const struct file_operations cifs_file_direct_nobrl_ops = {
994         /* BB reevaluate whether they can be done with directio, no cache */
995         .read = do_sync_read,
996         .write = do_sync_write,
997         .aio_read = cifs_user_readv,
998         .aio_write = cifs_user_writev,
999         .open = cifs_open,
1000         .release = cifs_close,
1001         .fsync = cifs_fsync,
1002         .flush = cifs_flush,
1003         .mmap = cifs_file_mmap,
1004         .splice_read = generic_file_splice_read,
1005 #ifdef CONFIG_CIFS_POSIX
1006         .unlocked_ioctl  = cifs_ioctl,
1007 #endif /* CONFIG_CIFS_POSIX */
1008         .llseek = cifs_llseek,
1009         .setlease = cifs_setlease,
1010 };
1011
1012 const struct file_operations cifs_dir_ops = {
1013         .readdir = cifs_readdir,
1014         .release = cifs_closedir,
1015         .read    = generic_read_dir,
1016         .unlocked_ioctl  = cifs_ioctl,
1017         .llseek = generic_file_llseek,
1018 };
1019
1020 static void
1021 cifs_init_once(void *inode)
1022 {
1023         struct cifsInodeInfo *cifsi = inode;
1024
1025         inode_init_once(&cifsi->vfs_inode);
1026         INIT_LIST_HEAD(&cifsi->lockList);
1027 }
1028
1029 static int
1030 cifs_init_inodecache(void)
1031 {
1032         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
1033                                               sizeof(struct cifsInodeInfo),
1034                                               0, (SLAB_RECLAIM_ACCOUNT|
1035                                                 SLAB_MEM_SPREAD),
1036                                               cifs_init_once);
1037         if (cifs_inode_cachep == NULL)
1038                 return -ENOMEM;
1039
1040         return 0;
1041 }
1042
1043 static void
1044 cifs_destroy_inodecache(void)
1045 {
1046         kmem_cache_destroy(cifs_inode_cachep);
1047 }
1048
1049 static int
1050 cifs_init_request_bufs(void)
1051 {
1052         if (CIFSMaxBufSize < 8192) {
1053         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
1054         Unicode path name has to fit in any SMB/CIFS path based frames */
1055                 CIFSMaxBufSize = 8192;
1056         } else if (CIFSMaxBufSize > 1024*127) {
1057                 CIFSMaxBufSize = 1024 * 127;
1058         } else {
1059                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
1060         }
1061 /*      cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
1062         cifs_req_cachep = kmem_cache_create("cifs_request",
1063                                             CIFSMaxBufSize +
1064                                             MAX_CIFS_HDR_SIZE, 0,
1065                                             SLAB_HWCACHE_ALIGN, NULL);
1066         if (cifs_req_cachep == NULL)
1067                 return -ENOMEM;
1068
1069         if (cifs_min_rcv < 1)
1070                 cifs_min_rcv = 1;
1071         else if (cifs_min_rcv > 64) {
1072                 cifs_min_rcv = 64;
1073                 cERROR(1, "cifs_min_rcv set to maximum (64)");
1074         }
1075
1076         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
1077                                                   cifs_req_cachep);
1078
1079         if (cifs_req_poolp == NULL) {
1080                 kmem_cache_destroy(cifs_req_cachep);
1081                 return -ENOMEM;
1082         }
1083         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
1084         almost all handle based requests (but not write response, nor is it
1085         sufficient for path based requests).  A smaller size would have
1086         been more efficient (compacting multiple slab items on one 4k page)
1087         for the case in which debug was on, but this larger size allows
1088         more SMBs to use small buffer alloc and is still much more
1089         efficient to alloc 1 per page off the slab compared to 17K (5page)
1090         alloc of large cifs buffers even when page debugging is on */
1091         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
1092                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
1093                         NULL);
1094         if (cifs_sm_req_cachep == NULL) {
1095                 mempool_destroy(cifs_req_poolp);
1096                 kmem_cache_destroy(cifs_req_cachep);
1097                 return -ENOMEM;
1098         }
1099
1100         if (cifs_min_small < 2)
1101                 cifs_min_small = 2;
1102         else if (cifs_min_small > 256) {
1103                 cifs_min_small = 256;
1104                 cFYI(1, "cifs_min_small set to maximum (256)");
1105         }
1106
1107         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
1108                                                      cifs_sm_req_cachep);
1109
1110         if (cifs_sm_req_poolp == NULL) {
1111                 mempool_destroy(cifs_req_poolp);
1112                 kmem_cache_destroy(cifs_req_cachep);
1113                 kmem_cache_destroy(cifs_sm_req_cachep);
1114                 return -ENOMEM;
1115         }
1116
1117         return 0;
1118 }
1119
1120 static void
1121 cifs_destroy_request_bufs(void)
1122 {
1123         mempool_destroy(cifs_req_poolp);
1124         kmem_cache_destroy(cifs_req_cachep);
1125         mempool_destroy(cifs_sm_req_poolp);
1126         kmem_cache_destroy(cifs_sm_req_cachep);
1127 }
1128
1129 static int
1130 cifs_init_mids(void)
1131 {
1132         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
1133                                             sizeof(struct mid_q_entry), 0,
1134                                             SLAB_HWCACHE_ALIGN, NULL);
1135         if (cifs_mid_cachep == NULL)
1136                 return -ENOMEM;
1137
1138         /* 3 is a reasonable minimum number of simultaneous operations */
1139         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
1140         if (cifs_mid_poolp == NULL) {
1141                 kmem_cache_destroy(cifs_mid_cachep);
1142                 return -ENOMEM;
1143         }
1144
1145         return 0;
1146 }
1147
1148 static void
1149 cifs_destroy_mids(void)
1150 {
1151         mempool_destroy(cifs_mid_poolp);
1152         kmem_cache_destroy(cifs_mid_cachep);
1153 }
1154
1155 static int __init
1156 init_cifs(void)
1157 {
1158         int rc = 0;
1159         cifs_proc_init();
1160         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1161 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1162         INIT_LIST_HEAD(&GlobalDnotifyReqList);
1163         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1164 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1165 /*
1166  *  Initialize Global counters
1167  */
1168         atomic_set(&sesInfoAllocCount, 0);
1169         atomic_set(&tconInfoAllocCount, 0);
1170         atomic_set(&tcpSesAllocCount, 0);
1171         atomic_set(&tcpSesReconnectCount, 0);
1172         atomic_set(&tconInfoReconnectCount, 0);
1173
1174         atomic_set(&bufAllocCount, 0);
1175         atomic_set(&smBufAllocCount, 0);
1176 #ifdef CONFIG_CIFS_STATS2
1177         atomic_set(&totBufAllocCount, 0);
1178         atomic_set(&totSmBufAllocCount, 0);
1179 #endif /* CONFIG_CIFS_STATS2 */
1180
1181         atomic_set(&midCount, 0);
1182         GlobalCurrentXid = 0;
1183         GlobalTotalActiveXid = 0;
1184         GlobalMaxActiveXid = 0;
1185         spin_lock_init(&cifs_tcp_ses_lock);
1186         spin_lock_init(&cifs_file_list_lock);
1187         spin_lock_init(&GlobalMid_Lock);
1188
1189         if (cifs_max_pending < 2) {
1190                 cifs_max_pending = 2;
1191                 cFYI(1, "cifs_max_pending set to min of 2");
1192         } else if (cifs_max_pending > 256) {
1193                 cifs_max_pending = 256;
1194                 cFYI(1, "cifs_max_pending set to max of 256");
1195         }
1196
1197         rc = cifs_fscache_register();
1198         if (rc)
1199                 goto out_clean_proc;
1200
1201         rc = cifs_init_inodecache();
1202         if (rc)
1203                 goto out_unreg_fscache;
1204
1205         rc = cifs_init_mids();
1206         if (rc)
1207                 goto out_destroy_inodecache;
1208
1209         rc = cifs_init_request_bufs();
1210         if (rc)
1211                 goto out_destroy_mids;
1212
1213 #ifdef CONFIG_CIFS_UPCALL
1214         rc = register_key_type(&cifs_spnego_key_type);
1215         if (rc)
1216                 goto out_destroy_request_bufs;
1217 #endif /* CONFIG_CIFS_UPCALL */
1218
1219 #ifdef CONFIG_CIFS_ACL
1220         rc = init_cifs_idmap();
1221         if (rc)
1222                 goto out_register_key_type;
1223 #endif /* CONFIG_CIFS_ACL */
1224
1225         rc = register_filesystem(&cifs_fs_type);
1226         if (rc)
1227                 goto out_init_cifs_idmap;
1228
1229         return 0;
1230
1231 out_init_cifs_idmap:
1232 #ifdef CONFIG_CIFS_ACL
1233         exit_cifs_idmap();
1234 out_register_key_type:
1235 #endif
1236 #ifdef CONFIG_CIFS_UPCALL
1237         unregister_key_type(&cifs_spnego_key_type);
1238 out_destroy_request_bufs:
1239 #endif
1240         cifs_destroy_request_bufs();
1241 out_destroy_mids:
1242         cifs_destroy_mids();
1243 out_destroy_inodecache:
1244         cifs_destroy_inodecache();
1245 out_unreg_fscache:
1246         cifs_fscache_unregister();
1247 out_clean_proc:
1248         cifs_proc_clean();
1249         return rc;
1250 }
1251
1252 static void __exit
1253 exit_cifs(void)
1254 {
1255         cFYI(DBG2, "exit_cifs");
1256         cifs_proc_clean();
1257         cifs_fscache_unregister();
1258 #ifdef CONFIG_CIFS_DFS_UPCALL
1259         cifs_dfs_release_automount_timer();
1260 #endif
1261 #ifdef CONFIG_CIFS_ACL
1262         cifs_destroy_idmaptrees();
1263         exit_cifs_idmap();
1264 #endif
1265 #ifdef CONFIG_CIFS_UPCALL
1266         unregister_key_type(&cifs_spnego_key_type);
1267 #endif
1268         unregister_filesystem(&cifs_fs_type);
1269         cifs_destroy_inodecache();
1270         cifs_destroy_mids();
1271         cifs_destroy_request_bufs();
1272 }
1273
1274 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1275 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1276 MODULE_DESCRIPTION
1277     ("VFS to access servers complying with the SNIA CIFS Specification "
1278      "e.g. Samba and Windows");
1279 MODULE_VERSION(CIFS_VERSION);
1280 module_init(init_cifs)
1281 module_exit(exit_cifs)