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