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