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