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