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