8a2cf129e535a21a8cd8bf7bc9116e2bbbd025da
[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 <linux/smp_lock.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 "dns_resolve.h"
49 #include "cifs_spnego.h"
50 #include "fscache.h"
51 #define CIFS_MAGIC_NUMBER 0xFF534D42    /* the first four bytes of SMB PDUs */
52
53 int cifsFYI = 0;
54 int cifsERROR = 1;
55 int traceSMB = 0;
56 unsigned int oplockEnabled = 1;
57 unsigned int experimEnabled = 0;
58 unsigned int linuxExtEnabled = 1;
59 unsigned int lookupCacheEnabled = 1;
60 unsigned int multiuser_mount = 0;
61 unsigned int global_secflags = CIFSSEC_DEF;
62 /* unsigned int ntlmv2_support = 0; */
63 unsigned int sign_CIFS_PDUs = 1;
64 static const struct super_operations cifs_super_ops;
65 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
66 module_param(CIFSMaxBufSize, int, 0);
67 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
68                                  "Default: 16384 Range: 8192 to 130048");
69 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
70 module_param(cifs_min_rcv, int, 0);
71 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
72                                 "1 to 64");
73 unsigned int cifs_min_small = 30;
74 module_param(cifs_min_small, int, 0);
75 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
76                                  "Range: 2 to 256");
77 unsigned int cifs_max_pending = CIFS_MAX_REQ;
78 module_param(cifs_max_pending, int, 0);
79 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
80                                    "Default: 50 Range: 2 to 256");
81
82 extern mempool_t *cifs_sm_req_poolp;
83 extern mempool_t *cifs_req_poolp;
84 extern mempool_t *cifs_mid_poolp;
85
86 static int
87 cifs_read_super(struct super_block *sb, void *data,
88                 const char *devname, int silent)
89 {
90         struct inode *inode;
91         struct cifs_sb_info *cifs_sb;
92         int rc = 0;
93
94         /* BB should we make this contingent on mount parm? */
95         sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
96         sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
97         cifs_sb = CIFS_SB(sb);
98         if (cifs_sb == NULL)
99                 return -ENOMEM;
100
101         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
102         if (rc) {
103                 kfree(cifs_sb);
104                 return rc;
105         }
106
107 #ifdef CONFIG_CIFS_DFS_UPCALL
108         /* copy mount params to sb for use in submounts */
109         /* BB: should we move this after the mount so we
110          * do not have to do the copy on failed mounts?
111          * BB: May be it is better to do simple copy before
112          * complex operation (mount), and in case of fail
113          * just exit instead of doing mount and attempting
114          * undo it if this copy fails?*/
115         if (data) {
116                 int len = strlen(data);
117                 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
118                 if (cifs_sb->mountdata == NULL) {
119                         bdi_destroy(&cifs_sb->bdi);
120                         kfree(sb->s_fs_info);
121                         sb->s_fs_info = NULL;
122                         return -ENOMEM;
123                 }
124                 strncpy(cifs_sb->mountdata, data, len + 1);
125                 cifs_sb->mountdata[len] = '\0';
126         }
127 #endif
128
129         rc = cifs_mount(sb, cifs_sb, data, devname);
130
131         if (rc) {
132                 if (!silent)
133                         cERROR(1, "cifs_mount failed w/return code = %d", rc);
134                 goto out_mount_failed;
135         }
136
137         sb->s_magic = CIFS_MAGIC_NUMBER;
138         sb->s_op = &cifs_super_ops;
139         sb->s_bdi = &cifs_sb->bdi;
140 /*      if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
141             sb->s_blocksize =
142                 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
143         sb->s_blocksize = CIFS_MAX_MSGSIZE;
144         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
145         inode = cifs_root_iget(sb, ROOT_I);
146
147         if (IS_ERR(inode)) {
148                 rc = PTR_ERR(inode);
149                 inode = NULL;
150                 goto out_no_root;
151         }
152
153         sb->s_root = d_alloc_root(inode);
154
155         if (!sb->s_root) {
156                 rc = -ENOMEM;
157                 goto out_no_root;
158         }
159
160 #ifdef CONFIG_CIFS_EXPERIMENTAL
161         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
162                 cFYI(1, "export ops supported");
163                 sb->s_export_op = &cifs_export_ops;
164         }
165 #endif /* EXPERIMENTAL */
166
167         return 0;
168
169 out_no_root:
170         cERROR(1, "cifs_read_super: get root inode failed");
171         if (inode)
172                 iput(inode);
173
174         cifs_umount(sb, cifs_sb);
175
176 out_mount_failed:
177         if (cifs_sb) {
178 #ifdef CONFIG_CIFS_DFS_UPCALL
179                 if (cifs_sb->mountdata) {
180                         kfree(cifs_sb->mountdata);
181                         cifs_sb->mountdata = NULL;
182                 }
183 #endif
184                 unload_nls(cifs_sb->local_nls);
185                 bdi_destroy(&cifs_sb->bdi);
186                 kfree(cifs_sb);
187         }
188         return rc;
189 }
190
191 static void
192 cifs_put_super(struct super_block *sb)
193 {
194         int rc = 0;
195         struct cifs_sb_info *cifs_sb;
196
197         cFYI(1, "In cifs_put_super");
198         cifs_sb = CIFS_SB(sb);
199         if (cifs_sb == NULL) {
200                 cFYI(1, "Empty cifs superblock info passed to unmount");
201                 return;
202         }
203
204         lock_kernel();
205
206         rc = cifs_umount(sb, cifs_sb);
207         if (rc)
208                 cERROR(1, "cifs_umount failed with return code %d", rc);
209 #ifdef CONFIG_CIFS_DFS_UPCALL
210         if (cifs_sb->mountdata) {
211                 kfree(cifs_sb->mountdata);
212                 cifs_sb->mountdata = NULL;
213         }
214 #endif
215
216         unload_nls(cifs_sb->local_nls);
217         bdi_destroy(&cifs_sb->bdi);
218         kfree(cifs_sb);
219
220         unlock_kernel();
221 }
222
223 static int
224 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
225 {
226         struct super_block *sb = dentry->d_sb;
227         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
228         struct cifsTconInfo *tcon = cifs_sb->tcon;
229         int rc = -EOPNOTSUPP;
230         int xid;
231
232         xid = GetXid();
233
234         buf->f_type = CIFS_MAGIC_NUMBER;
235
236         /*
237          * PATH_MAX may be too long - it would presumably be total path,
238          * but note that some servers (includinng Samba 3) have a shorter
239          * maximum path.
240          *
241          * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
242          */
243         buf->f_namelen = PATH_MAX;
244         buf->f_files = 0;       /* undefined */
245         buf->f_ffree = 0;       /* unlimited */
246
247         /*
248          * We could add a second check for a QFS Unix capability bit
249          */
250         if ((tcon->ses->capabilities & CAP_UNIX) &&
251             (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
252                 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
253
254         /*
255          * Only need to call the old QFSInfo if failed on newer one,
256          * e.g. by OS/2.
257          **/
258         if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
259                 rc = CIFSSMBQFSInfo(xid, tcon, buf);
260
261         /*
262          * Some old Windows servers also do not support level 103, retry with
263          * older level one if old server failed the previous call or we
264          * bypassed it because we detected that this was an older LANMAN sess
265          */
266         if (rc)
267                 rc = SMBOldQFSInfo(xid, tcon, buf);
268
269         FreeXid(xid);
270         return 0;
271 }
272
273 static int cifs_permission(struct inode *inode, int mask)
274 {
275         struct cifs_sb_info *cifs_sb;
276
277         cifs_sb = CIFS_SB(inode->i_sb);
278
279         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
280                 if ((mask & MAY_EXEC) && !execute_ok(inode))
281                         return -EACCES;
282                 else
283                         return 0;
284         } else /* file mode might have been restricted at mount time
285                 on the client (above and beyond ACL on servers) for
286                 servers which do not support setting and viewing mode bits,
287                 so allowing client to check permissions is useful */
288                 return generic_permission(inode, mask, NULL);
289 }
290
291 static struct kmem_cache *cifs_inode_cachep;
292 static struct kmem_cache *cifs_req_cachep;
293 static struct kmem_cache *cifs_mid_cachep;
294 static struct kmem_cache *cifs_sm_req_cachep;
295 mempool_t *cifs_sm_req_poolp;
296 mempool_t *cifs_req_poolp;
297 mempool_t *cifs_mid_poolp;
298
299 static struct inode *
300 cifs_alloc_inode(struct super_block *sb)
301 {
302         struct cifsInodeInfo *cifs_inode;
303         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
304         if (!cifs_inode)
305                 return NULL;
306         cifs_inode->cifsAttrs = 0x20;   /* default */
307         cifs_inode->time = 0;
308         cifs_inode->write_behind_rc = 0;
309         /* Until the file is open and we have gotten oplock
310         info back from the server, can not assume caching of
311         file data or metadata */
312         cifs_inode->clientCanCacheRead = false;
313         cifs_inode->clientCanCacheAll = false;
314         cifs_inode->delete_pending = false;
315         cifs_inode->invalid_mapping = false;
316         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
317         cifs_inode->server_eof = 0;
318
319         /* Can not set i_flags here - they get immediately overwritten
320            to zero by the VFS */
321 /*      cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
322         INIT_LIST_HEAD(&cifs_inode->openFileList);
323         return &cifs_inode->vfs_inode;
324 }
325
326 static void
327 cifs_destroy_inode(struct inode *inode)
328 {
329         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
330 }
331
332 static void
333 cifs_clear_inode(struct inode *inode)
334 {
335         cifs_fscache_release_inode_cookie(inode);
336 }
337
338 static void
339 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
340 {
341         seq_printf(s, ",addr=");
342
343         switch (server->addr.sockAddr.sin_family) {
344         case AF_INET:
345                 seq_printf(s, "%pI4", &server->addr.sockAddr.sin_addr.s_addr);
346                 break;
347         case AF_INET6:
348                 seq_printf(s, "%pI6",
349                            &server->addr.sockAddr6.sin6_addr.s6_addr);
350                 if (server->addr.sockAddr6.sin6_scope_id)
351                         seq_printf(s, "%%%u",
352                                    server->addr.sockAddr6.sin6_scope_id);
353                 break;
354         default:
355                 seq_printf(s, "(unknown)");
356         }
357 }
358
359 /*
360  * cifs_show_options() is for displaying mount options in /proc/mounts.
361  * Not all settable options are displayed but most of the important
362  * ones are.
363  */
364 static int
365 cifs_show_options(struct seq_file *s, struct vfsmount *m)
366 {
367         struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
368         struct cifsTconInfo *tcon = cifs_sb->tcon;
369
370         seq_printf(s, ",unc=%s", tcon->treeName);
371         if (tcon->ses->userName)
372                 seq_printf(s, ",username=%s", tcon->ses->userName);
373         if (tcon->ses->domainName)
374                 seq_printf(s, ",domain=%s", tcon->ses->domainName);
375
376         seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
377         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
378                 seq_printf(s, ",forceuid");
379         else
380                 seq_printf(s, ",noforceuid");
381
382         seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
383         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
384                 seq_printf(s, ",forcegid");
385         else
386                 seq_printf(s, ",noforcegid");
387
388         cifs_show_address(s, tcon->ses->server);
389
390         if (!tcon->unix_ext)
391                 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
392                                            cifs_sb->mnt_file_mode,
393                                            cifs_sb->mnt_dir_mode);
394         if (tcon->seal)
395                 seq_printf(s, ",seal");
396         if (tcon->nocase)
397                 seq_printf(s, ",nocase");
398         if (tcon->retry)
399                 seq_printf(s, ",hard");
400         if (cifs_sb->prepath)
401                 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
402         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
403                 seq_printf(s, ",posixpaths");
404         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
405                 seq_printf(s, ",setuids");
406         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
407                 seq_printf(s, ",serverino");
408         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
409                 seq_printf(s, ",directio");
410         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
411                 seq_printf(s, ",nouser_xattr");
412         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
413                 seq_printf(s, ",mapchars");
414         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
415                 seq_printf(s, ",sfu");
416         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
417                 seq_printf(s, ",nobrl");
418         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
419                 seq_printf(s, ",cifsacl");
420         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
421                 seq_printf(s, ",dynperm");
422         if (m->mnt_sb->s_flags & MS_POSIXACL)
423                 seq_printf(s, ",acl");
424
425         seq_printf(s, ",rsize=%d", cifs_sb->rsize);
426         seq_printf(s, ",wsize=%d", cifs_sb->wsize);
427
428         return 0;
429 }
430
431 static void cifs_umount_begin(struct super_block *sb)
432 {
433         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
434         struct cifsTconInfo *tcon;
435
436         if (cifs_sb == NULL)
437                 return;
438
439         tcon = cifs_sb->tcon;
440         if (tcon == NULL)
441                 return;
442
443         read_lock(&cifs_tcp_ses_lock);
444         if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
445                 /* we have other mounts to same share or we have
446                    already tried to force umount this and woken up
447                    all waiting network requests, nothing to do */
448                 read_unlock(&cifs_tcp_ses_lock);
449                 return;
450         } else if (tcon->tc_count == 1)
451                 tcon->tidStatus = CifsExiting;
452         read_unlock(&cifs_tcp_ses_lock);
453
454         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
455         /* cancel_notify_requests(tcon); */
456         if (tcon->ses && tcon->ses->server) {
457                 cFYI(1, "wake up tasks now - umount begin not complete");
458                 wake_up_all(&tcon->ses->server->request_q);
459                 wake_up_all(&tcon->ses->server->response_q);
460                 msleep(1); /* yield */
461                 /* we have to kick the requests once more */
462                 wake_up_all(&tcon->ses->server->response_q);
463                 msleep(1);
464         }
465
466         return;
467 }
468
469 #ifdef CONFIG_CIFS_STATS2
470 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
471 {
472         /* BB FIXME */
473         return 0;
474 }
475 #endif
476
477 static int cifs_remount(struct super_block *sb, int *flags, char *data)
478 {
479         *flags |= MS_NODIRATIME;
480         return 0;
481 }
482
483 void cifs_drop_inode(struct inode *inode)
484 {
485         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
486
487         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
488                 return generic_drop_inode(inode);
489
490         return generic_delete_inode(inode);
491 }
492
493 static const struct super_operations cifs_super_ops = {
494         .put_super = cifs_put_super,
495         .statfs = cifs_statfs,
496         .alloc_inode = cifs_alloc_inode,
497         .destroy_inode = cifs_destroy_inode,
498         .drop_inode     = cifs_drop_inode,
499         .clear_inode    = cifs_clear_inode,
500 /*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
501         function unless later we add lazy close of inodes or unless the
502         kernel forgets to call us with the same number of releases (closes)
503         as opens */
504         .show_options = cifs_show_options,
505         .umount_begin   = cifs_umount_begin,
506         .remount_fs = cifs_remount,
507 #ifdef CONFIG_CIFS_STATS2
508         .show_stats = cifs_show_stats,
509 #endif
510 };
511
512 static int
513 cifs_get_sb(struct file_system_type *fs_type,
514             int flags, const char *dev_name, void *data, struct vfsmount *mnt)
515 {
516         int rc;
517         struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
518
519         cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
520
521         if (IS_ERR(sb))
522                 return PTR_ERR(sb);
523
524         sb->s_flags = flags;
525
526         rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
527         if (rc) {
528                 deactivate_locked_super(sb);
529                 return rc;
530         }
531         sb->s_flags |= MS_ACTIVE;
532         simple_set_mnt(mnt, sb);
533         return 0;
534 }
535
536 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
537                                    unsigned long nr_segs, loff_t pos)
538 {
539         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
540         ssize_t written;
541
542         written = generic_file_aio_write(iocb, iov, nr_segs, pos);
543         if (!CIFS_I(inode)->clientCanCacheAll)
544                 filemap_fdatawrite(inode->i_mapping);
545         return written;
546 }
547
548 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
549 {
550         /* origin == SEEK_END => we must revalidate the cached file length */
551         if (origin == SEEK_END) {
552                 int retval;
553
554                 /* some applications poll for the file length in this strange
555                    way so we must seek to end on non-oplocked files by
556                    setting the revalidate time to zero */
557                 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
558
559                 retval = cifs_revalidate_file(file);
560                 if (retval < 0)
561                         return (loff_t)retval;
562         }
563         return generic_file_llseek_unlocked(file, offset, origin);
564 }
565
566 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
567 {
568         /* note that this is called by vfs setlease with the BKL held
569            although I doubt that BKL is needed here in cifs */
570         struct inode *inode = file->f_path.dentry->d_inode;
571
572         if (!(S_ISREG(inode->i_mode)))
573                 return -EINVAL;
574
575         /* check if file is oplocked */
576         if (((arg == F_RDLCK) &&
577                 (CIFS_I(inode)->clientCanCacheRead)) ||
578             ((arg == F_WRLCK) &&
579                 (CIFS_I(inode)->clientCanCacheAll)))
580                 return generic_setlease(file, arg, lease);
581         else if (CIFS_SB(inode->i_sb)->tcon->local_lease &&
582                         !CIFS_I(inode)->clientCanCacheRead)
583                 /* If the server claims to support oplock on this
584                    file, then we still need to check oplock even
585                    if the local_lease mount option is set, but there
586                    are servers which do not support oplock for which
587                    this mount option may be useful if the user
588                    knows that the file won't be changed on the server
589                    by anyone else */
590                 return generic_setlease(file, arg, lease);
591         else
592                 return -EAGAIN;
593 }
594
595 struct file_system_type cifs_fs_type = {
596         .owner = THIS_MODULE,
597         .name = "cifs",
598         .get_sb = cifs_get_sb,
599         .kill_sb = kill_anon_super,
600         /*  .fs_flags */
601 };
602 const struct inode_operations cifs_dir_inode_ops = {
603         .create = cifs_create,
604         .lookup = cifs_lookup,
605         .getattr = cifs_getattr,
606         .unlink = cifs_unlink,
607         .link = cifs_hardlink,
608         .mkdir = cifs_mkdir,
609         .rmdir = cifs_rmdir,
610         .rename = cifs_rename,
611         .permission = cifs_permission,
612 /*      revalidate:cifs_revalidate,   */
613         .setattr = cifs_setattr,
614         .symlink = cifs_symlink,
615         .mknod   = cifs_mknod,
616 #ifdef CONFIG_CIFS_XATTR
617         .setxattr = cifs_setxattr,
618         .getxattr = cifs_getxattr,
619         .listxattr = cifs_listxattr,
620         .removexattr = cifs_removexattr,
621 #endif
622 };
623
624 const struct inode_operations cifs_file_inode_ops = {
625 /*      revalidate:cifs_revalidate, */
626         .setattr = cifs_setattr,
627         .getattr = cifs_getattr, /* do we need this anymore? */
628         .rename = cifs_rename,
629         .permission = cifs_permission,
630 #ifdef CONFIG_CIFS_XATTR
631         .setxattr = cifs_setxattr,
632         .getxattr = cifs_getxattr,
633         .listxattr = cifs_listxattr,
634         .removexattr = cifs_removexattr,
635 #endif
636 };
637
638 const struct inode_operations cifs_symlink_inode_ops = {
639         .readlink = generic_readlink,
640         .follow_link = cifs_follow_link,
641         .put_link = cifs_put_link,
642         .permission = cifs_permission,
643         /* BB add the following two eventually */
644         /* revalidate: cifs_revalidate,
645            setattr:    cifs_notify_change, *//* BB do we need notify change */
646 #ifdef CONFIG_CIFS_XATTR
647         .setxattr = cifs_setxattr,
648         .getxattr = cifs_getxattr,
649         .listxattr = cifs_listxattr,
650         .removexattr = cifs_removexattr,
651 #endif
652 };
653
654 const struct file_operations cifs_file_ops = {
655         .read = do_sync_read,
656         .write = do_sync_write,
657         .aio_read = generic_file_aio_read,
658         .aio_write = cifs_file_aio_write,
659         .open = cifs_open,
660         .release = cifs_close,
661         .lock = cifs_lock,
662         .fsync = cifs_fsync,
663         .flush = cifs_flush,
664         .mmap  = cifs_file_mmap,
665         .splice_read = generic_file_splice_read,
666         .llseek = cifs_llseek,
667 #ifdef CONFIG_CIFS_POSIX
668         .unlocked_ioctl = cifs_ioctl,
669 #endif /* CONFIG_CIFS_POSIX */
670         .setlease = cifs_setlease,
671 };
672
673 const struct file_operations cifs_file_direct_ops = {
674         /* no aio, no readv -
675            BB reevaluate whether they can be done with directio, no cache */
676         .read = cifs_user_read,
677         .write = cifs_user_write,
678         .open = cifs_open,
679         .release = cifs_close,
680         .lock = cifs_lock,
681         .fsync = cifs_fsync,
682         .flush = cifs_flush,
683         .mmap = cifs_file_mmap,
684         .splice_read = generic_file_splice_read,
685 #ifdef CONFIG_CIFS_POSIX
686         .unlocked_ioctl  = cifs_ioctl,
687 #endif /* CONFIG_CIFS_POSIX */
688         .llseek = cifs_llseek,
689         .setlease = cifs_setlease,
690 };
691 const struct file_operations cifs_file_nobrl_ops = {
692         .read = do_sync_read,
693         .write = do_sync_write,
694         .aio_read = generic_file_aio_read,
695         .aio_write = cifs_file_aio_write,
696         .open = cifs_open,
697         .release = cifs_close,
698         .fsync = cifs_fsync,
699         .flush = cifs_flush,
700         .mmap  = cifs_file_mmap,
701         .splice_read = generic_file_splice_read,
702         .llseek = cifs_llseek,
703 #ifdef CONFIG_CIFS_POSIX
704         .unlocked_ioctl = cifs_ioctl,
705 #endif /* CONFIG_CIFS_POSIX */
706         .setlease = cifs_setlease,
707 };
708
709 const struct file_operations cifs_file_direct_nobrl_ops = {
710         /* no mmap, no aio, no readv -
711            BB reevaluate whether they can be done with directio, no cache */
712         .read = cifs_user_read,
713         .write = cifs_user_write,
714         .open = cifs_open,
715         .release = cifs_close,
716         .fsync = cifs_fsync,
717         .flush = cifs_flush,
718         .mmap = cifs_file_mmap,
719         .splice_read = generic_file_splice_read,
720 #ifdef CONFIG_CIFS_POSIX
721         .unlocked_ioctl  = cifs_ioctl,
722 #endif /* CONFIG_CIFS_POSIX */
723         .llseek = cifs_llseek,
724         .setlease = cifs_setlease,
725 };
726
727 const struct file_operations cifs_dir_ops = {
728         .readdir = cifs_readdir,
729         .release = cifs_closedir,
730         .read    = generic_read_dir,
731         .unlocked_ioctl  = cifs_ioctl,
732         .llseek = generic_file_llseek,
733 };
734
735 static void
736 cifs_init_once(void *inode)
737 {
738         struct cifsInodeInfo *cifsi = inode;
739
740         inode_init_once(&cifsi->vfs_inode);
741         INIT_LIST_HEAD(&cifsi->lockList);
742 }
743
744 static int
745 cifs_init_inodecache(void)
746 {
747         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
748                                               sizeof(struct cifsInodeInfo),
749                                               0, (SLAB_RECLAIM_ACCOUNT|
750                                                 SLAB_MEM_SPREAD),
751                                               cifs_init_once);
752         if (cifs_inode_cachep == NULL)
753                 return -ENOMEM;
754
755         return 0;
756 }
757
758 static void
759 cifs_destroy_inodecache(void)
760 {
761         kmem_cache_destroy(cifs_inode_cachep);
762 }
763
764 static int
765 cifs_init_request_bufs(void)
766 {
767         if (CIFSMaxBufSize < 8192) {
768         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
769         Unicode path name has to fit in any SMB/CIFS path based frames */
770                 CIFSMaxBufSize = 8192;
771         } else if (CIFSMaxBufSize > 1024*127) {
772                 CIFSMaxBufSize = 1024 * 127;
773         } else {
774                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
775         }
776 /*      cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
777         cifs_req_cachep = kmem_cache_create("cifs_request",
778                                             CIFSMaxBufSize +
779                                             MAX_CIFS_HDR_SIZE, 0,
780                                             SLAB_HWCACHE_ALIGN, NULL);
781         if (cifs_req_cachep == NULL)
782                 return -ENOMEM;
783
784         if (cifs_min_rcv < 1)
785                 cifs_min_rcv = 1;
786         else if (cifs_min_rcv > 64) {
787                 cifs_min_rcv = 64;
788                 cERROR(1, "cifs_min_rcv set to maximum (64)");
789         }
790
791         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
792                                                   cifs_req_cachep);
793
794         if (cifs_req_poolp == NULL) {
795                 kmem_cache_destroy(cifs_req_cachep);
796                 return -ENOMEM;
797         }
798         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
799         almost all handle based requests (but not write response, nor is it
800         sufficient for path based requests).  A smaller size would have
801         been more efficient (compacting multiple slab items on one 4k page)
802         for the case in which debug was on, but this larger size allows
803         more SMBs to use small buffer alloc and is still much more
804         efficient to alloc 1 per page off the slab compared to 17K (5page)
805         alloc of large cifs buffers even when page debugging is on */
806         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
807                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
808                         NULL);
809         if (cifs_sm_req_cachep == NULL) {
810                 mempool_destroy(cifs_req_poolp);
811                 kmem_cache_destroy(cifs_req_cachep);
812                 return -ENOMEM;
813         }
814
815         if (cifs_min_small < 2)
816                 cifs_min_small = 2;
817         else if (cifs_min_small > 256) {
818                 cifs_min_small = 256;
819                 cFYI(1, "cifs_min_small set to maximum (256)");
820         }
821
822         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
823                                                      cifs_sm_req_cachep);
824
825         if (cifs_sm_req_poolp == NULL) {
826                 mempool_destroy(cifs_req_poolp);
827                 kmem_cache_destroy(cifs_req_cachep);
828                 kmem_cache_destroy(cifs_sm_req_cachep);
829                 return -ENOMEM;
830         }
831
832         return 0;
833 }
834
835 static void
836 cifs_destroy_request_bufs(void)
837 {
838         mempool_destroy(cifs_req_poolp);
839         kmem_cache_destroy(cifs_req_cachep);
840         mempool_destroy(cifs_sm_req_poolp);
841         kmem_cache_destroy(cifs_sm_req_cachep);
842 }
843
844 static int
845 cifs_init_mids(void)
846 {
847         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
848                                             sizeof(struct mid_q_entry), 0,
849                                             SLAB_HWCACHE_ALIGN, NULL);
850         if (cifs_mid_cachep == NULL)
851                 return -ENOMEM;
852
853         /* 3 is a reasonable minimum number of simultaneous operations */
854         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
855         if (cifs_mid_poolp == NULL) {
856                 kmem_cache_destroy(cifs_mid_cachep);
857                 return -ENOMEM;
858         }
859
860         return 0;
861 }
862
863 static void
864 cifs_destroy_mids(void)
865 {
866         mempool_destroy(cifs_mid_poolp);
867         kmem_cache_destroy(cifs_mid_cachep);
868 }
869
870 static int __init
871 init_cifs(void)
872 {
873         int rc = 0;
874         cifs_proc_init();
875         INIT_LIST_HEAD(&cifs_tcp_ses_list);
876 #ifdef CONFIG_CIFS_EXPERIMENTAL
877         INIT_LIST_HEAD(&GlobalDnotifyReqList);
878         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
879 #endif
880 /*
881  *  Initialize Global counters
882  */
883         atomic_set(&sesInfoAllocCount, 0);
884         atomic_set(&tconInfoAllocCount, 0);
885         atomic_set(&tcpSesAllocCount, 0);
886         atomic_set(&tcpSesReconnectCount, 0);
887         atomic_set(&tconInfoReconnectCount, 0);
888
889         atomic_set(&bufAllocCount, 0);
890         atomic_set(&smBufAllocCount, 0);
891 #ifdef CONFIG_CIFS_STATS2
892         atomic_set(&totBufAllocCount, 0);
893         atomic_set(&totSmBufAllocCount, 0);
894 #endif /* CONFIG_CIFS_STATS2 */
895
896         atomic_set(&midCount, 0);
897         GlobalCurrentXid = 0;
898         GlobalTotalActiveXid = 0;
899         GlobalMaxActiveXid = 0;
900         memset(Local_System_Name, 0, 15);
901         rwlock_init(&GlobalSMBSeslock);
902         rwlock_init(&cifs_tcp_ses_lock);
903         spin_lock_init(&GlobalMid_Lock);
904
905         if (cifs_max_pending < 2) {
906                 cifs_max_pending = 2;
907                 cFYI(1, "cifs_max_pending set to min of 2");
908         } else if (cifs_max_pending > 256) {
909                 cifs_max_pending = 256;
910                 cFYI(1, "cifs_max_pending set to max of 256");
911         }
912
913         rc = cifs_fscache_register();
914         if (rc)
915                 goto out;
916
917         rc = cifs_init_inodecache();
918         if (rc)
919                 goto out_clean_proc;
920
921         rc = cifs_init_mids();
922         if (rc)
923                 goto out_destroy_inodecache;
924
925         rc = cifs_init_request_bufs();
926         if (rc)
927                 goto out_destroy_mids;
928
929         rc = register_filesystem(&cifs_fs_type);
930         if (rc)
931                 goto out_destroy_request_bufs;
932 #ifdef CONFIG_CIFS_UPCALL
933         rc = register_key_type(&cifs_spnego_key_type);
934         if (rc)
935                 goto out_unregister_filesystem;
936 #endif
937 #ifdef CONFIG_CIFS_DFS_UPCALL
938         rc = cifs_init_dns_resolver();
939         if (rc)
940                 goto out_unregister_key_type;
941 #endif
942         rc = slow_work_register_user(THIS_MODULE);
943         if (rc)
944                 goto out_unregister_resolver_key;
945
946         return 0;
947
948  out_unregister_resolver_key:
949 #ifdef CONFIG_CIFS_DFS_UPCALL
950         cifs_exit_dns_resolver();
951  out_unregister_key_type:
952 #endif
953 #ifdef CONFIG_CIFS_UPCALL
954         unregister_key_type(&cifs_spnego_key_type);
955  out_unregister_filesystem:
956 #endif
957         unregister_filesystem(&cifs_fs_type);
958  out_destroy_request_bufs:
959         cifs_destroy_request_bufs();
960  out_destroy_mids:
961         cifs_destroy_mids();
962  out_destroy_inodecache:
963         cifs_destroy_inodecache();
964  out_clean_proc:
965         cifs_proc_clean();
966         cifs_fscache_unregister();
967  out:
968         return rc;
969 }
970
971 static void __exit
972 exit_cifs(void)
973 {
974         cFYI(DBG2, "exit_cifs");
975         cifs_proc_clean();
976         cifs_fscache_unregister();
977 #ifdef CONFIG_CIFS_DFS_UPCALL
978         cifs_dfs_release_automount_timer();
979         cifs_exit_dns_resolver();
980 #endif
981 #ifdef CONFIG_CIFS_UPCALL
982         unregister_key_type(&cifs_spnego_key_type);
983 #endif
984         unregister_filesystem(&cifs_fs_type);
985         cifs_destroy_inodecache();
986         cifs_destroy_mids();
987         cifs_destroy_request_bufs();
988 }
989
990 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
991 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
992 MODULE_DESCRIPTION
993     ("VFS to access servers complying with the SNIA CIFS Specification "
994      "e.g. Samba and Windows");
995 MODULE_VERSION(CIFS_VERSION);
996 module_init(init_cifs)
997 module_exit(exit_cifs)