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