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 #ifdef CONFIG_CIFS_QUOTA
  53 static struct quotactl_ops cifs_quotactl_ops;
  54 #endif /* QUOTA */
  55
  56 int cifsFYI = 0;
  57 int cifsERROR = 1;
  58 int traceSMB = 0;
  59 unsigned int oplockEnabled = 1;
  60 unsigned int experimEnabled = 0;
  61 unsigned int linuxExtEnabled = 1;
  62 unsigned int lookupCacheEnabled = 1;
  63 unsigned int multiuser_mount = 0;
  64 unsigned int extended_security = CIFSSEC_DEF;
  65 /* unsigned int ntlmv2_support = 0; */
  66 unsigned int sign_CIFS_PDUs = 1;
  67 extern struct task_struct *oplockThread; /* remove sparse warning */
  68 struct task_struct *oplockThread = NULL;
  69 /* extern struct task_struct * dnotifyThread; remove sparse warning */
  70 static const struct super_operations cifs_super_ops;
  71 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
  72 module_param(CIFSMaxBufSize, int, 0);
  73 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
  74                                  "Default: 16384 Range: 8192 to 130048");
  75 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
  76 module_param(cifs_min_rcv, int, 0);
  77 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
  78                                 "1 to 64");
  79 unsigned int cifs_min_small = 30;
  80 module_param(cifs_min_small, int, 0);
  81 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
  82                                  "Range: 2 to 256");
  83 unsigned int cifs_max_pending = CIFS_MAX_REQ;
  84 module_param(cifs_max_pending, int, 0);
  85 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
  86                                    "Default: 50 Range: 2 to 256");
  87
  88 extern mempool_t *cifs_sm_req_poolp;
  89 extern mempool_t *cifs_req_poolp;
  90 extern mempool_t *cifs_mid_poolp;
  91
  92 extern struct kmem_cache *cifs_oplock_cachep;
  93
  94 static int
  95 cifs_read_super(struct super_block *sb, void *data,
  96                 const char *devname, int silent)
  97 {
  98         struct inode *inode;
  99         struct cifs_sb_info *cifs_sb;
 100         int rc = 0;
 101
 102         /* BB should we make this contingent on mount parm? */
 103         sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
 104         sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
 105         cifs_sb = CIFS_SB(sb);
 106         if (cifs_sb == NULL)
 107                 return -ENOMEM;
 108
 109 #ifdef CONFIG_CIFS_DFS_UPCALL
 110         /* copy mount params to sb for use in submounts */
 111         /* BB: should we move this after the mount so we
 112          * do not have to do the copy on failed mounts?
 113          * BB: May be it is better to do simple copy before
 114          * complex operation (mount), and in case of fail
 115          * just exit instead of doing mount and attempting
 116          * undo it if this copy fails?*/
 117         if (data) {
 118                 int len = strlen(data);
 119                 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
 120                 if (cifs_sb->mountdata == NULL) {
 121                         kfree(sb->s_fs_info);
 122                         sb->s_fs_info = NULL;
 123                         return -ENOMEM;
 124                 }
 125                 strncpy(cifs_sb->mountdata, data, len + 1);
 126                 cifs_sb->mountdata[len] = '\0';
 127         }
 128 #endif
 129
 130         rc = cifs_mount(sb, cifs_sb, data, devname);
 131
 132         if (rc) {
 133                 if (!silent)
 134                         cERROR(1,
 135                                ("cifs_mount failed w/return code = %d", rc));
 136                 goto out_mount_failed;
 137         }
 138
 139         sb->s_magic = CIFS_MAGIC_NUMBER;
 140         sb->s_op = &cifs_super_ops;
 141 /*      if (cifs_sb->tcon->ses->server->maxBuf > MAX_CIFS_HDR_SIZE + 512)
 142             sb->s_blocksize =
 143                 cifs_sb->tcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE; */
 144 #ifdef CONFIG_CIFS_QUOTA
 145         sb->s_qcop = &cifs_quotactl_ops;
 146 #endif
 147         sb->s_blocksize = CIFS_MAX_MSGSIZE;
 148         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
 149         inode = cifs_root_iget(sb, ROOT_I);
 150
 151         if (IS_ERR(inode)) {
 152                 rc = PTR_ERR(inode);
 153                 inode = NULL;
 154                 goto out_no_root;
 155         }
 156
 157         sb->s_root = d_alloc_root(inode);
 158
 159         if (!sb->s_root) {
 160                 rc = -ENOMEM;
 161                 goto out_no_root;
 162         }
 163
 164 #ifdef CONFIG_CIFS_EXPERIMENTAL
 165         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
 166                 cFYI(1, ("export ops supported"));
 167                 sb->s_export_op = &cifs_export_ops;
 168         }
 169 #endif /* EXPERIMENTAL */
 170
 171         return 0;
 172
 173 out_no_root:
 174         cERROR(1, ("cifs_read_super: get root inode failed"));
 175         if (inode)
 176                 iput(inode);
 177
 178         cifs_umount(sb, cifs_sb);
 179
 180 out_mount_failed:
 181         if (cifs_sb) {
 182 #ifdef CONFIG_CIFS_DFS_UPCALL
 183                 if (cifs_sb->mountdata) {
 184                         kfree(cifs_sb->mountdata);
 185                         cifs_sb->mountdata = NULL;
 186                 }
 187 #endif
 188                 if (cifs_sb->local_nls)
 189                         unload_nls(cifs_sb->local_nls);
 190                 kfree(cifs_sb);
 191         }
 192         return rc;
 193 }
 194
 195 static void
 196 cifs_put_super(struct super_block *sb)
 197 {
 198         int rc = 0;
 199         struct cifs_sb_info *cifs_sb;
 200
 201         cFYI(1, ("In cifs_put_super"));
 202         cifs_sb = CIFS_SB(sb);
 203         if (cifs_sb == NULL) {
 204                 cFYI(1, ("Empty cifs superblock info passed to unmount"));
 205                 return;
 206         }
 207
 208         lock_kernel();
 209
 210         rc = cifs_umount(sb, cifs_sb);
 211         if (rc)
 212                 cERROR(1, ("cifs_umount failed with return code %d", rc));
 213 #ifdef CONFIG_CIFS_DFS_UPCALL
 214         if (cifs_sb->mountdata) {
 215                 kfree(cifs_sb->mountdata);
 216                 cifs_sb->mountdata = NULL;
 217         }
 218 #endif
 219
 220         unload_nls(cifs_sb->local_nls);
 221         kfree(cifs_sb);
 222
 223         unlock_kernel();
 224 }
 225
 226 static int
 227 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
 228 {
 229         struct super_block *sb = dentry->d_sb;
 230         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 231         struct cifsTconInfo *tcon = cifs_sb->tcon;
 232         int rc = -EOPNOTSUPP;
 233         int xid;
 234
 235         xid = GetXid();
 236
 237         buf->f_type = CIFS_MAGIC_NUMBER;
 238
 239         /*
 240          * PATH_MAX may be too long - it would presumably be total path,
 241          * but note that some servers (includinng Samba 3) have a shorter
 242          * maximum path.
 243          *
 244          * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
 245          */
 246         buf->f_namelen = PATH_MAX;
 247         buf->f_files = 0;       /* undefined */
 248         buf->f_ffree = 0;       /* unlimited */
 249
 250         /*
 251          * We could add a second check for a QFS Unix capability bit
 252          */
 253         if ((tcon->ses->capabilities & CAP_UNIX) &&
 254             (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
 255                 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
 256
 257         /*
 258          * Only need to call the old QFSInfo if failed on newer one,
 259          * e.g. by OS/2.
 260          **/
 261         if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
 262                 rc = CIFSSMBQFSInfo(xid, tcon, buf);
 263
 264         /*
 265          * Some old Windows servers also do not support level 103, retry with
 266          * older level one if old server failed the previous call or we
 267          * bypassed it because we detected that this was an older LANMAN sess
 268          */
 269         if (rc)
 270                 rc = SMBOldQFSInfo(xid, tcon, buf);
 271
 272         FreeXid(xid);
 273         return 0;
 274 }
 275
 276 static int cifs_permission(struct inode *inode, int mask)
 277 {
 278         struct cifs_sb_info *cifs_sb;
 279
 280         cifs_sb = CIFS_SB(inode->i_sb);
 281
 282         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
 283                 if ((mask & MAY_EXEC) && !execute_ok(inode))
 284                         return -EACCES;
 285                 else
 286                         return 0;
 287         } else /* file mode might have been restricted at mount time
 288                 on the client (above and beyond ACL on servers) for
 289                 servers which do not support setting and viewing mode bits,
 290                 so allowing client to check permissions is useful */
 291                 return generic_permission(inode, mask, NULL);
 292 }
 293
 294 static struct kmem_cache *cifs_inode_cachep;
 295 static struct kmem_cache *cifs_req_cachep;
 296 static struct kmem_cache *cifs_mid_cachep;
 297 struct kmem_cache *cifs_oplock_cachep;
 298 static struct kmem_cache *cifs_sm_req_cachep;
 299 mempool_t *cifs_sm_req_poolp;
 300 mempool_t *cifs_req_poolp;
 301 mempool_t *cifs_mid_poolp;
 302
 303 static struct inode *
 304 cifs_alloc_inode(struct super_block *sb)
 305 {
 306         struct cifsInodeInfo *cifs_inode;
 307         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
 308         if (!cifs_inode)
 309                 return NULL;
 310         cifs_inode->cifsAttrs = 0x20;   /* default */
 311         cifs_inode->time = 0;
 312         cifs_inode->write_behind_rc = 0;
 313         /* Until the file is open and we have gotten oplock
 314         info back from the server, can not assume caching of
 315         file data or metadata */
 316         cifs_inode->clientCanCacheRead = false;
 317         cifs_inode->clientCanCacheAll = false;
 318         cifs_inode->delete_pending = false;
 319         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
 320         cifs_inode->server_eof = 0;
 321
 322         /* Can not set i_flags here - they get immediately overwritten
 323            to zero by the VFS */
 324 /*      cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
 325         INIT_LIST_HEAD(&cifs_inode->openFileList);
 326         return &cifs_inode->vfs_inode;
 327 }
 328
 329 static void
 330 cifs_destroy_inode(struct inode *inode)
 331 {
 332         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
 333 }
 334
 335 static void
 336 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
 337 {
 338         seq_printf(s, ",addr=");
 339
 340         switch (server->addr.sockAddr.sin_family) {
 341         case AF_INET:
 342                 seq_printf(s, "%pI4", &server->addr.sockAddr.sin_addr.s_addr);
 343                 break;
 344         case AF_INET6:
 345                 seq_printf(s, "%pI6",
 346                            &server->addr.sockAddr6.sin6_addr.s6_addr);
 347                 if (server->addr.sockAddr6.sin6_scope_id)
 348                         seq_printf(s, "%%%u",
 349                                    server->addr.sockAddr6.sin6_scope_id);
 350                 break;
 351         default:
 352                 seq_printf(s, "(unknown)");
 353         }
 354 }
 355
 356 /*
 357  * cifs_show_options() is for displaying mount options in /proc/mounts.
 358  * Not all settable options are displayed but most of the important
 359  * ones are.
 360  */
 361 static int
 362 cifs_show_options(struct seq_file *s, struct vfsmount *m)
 363 {
 364         struct cifs_sb_info *cifs_sb;
 365         struct cifsTconInfo *tcon;
 366
 367         cifs_sb = CIFS_SB(m->mnt_sb);
 368         tcon = cifs_sb->tcon;
 369
 370         seq_printf(s, ",unc=%s", cifs_sb->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 #ifdef CONFIG_CIFS_QUOTA
 432 int cifs_xquota_set(struct super_block *sb, int quota_type, qid_t qid,
 433                 struct fs_disk_quota *pdquota)
 434 {
 435         int xid;
 436         int rc = 0;
 437         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 438         struct cifsTconInfo *pTcon;
 439
 440         if (cifs_sb)
 441                 pTcon = cifs_sb->tcon;
 442         else
 443                 return -EIO;
 444
 445
 446         xid = GetXid();
 447         if (pTcon) {
 448                 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
 449         } else
 450                 rc = -EIO;
 451
 452         FreeXid(xid);
 453         return rc;
 454 }
 455
 456 int cifs_xquota_get(struct super_block *sb, int quota_type, qid_t qid,
 457                     struct fs_disk_quota *pdquota)
 458 {
 459         int xid;
 460         int rc = 0;
 461         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 462         struct cifsTconInfo *pTcon;
 463
 464         if (cifs_sb)
 465                 pTcon = cifs_sb->tcon;
 466         else
 467                 return -EIO;
 468
 469         xid = GetXid();
 470         if (pTcon) {
 471                 cFYI(1, ("set type: 0x%x id: %d", quota_type, qid));
 472         } else
 473                 rc = -EIO;
 474
 475         FreeXid(xid);
 476         return rc;
 477 }
 478
 479 int cifs_xstate_set(struct super_block *sb, unsigned int flags, int operation)
 480 {
 481         int xid;
 482         int rc = 0;
 483         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 484         struct cifsTconInfo *pTcon;
 485
 486         if (cifs_sb)
 487                 pTcon = cifs_sb->tcon;
 488         else
 489                 return -EIO;
 490
 491         xid = GetXid();
 492         if (pTcon) {
 493                 cFYI(1, ("flags: 0x%x operation: 0x%x", flags, operation));
 494         } else
 495                 rc = -EIO;
 496
 497         FreeXid(xid);
 498         return rc;
 499 }
 500
 501 int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
 502 {
 503         int xid;
 504         int rc = 0;
 505         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 506         struct cifsTconInfo *pTcon;
 507
 508         if (cifs_sb)
 509                 pTcon = cifs_sb->tcon;
 510         else
 511                 return -EIO;
 512
 513         xid = GetXid();
 514         if (pTcon) {
 515                 cFYI(1, ("pqstats %p", qstats));
 516         } else
 517                 rc = -EIO;
 518
 519         FreeXid(xid);
 520         return rc;
 521 }
 522
 523 static struct quotactl_ops cifs_quotactl_ops = {
 524         .set_xquota     = cifs_xquota_set,
 525         .get_xquota     = cifs_xquota_get,
 526         .set_xstate     = cifs_xstate_set,
 527         .get_xstate     = cifs_xstate_get,
 528 };
 529 #endif
 530
 531 static void cifs_umount_begin(struct super_block *sb)
 532 {
 533         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 534         struct cifsTconInfo *tcon;
 535
 536         if (cifs_sb == NULL)
 537                 return;
 538
 539         tcon = cifs_sb->tcon;
 540         if (tcon == NULL)
 541                 return;
 542
 543         read_lock(&cifs_tcp_ses_lock);
 544         if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
 545                 /* we have other mounts to same share or we have
 546                    already tried to force umount this and woken up
 547                    all waiting network requests, nothing to do */
 548                 read_unlock(&cifs_tcp_ses_lock);
 549                 return;
 550         } else if (tcon->tc_count == 1)
 551                 tcon->tidStatus = CifsExiting;
 552         read_unlock(&cifs_tcp_ses_lock);
 553
 554         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
 555         /* cancel_notify_requests(tcon); */
 556         if (tcon->ses && tcon->ses->server) {
 557                 cFYI(1, ("wake up tasks now - umount begin not complete"));
 558                 wake_up_all(&tcon->ses->server->request_q);
 559                 wake_up_all(&tcon->ses->server->response_q);
 560                 msleep(1); /* yield */
 561                 /* we have to kick the requests once more */
 562                 wake_up_all(&tcon->ses->server->response_q);
 563                 msleep(1);
 564         }
 565
 566         return;
 567 }
 568
 569 #ifdef CONFIG_CIFS_STATS2
 570 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
 571 {
 572         /* BB FIXME */
 573         return 0;
 574 }
 575 #endif
 576
 577 static int cifs_remount(struct super_block *sb, int *flags, char *data)
 578 {
 579         *flags |= MS_NODIRATIME;
 580         return 0;
 581 }
 582
 583 static const struct super_operations cifs_super_ops = {
 584         .put_super = cifs_put_super,
 585         .statfs = cifs_statfs,
 586         .alloc_inode = cifs_alloc_inode,
 587         .destroy_inode = cifs_destroy_inode,
 588 /*      .drop_inode         = generic_delete_inode,
 589         .delete_inode   = cifs_delete_inode,  */  /* Do not need above two
 590         functions unless later we add lazy close of inodes or unless the
 591         kernel forgets to call us with the same number of releases (closes)
 592         as opens */
 593         .show_options = cifs_show_options,
 594         .umount_begin   = cifs_umount_begin,
 595         .remount_fs = cifs_remount,
 596 #ifdef CONFIG_CIFS_STATS2
 597         .show_stats = cifs_show_stats,
 598 #endif
 599 };
 600
 601 static int
 602 cifs_get_sb(struct file_system_type *fs_type,
 603             int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 604 {
 605         int rc;
 606         struct super_block *sb = sget(fs_type, NULL, set_anon_super, NULL);
 607
 608         cFYI(1, ("Devname: %s flags: %d ", dev_name, flags));
 609
 610         if (IS_ERR(sb))
 611                 return PTR_ERR(sb);
 612
 613         sb->s_flags = flags;
 614
 615         rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
 616         if (rc) {
 617                 deactivate_locked_super(sb);
 618                 return rc;
 619         }
 620         sb->s_flags |= MS_ACTIVE;
 621         simple_set_mnt(mnt, sb);
 622         return 0;
 623 }
 624
 625 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 626                                    unsigned long nr_segs, loff_t pos)
 627 {
 628         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
 629         ssize_t written;
 630
 631         written = generic_file_aio_write(iocb, iov, nr_segs, pos);
 632         if (!CIFS_I(inode)->clientCanCacheAll)
 633                 filemap_fdatawrite(inode->i_mapping);
 634         return written;
 635 }
 636
 637 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
 638 {
 639         /* origin == SEEK_END => we must revalidate the cached file length */
 640         if (origin == SEEK_END) {
 641                 int retval;
 642
 643                 /* some applications poll for the file length in this strange
 644                    way so we must seek to end on non-oplocked files by
 645                    setting the revalidate time to zero */
 646                 CIFS_I(file->f_path.dentry->d_inode)->time = 0;
 647
 648                 retval = cifs_revalidate(file->f_path.dentry);
 649                 if (retval < 0)
 650                         return (loff_t)retval;
 651         }
 652         return generic_file_llseek_unlocked(file, offset, origin);
 653 }
 654
 655 #ifdef CONFIG_CIFS_EXPERIMENTAL
 656 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
 657 {
 658         /* note that this is called by vfs setlease with the BKL held
 659            although I doubt that BKL is needed here in cifs */
 660         struct inode *inode = file->f_path.dentry->d_inode;
 661
 662         if (!(S_ISREG(inode->i_mode)))
 663                 return -EINVAL;
 664
 665         /* check if file is oplocked */
 666         if (((arg == F_RDLCK) &&
 667                 (CIFS_I(inode)->clientCanCacheRead)) ||
 668             ((arg == F_WRLCK) &&
 669                 (CIFS_I(inode)->clientCanCacheAll)))
 670                 return generic_setlease(file, arg, lease);
 671         else if (CIFS_SB(inode->i_sb)->tcon->local_lease &&
 672                         !CIFS_I(inode)->clientCanCacheRead)
 673                 /* If the server claims to support oplock on this
 674                    file, then we still need to check oplock even
 675                    if the local_lease mount option is set, but there
 676                    are servers which do not support oplock for which
 677                    this mount option may be useful if the user
 678                    knows that the file won't be changed on the server
 679                    by anyone else */
 680                 return generic_setlease(file, arg, lease);
 681         else
 682                 return -EAGAIN;
 683 }
 684 #endif
 685
 686 struct file_system_type cifs_fs_type = {
 687         .owner = THIS_MODULE,
 688         .name = "cifs",
 689         .get_sb = cifs_get_sb,
 690         .kill_sb = kill_anon_super,
 691         /*  .fs_flags */
 692 };
 693 const struct inode_operations cifs_dir_inode_ops = {
 694         .create = cifs_create,
 695         .lookup = cifs_lookup,
 696         .getattr = cifs_getattr,
 697         .unlink = cifs_unlink,
 698         .link = cifs_hardlink,
 699         .mkdir = cifs_mkdir,
 700         .rmdir = cifs_rmdir,
 701         .rename = cifs_rename,
 702         .permission = cifs_permission,
 703 /*      revalidate:cifs_revalidate,   */
 704         .setattr = cifs_setattr,
 705         .symlink = cifs_symlink,
 706         .mknod   = cifs_mknod,
 707 #ifdef CONFIG_CIFS_XATTR
 708         .setxattr = cifs_setxattr,
 709         .getxattr = cifs_getxattr,
 710         .listxattr = cifs_listxattr,
 711         .removexattr = cifs_removexattr,
 712 #endif
 713 };
 714
 715 const struct inode_operations cifs_file_inode_ops = {
 716 /*      revalidate:cifs_revalidate, */
 717         .setattr = cifs_setattr,
 718         .getattr = cifs_getattr, /* do we need this anymore? */
 719         .rename = cifs_rename,
 720         .permission = cifs_permission,
 721 #ifdef CONFIG_CIFS_XATTR
 722         .setxattr = cifs_setxattr,
 723         .getxattr = cifs_getxattr,
 724         .listxattr = cifs_listxattr,
 725         .removexattr = cifs_removexattr,
 726 #endif
 727 };
 728
 729 const struct inode_operations cifs_symlink_inode_ops = {
 730         .readlink = generic_readlink,
 731         .follow_link = cifs_follow_link,
 732         .put_link = cifs_put_link,
 733         .permission = cifs_permission,
 734         /* BB add the following two eventually */
 735         /* revalidate: cifs_revalidate,
 736            setattr:    cifs_notify_change, *//* BB do we need notify change */
 737 #ifdef CONFIG_CIFS_XATTR
 738         .setxattr = cifs_setxattr,
 739         .getxattr = cifs_getxattr,
 740         .listxattr = cifs_listxattr,
 741         .removexattr = cifs_removexattr,
 742 #endif
 743 };
 744
 745 const struct file_operations cifs_file_ops = {
 746         .read = do_sync_read,
 747         .write = do_sync_write,
 748         .aio_read = generic_file_aio_read,
 749         .aio_write = cifs_file_aio_write,
 750         .open = cifs_open,
 751         .release = cifs_close,
 752         .lock = cifs_lock,
 753         .fsync = cifs_fsync,
 754         .flush = cifs_flush,
 755         .mmap  = cifs_file_mmap,
 756         .splice_read = generic_file_splice_read,
 757         .llseek = cifs_llseek,
 758 #ifdef CONFIG_CIFS_POSIX
 759         .unlocked_ioctl = cifs_ioctl,
 760 #endif /* CONFIG_CIFS_POSIX */
 761
 762 #ifdef CONFIG_CIFS_EXPERIMENTAL
 763         .setlease = cifs_setlease,
 764 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 765 };
 766
 767 const struct file_operations cifs_file_direct_ops = {
 768         /* no mmap, no aio, no readv -
 769            BB reevaluate whether they can be done with directio, no cache */
 770         .read = cifs_user_read,
 771         .write = cifs_user_write,
 772         .open = cifs_open,
 773         .release = cifs_close,
 774         .lock = cifs_lock,
 775         .fsync = cifs_fsync,
 776         .flush = cifs_flush,
 777         .splice_read = generic_file_splice_read,
 778 #ifdef CONFIG_CIFS_POSIX
 779         .unlocked_ioctl  = cifs_ioctl,
 780 #endif /* CONFIG_CIFS_POSIX */
 781         .llseek = cifs_llseek,
 782 #ifdef CONFIG_CIFS_EXPERIMENTAL
 783         .setlease = cifs_setlease,
 784 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 785 };
 786 const struct file_operations cifs_file_nobrl_ops = {
 787         .read = do_sync_read,
 788         .write = do_sync_write,
 789         .aio_read = generic_file_aio_read,
 790         .aio_write = cifs_file_aio_write,
 791         .open = cifs_open,
 792         .release = cifs_close,
 793         .fsync = cifs_fsync,
 794         .flush = cifs_flush,
 795         .mmap  = cifs_file_mmap,
 796         .splice_read = generic_file_splice_read,
 797         .llseek = cifs_llseek,
 798 #ifdef CONFIG_CIFS_POSIX
 799         .unlocked_ioctl = cifs_ioctl,
 800 #endif /* CONFIG_CIFS_POSIX */
 801
 802 #ifdef CONFIG_CIFS_EXPERIMENTAL
 803         .setlease = cifs_setlease,
 804 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 805 };
 806
 807 const struct file_operations cifs_file_direct_nobrl_ops = {
 808         /* no mmap, no aio, no readv -
 809            BB reevaluate whether they can be done with directio, no cache */
 810         .read = cifs_user_read,
 811         .write = cifs_user_write,
 812         .open = cifs_open,
 813         .release = cifs_close,
 814         .fsync = cifs_fsync,
 815         .flush = cifs_flush,
 816         .splice_read = generic_file_splice_read,
 817 #ifdef CONFIG_CIFS_POSIX
 818         .unlocked_ioctl  = cifs_ioctl,
 819 #endif /* CONFIG_CIFS_POSIX */
 820         .llseek = cifs_llseek,
 821 #ifdef CONFIG_CIFS_EXPERIMENTAL
 822         .setlease = cifs_setlease,
 823 #endif /* CONFIG_CIFS_EXPERIMENTAL */
 824 };
 825
 826 const struct file_operations cifs_dir_ops = {
 827         .readdir = cifs_readdir,
 828         .release = cifs_closedir,
 829         .read    = generic_read_dir,
 830         .unlocked_ioctl  = cifs_ioctl,
 831         .llseek = generic_file_llseek,
 832 };
 833
 834 static void
 835 cifs_init_once(void *inode)
 836 {
 837         struct cifsInodeInfo *cifsi = inode;
 838
 839         inode_init_once(&cifsi->vfs_inode);
 840         INIT_LIST_HEAD(&cifsi->lockList);
 841 }
 842
 843 static int
 844 cifs_init_inodecache(void)
 845 {
 846         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
 847                                               sizeof(struct cifsInodeInfo),
 848                                               0, (SLAB_RECLAIM_ACCOUNT|
 849                                                 SLAB_MEM_SPREAD),
 850                                               cifs_init_once);
 851         if (cifs_inode_cachep == NULL)
 852                 return -ENOMEM;
 853
 854         return 0;
 855 }
 856
 857 static void
 858 cifs_destroy_inodecache(void)
 859 {
 860         kmem_cache_destroy(cifs_inode_cachep);
 861 }
 862
 863 static int
 864 cifs_init_request_bufs(void)
 865 {
 866         if (CIFSMaxBufSize < 8192) {
 867         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
 868         Unicode path name has to fit in any SMB/CIFS path based frames */
 869                 CIFSMaxBufSize = 8192;
 870         } else if (CIFSMaxBufSize > 1024*127) {
 871                 CIFSMaxBufSize = 1024 * 127;
 872         } else {
 873                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
 874         }
 875 /*      cERROR(1,("CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize)); */
 876         cifs_req_cachep = kmem_cache_create("cifs_request",
 877                                             CIFSMaxBufSize +
 878                                             MAX_CIFS_HDR_SIZE, 0,
 879                                             SLAB_HWCACHE_ALIGN, NULL);
 880         if (cifs_req_cachep == NULL)
 881                 return -ENOMEM;
 882
 883         if (cifs_min_rcv < 1)
 884                 cifs_min_rcv = 1;
 885         else if (cifs_min_rcv > 64) {
 886                 cifs_min_rcv = 64;
 887                 cERROR(1, ("cifs_min_rcv set to maximum (64)"));
 888         }
 889
 890         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
 891                                                   cifs_req_cachep);
 892
 893         if (cifs_req_poolp == NULL) {
 894                 kmem_cache_destroy(cifs_req_cachep);
 895                 return -ENOMEM;
 896         }
 897         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
 898         almost all handle based requests (but not write response, nor is it
 899         sufficient for path based requests).  A smaller size would have
 900         been more efficient (compacting multiple slab items on one 4k page)
 901         for the case in which debug was on, but this larger size allows
 902         more SMBs to use small buffer alloc and is still much more
 903         efficient to alloc 1 per page off the slab compared to 17K (5page)
 904         alloc of large cifs buffers even when page debugging is on */
 905         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
 906                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
 907                         NULL);
 908         if (cifs_sm_req_cachep == NULL) {
 909                 mempool_destroy(cifs_req_poolp);
 910                 kmem_cache_destroy(cifs_req_cachep);
 911                 return -ENOMEM;
 912         }
 913
 914         if (cifs_min_small < 2)
 915                 cifs_min_small = 2;
 916         else if (cifs_min_small > 256) {
 917                 cifs_min_small = 256;
 918                 cFYI(1, ("cifs_min_small set to maximum (256)"));
 919         }
 920
 921         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
 922                                                      cifs_sm_req_cachep);
 923
 924         if (cifs_sm_req_poolp == NULL) {
 925                 mempool_destroy(cifs_req_poolp);
 926                 kmem_cache_destroy(cifs_req_cachep);
 927                 kmem_cache_destroy(cifs_sm_req_cachep);
 928                 return -ENOMEM;
 929         }
 930
 931         return 0;
 932 }
 933
 934 static void
 935 cifs_destroy_request_bufs(void)
 936 {
 937         mempool_destroy(cifs_req_poolp);
 938         kmem_cache_destroy(cifs_req_cachep);
 939         mempool_destroy(cifs_sm_req_poolp);
 940         kmem_cache_destroy(cifs_sm_req_cachep);
 941 }
 942
 943 static int
 944 cifs_init_mids(void)
 945 {
 946         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
 947                                             sizeof(struct mid_q_entry), 0,
 948                                             SLAB_HWCACHE_ALIGN, NULL);
 949         if (cifs_mid_cachep == NULL)
 950                 return -ENOMEM;
 951
 952         /* 3 is a reasonable minimum number of simultaneous operations */
 953         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
 954         if (cifs_mid_poolp == NULL) {
 955                 kmem_cache_destroy(cifs_mid_cachep);
 956                 return -ENOMEM;
 957         }
 958
 959         cifs_oplock_cachep = kmem_cache_create("cifs_oplock_structs",
 960                                         sizeof(struct oplock_q_entry), 0,
 961                                         SLAB_HWCACHE_ALIGN, NULL);
 962         if (cifs_oplock_cachep == NULL) {
 963                 mempool_destroy(cifs_mid_poolp);
 964                 kmem_cache_destroy(cifs_mid_cachep);
 965                 return -ENOMEM;
 966         }
 967
 968         return 0;
 969 }
 970
 971 static void
 972 cifs_destroy_mids(void)
 973 {
 974         mempool_destroy(cifs_mid_poolp);
 975         kmem_cache_destroy(cifs_mid_cachep);
 976         kmem_cache_destroy(cifs_oplock_cachep);
 977 }
 978
 979 static int cifs_oplock_thread(void *dummyarg)
 980 {
 981         struct oplock_q_entry *oplock_item;
 982         struct cifsTconInfo *pTcon;
 983         struct inode *inode;
 984         __u16  netfid;
 985         int rc, waitrc = 0;
 986
 987         set_freezable();
 988         do {
 989                 if (try_to_freeze())
 990                         continue;
 991
 992                 spin_lock(&GlobalMid_Lock);
 993                 if (list_empty(&GlobalOplock_Q)) {
 994                         spin_unlock(&GlobalMid_Lock);
 995                         set_current_state(TASK_INTERRUPTIBLE);
 996                         schedule_timeout(39*HZ);
 997                 } else {
 998                         oplock_item = list_entry(GlobalOplock_Q.next,
 999                                                 struct oplock_q_entry, qhead);
1000                         cFYI(1, ("found oplock item to write out"));
1001                         pTcon = oplock_item->tcon;
1002                         inode = oplock_item->pinode;
1003                         netfid = oplock_item->netfid;
1004                         spin_unlock(&GlobalMid_Lock);
1005                         DeleteOplockQEntry(oplock_item);
1006                         /* can not grab inode sem here since it would
1007                                 deadlock when oplock received on delete
1008                                 since vfs_unlink holds the i_mutex across
1009                                 the call */
1010                         /* mutex_lock(&inode->i_mutex);*/
1011                         if (S_ISREG(inode->i_mode)) {
1012 #ifdef CONFIG_CIFS_EXPERIMENTAL
1013                                 if (CIFS_I(inode)->clientCanCacheAll == 0)
1014                                         break_lease(inode, FMODE_READ);
1015                                 else if (CIFS_I(inode)->clientCanCacheRead == 0)
1016                                         break_lease(inode, FMODE_WRITE);
1017 #endif
1018                                 rc = filemap_fdatawrite(inode->i_mapping);
1019                                 if (CIFS_I(inode)->clientCanCacheRead == 0) {
1020                                         waitrc = filemap_fdatawait(
1021                                                               inode->i_mapping);
1022                                         invalidate_remote_inode(inode);
1023                                 }
1024                                 if (rc == 0)
1025                                         rc = waitrc;
1026                         } else
1027                                 rc = 0;
1028                         /* mutex_unlock(&inode->i_mutex);*/
1029                         if (rc)
1030                                 CIFS_I(inode)->write_behind_rc = rc;
1031                         cFYI(1, ("Oplock flush inode %p rc %d",
1032                                 inode, rc));
1033
1034                                 /* releasing stale oplock after recent reconnect
1035                                 of smb session using a now incorrect file
1036                                 handle is not a data integrity issue but do
1037                                 not bother sending an oplock release if session
1038                                 to server still is disconnected since oplock
1039                                 already released by the server in that case */
1040                         if (!pTcon->need_reconnect) {
1041                                 rc = CIFSSMBLock(0, pTcon, netfid,
1042                                                 0 /* len */ , 0 /* offset */, 0,
1043                                                 0, LOCKING_ANDX_OPLOCK_RELEASE,
1044                                                 false /* wait flag */);
1045                                 cFYI(1, ("Oplock release rc = %d", rc));
1046                         }
1047                         set_current_state(TASK_INTERRUPTIBLE);
1048                         schedule_timeout(1);  /* yield in case q were corrupt */
1049                 }
1050         } while (!kthread_should_stop());
1051
1052         return 0;
1053 }
1054
1055 static int __init
1056 init_cifs(void)
1057 {
1058         int rc = 0;
1059         cifs_proc_init();
1060         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1061         INIT_LIST_HEAD(&GlobalOplock_Q);
1062 #ifdef CONFIG_CIFS_EXPERIMENTAL
1063         INIT_LIST_HEAD(&GlobalDnotifyReqList);
1064         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1065 #endif
1066 /*
1067  *  Initialize Global counters
1068  */
1069         atomic_set(&sesInfoAllocCount, 0);
1070         atomic_set(&tconInfoAllocCount, 0);
1071         atomic_set(&tcpSesAllocCount, 0);
1072         atomic_set(&tcpSesReconnectCount, 0);
1073         atomic_set(&tconInfoReconnectCount, 0);
1074
1075         atomic_set(&bufAllocCount, 0);
1076         atomic_set(&smBufAllocCount, 0);
1077 #ifdef CONFIG_CIFS_STATS2
1078         atomic_set(&totBufAllocCount, 0);
1079         atomic_set(&totSmBufAllocCount, 0);
1080 #endif /* CONFIG_CIFS_STATS2 */
1081
1082         atomic_set(&midCount, 0);
1083         GlobalCurrentXid = 0;
1084         GlobalTotalActiveXid = 0;
1085         GlobalMaxActiveXid = 0;
1086         memset(Local_System_Name, 0, 15);
1087         rwlock_init(&GlobalSMBSeslock);
1088         rwlock_init(&cifs_tcp_ses_lock);
1089         spin_lock_init(&GlobalMid_Lock);
1090
1091         if (cifs_max_pending < 2) {
1092                 cifs_max_pending = 2;
1093                 cFYI(1, ("cifs_max_pending set to min of 2"));
1094         } else if (cifs_max_pending > 256) {
1095                 cifs_max_pending = 256;
1096                 cFYI(1, ("cifs_max_pending set to max of 256"));
1097         }
1098
1099         rc = cifs_init_inodecache();
1100         if (rc)
1101                 goto out_clean_proc;
1102
1103         rc = cifs_init_mids();
1104         if (rc)
1105                 goto out_destroy_inodecache;
1106
1107         rc = cifs_init_request_bufs();
1108         if (rc)
1109                 goto out_destroy_mids;
1110
1111         rc = register_filesystem(&cifs_fs_type);
1112         if (rc)
1113                 goto out_destroy_request_bufs;
1114 #ifdef CONFIG_CIFS_UPCALL
1115         rc = register_key_type(&cifs_spnego_key_type);
1116         if (rc)
1117                 goto out_unregister_filesystem;
1118 #endif
1119 #ifdef CONFIG_CIFS_DFS_UPCALL
1120         rc = register_key_type(&key_type_dns_resolver);
1121         if (rc)
1122                 goto out_unregister_key_type;
1123 #endif
1124         oplockThread = kthread_run(cifs_oplock_thread, NULL, "cifsoplockd");
1125         if (IS_ERR(oplockThread)) {
1126                 rc = PTR_ERR(oplockThread);
1127                 cERROR(1, ("error %d create oplock thread", rc));
1128                 goto out_unregister_dfs_key_type;
1129         }
1130
1131         return 0;
1132
1133  out_unregister_dfs_key_type:
1134 #ifdef CONFIG_CIFS_DFS_UPCALL
1135         unregister_key_type(&key_type_dns_resolver);
1136  out_unregister_key_type:
1137 #endif
1138 #ifdef CONFIG_CIFS_UPCALL
1139         unregister_key_type(&cifs_spnego_key_type);
1140  out_unregister_filesystem:
1141 #endif
1142         unregister_filesystem(&cifs_fs_type);
1143  out_destroy_request_bufs:
1144         cifs_destroy_request_bufs();
1145  out_destroy_mids:
1146         cifs_destroy_mids();
1147  out_destroy_inodecache:
1148         cifs_destroy_inodecache();
1149  out_clean_proc:
1150         cifs_proc_clean();
1151         return rc;
1152 }
1153
1154 static void __exit
1155 exit_cifs(void)
1156 {
1157         cFYI(DBG2, ("exit_cifs"));
1158         cifs_proc_clean();
1159 #ifdef CONFIG_CIFS_DFS_UPCALL
1160         cifs_dfs_release_automount_timer();
1161         unregister_key_type(&key_type_dns_resolver);
1162 #endif
1163 #ifdef CONFIG_CIFS_UPCALL
1164         unregister_key_type(&cifs_spnego_key_type);
1165 #endif
1166         unregister_filesystem(&cifs_fs_type);
1167         cifs_destroy_inodecache();
1168         cifs_destroy_mids();
1169         cifs_destroy_request_bufs();
1170         kthread_stop(oplockThread);
1171 }
1172
1173 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1174 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1175 MODULE_DESCRIPTION
1176     ("VFS to access servers complying with the SNIA CIFS Specification "
1177      "e.g. Samba and Windows");
1178 MODULE_VERSION(CIFS_VERSION);
1179 module_init(init_cifs)
1180 module_exit(exit_cifs)