cifs: convert cifs_writepages to use async writes
[firefly-linux-kernel-4.4.55.git] / fs / cifs / cifsfs.c
1 /*
2  *   fs/cifs/cifsfs.c
3  *
4  *   Copyright (C) International Business Machines  Corp., 2002,2008
5  *   Author(s): Steve French (sfrench@us.ibm.com)
6  *
7  *   Common Internet FileSystem (CIFS) client
8  *
9  *   This library is free software; you can redistribute it and/or modify
10  *   it under the terms of the GNU Lesser General Public License as published
11  *   by the Free Software Foundation; either version 2.1 of the License, or
12  *   (at your option) any later version.
13  *
14  *   This library is distributed in the hope that it will be useful,
15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
17  *   the GNU Lesser General Public License for more details.
18  *
19  *   You should have received a copy of the GNU Lesser General Public License
20  *   along with this library; if not, write to the Free Software
21  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22  */
23
24 /* Note that BB means BUGBUG (ie something to fix eventually) */
25
26 #include <linux/module.h>
27 #include <linux/fs.h>
28 #include <linux/mount.h>
29 #include <linux/slab.h>
30 #include <linux/init.h>
31 #include <linux/list.h>
32 #include <linux/seq_file.h>
33 #include <linux/vfs.h>
34 #include <linux/mempool.h>
35 #include <linux/delay.h>
36 #include <linux/kthread.h>
37 #include <linux/freezer.h>
38 #include <net/ipv6.h>
39 #include "cifsfs.h"
40 #include "cifspdu.h"
41 #define DECLARE_GLOBALS_HERE
42 #include "cifsglob.h"
43 #include "cifsproto.h"
44 #include "cifs_debug.h"
45 #include "cifs_fs_sb.h"
46 #include <linux/mm.h>
47 #include <linux/key-type.h>
48 #include "cifs_spnego.h"
49 #include "fscache.h"
50 #define CIFS_MAGIC_NUMBER 0xFF534D42    /* the first four bytes of SMB PDUs */
51
52 int cifsFYI = 0;
53 int cifsERROR = 1;
54 int traceSMB = 0;
55 unsigned int oplockEnabled = 1;
56 unsigned int linuxExtEnabled = 1;
57 unsigned int lookupCacheEnabled = 1;
58 unsigned int multiuser_mount = 0;
59 unsigned int global_secflags = CIFSSEC_DEF;
60 /* unsigned int ntlmv2_support = 0; */
61 unsigned int sign_CIFS_PDUs = 1;
62 static const struct super_operations cifs_super_ops;
63 unsigned int CIFSMaxBufSize = CIFS_MAX_MSGSIZE;
64 module_param(CIFSMaxBufSize, int, 0);
65 MODULE_PARM_DESC(CIFSMaxBufSize, "Network buffer size (not including header). "
66                                  "Default: 16384 Range: 8192 to 130048");
67 unsigned int cifs_min_rcv = CIFS_MIN_RCV_POOL;
68 module_param(cifs_min_rcv, int, 0);
69 MODULE_PARM_DESC(cifs_min_rcv, "Network buffers in pool. Default: 4 Range: "
70                                 "1 to 64");
71 unsigned int cifs_min_small = 30;
72 module_param(cifs_min_small, int, 0);
73 MODULE_PARM_DESC(cifs_min_small, "Small network buffers in pool. Default: 30 "
74                                  "Range: 2 to 256");
75 unsigned int cifs_max_pending = CIFS_MAX_REQ;
76 module_param(cifs_max_pending, int, 0);
77 MODULE_PARM_DESC(cifs_max_pending, "Simultaneous requests to server. "
78                                    "Default: 50 Range: 2 to 256");
79 unsigned short echo_retries = 5;
80 module_param(echo_retries, ushort, 0644);
81 MODULE_PARM_DESC(echo_retries, "Number of echo attempts before giving up and "
82                                "reconnecting server. Default: 5. 0 means "
83                                "never reconnect.");
84 extern mempool_t *cifs_sm_req_poolp;
85 extern mempool_t *cifs_req_poolp;
86 extern mempool_t *cifs_mid_poolp;
87
88 void
89 cifs_sb_active(struct super_block *sb)
90 {
91         struct cifs_sb_info *server = CIFS_SB(sb);
92
93         if (atomic_inc_return(&server->active) == 1)
94                 atomic_inc(&sb->s_active);
95 }
96
97 void
98 cifs_sb_deactive(struct super_block *sb)
99 {
100         struct cifs_sb_info *server = CIFS_SB(sb);
101
102         if (atomic_dec_and_test(&server->active))
103                 deactivate_super(sb);
104 }
105
106 static int
107 cifs_read_super(struct super_block *sb, struct smb_vol *volume_info,
108                 const char *devname, int silent)
109 {
110         struct inode *inode;
111         struct cifs_sb_info *cifs_sb;
112         int rc = 0;
113
114         cifs_sb = CIFS_SB(sb);
115
116         spin_lock_init(&cifs_sb->tlink_tree_lock);
117         cifs_sb->tlink_tree = RB_ROOT;
118
119         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
120         if (rc)
121                 return rc;
122
123         cifs_sb->bdi.ra_pages = default_backing_dev_info.ra_pages;
124
125         rc = cifs_mount(sb, cifs_sb, volume_info, devname);
126
127         if (rc) {
128                 if (!silent)
129                         cERROR(1, "cifs_mount failed w/return code = %d", rc);
130                 goto out_mount_failed;
131         }
132
133         sb->s_magic = CIFS_MAGIC_NUMBER;
134         sb->s_op = &cifs_super_ops;
135         sb->s_bdi = &cifs_sb->bdi;
136         sb->s_blocksize = CIFS_MAX_MSGSIZE;
137         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
138         inode = cifs_root_iget(sb);
139
140         if (IS_ERR(inode)) {
141                 rc = PTR_ERR(inode);
142                 inode = NULL;
143                 goto out_no_root;
144         }
145
146         sb->s_root = d_alloc_root(inode);
147
148         if (!sb->s_root) {
149                 rc = -ENOMEM;
150                 goto out_no_root;
151         }
152
153         /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */
154         if (cifs_sb_master_tcon(cifs_sb)->nocase)
155                 sb->s_d_op = &cifs_ci_dentry_ops;
156         else
157                 sb->s_d_op = &cifs_dentry_ops;
158
159 #ifdef CIFS_NFSD_EXPORT
160         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
161                 cFYI(1, "export ops supported");
162                 sb->s_export_op = &cifs_export_ops;
163         }
164 #endif /* CIFS_NFSD_EXPORT */
165
166         return 0;
167
168 out_no_root:
169         cERROR(1, "cifs_read_super: get root inode failed");
170         if (inode)
171                 iput(inode);
172
173         cifs_umount(sb, cifs_sb);
174
175 out_mount_failed:
176         bdi_destroy(&cifs_sb->bdi);
177         return rc;
178 }
179
180 static void
181 cifs_put_super(struct super_block *sb)
182 {
183         int rc = 0;
184         struct cifs_sb_info *cifs_sb;
185
186         cFYI(1, "In cifs_put_super");
187         cifs_sb = CIFS_SB(sb);
188         if (cifs_sb == NULL) {
189                 cFYI(1, "Empty cifs superblock info passed to unmount");
190                 return;
191         }
192
193         rc = cifs_umount(sb, cifs_sb);
194         if (rc)
195                 cERROR(1, "cifs_umount failed with return code %d", rc);
196         if (cifs_sb->mountdata) {
197                 kfree(cifs_sb->mountdata);
198                 cifs_sb->mountdata = NULL;
199         }
200
201         unload_nls(cifs_sb->local_nls);
202         bdi_destroy(&cifs_sb->bdi);
203         kfree(cifs_sb);
204 }
205
206 static int
207 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
208 {
209         struct super_block *sb = dentry->d_sb;
210         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
211         struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
212         int rc = -EOPNOTSUPP;
213         int xid;
214
215         xid = GetXid();
216
217         buf->f_type = CIFS_MAGIC_NUMBER;
218
219         /*
220          * PATH_MAX may be too long - it would presumably be total path,
221          * but note that some servers (includinng Samba 3) have a shorter
222          * maximum path.
223          *
224          * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
225          */
226         buf->f_namelen = PATH_MAX;
227         buf->f_files = 0;       /* undefined */
228         buf->f_ffree = 0;       /* unlimited */
229
230         /*
231          * We could add a second check for a QFS Unix capability bit
232          */
233         if ((tcon->ses->capabilities & CAP_UNIX) &&
234             (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
235                 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
236
237         /*
238          * Only need to call the old QFSInfo if failed on newer one,
239          * e.g. by OS/2.
240          **/
241         if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
242                 rc = CIFSSMBQFSInfo(xid, tcon, buf);
243
244         /*
245          * Some old Windows servers also do not support level 103, retry with
246          * older level one if old server failed the previous call or we
247          * bypassed it because we detected that this was an older LANMAN sess
248          */
249         if (rc)
250                 rc = SMBOldQFSInfo(xid, tcon, buf);
251
252         FreeXid(xid);
253         return 0;
254 }
255
256 static int cifs_permission(struct inode *inode, int mask, unsigned int flags)
257 {
258         struct cifs_sb_info *cifs_sb;
259
260         if (flags & IPERM_FLAG_RCU)
261                 return -ECHILD;
262
263         cifs_sb = CIFS_SB(inode->i_sb);
264
265         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
266                 if ((mask & MAY_EXEC) && !execute_ok(inode))
267                         return -EACCES;
268                 else
269                         return 0;
270         } else /* file mode might have been restricted at mount time
271                 on the client (above and beyond ACL on servers) for
272                 servers which do not support setting and viewing mode bits,
273                 so allowing client to check permissions is useful */
274                 return generic_permission(inode, mask, flags, NULL);
275 }
276
277 static struct kmem_cache *cifs_inode_cachep;
278 static struct kmem_cache *cifs_req_cachep;
279 static struct kmem_cache *cifs_mid_cachep;
280 static struct kmem_cache *cifs_sm_req_cachep;
281 mempool_t *cifs_sm_req_poolp;
282 mempool_t *cifs_req_poolp;
283 mempool_t *cifs_mid_poolp;
284
285 static struct inode *
286 cifs_alloc_inode(struct super_block *sb)
287 {
288         struct cifsInodeInfo *cifs_inode;
289         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
290         if (!cifs_inode)
291                 return NULL;
292         cifs_inode->cifsAttrs = 0x20;   /* default */
293         cifs_inode->time = 0;
294         /* Until the file is open and we have gotten oplock
295         info back from the server, can not assume caching of
296         file data or metadata */
297         cifs_set_oplock_level(cifs_inode, 0);
298         cifs_inode->delete_pending = false;
299         cifs_inode->invalid_mapping = false;
300         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
301         cifs_inode->server_eof = 0;
302         cifs_inode->uniqueid = 0;
303         cifs_inode->createtime = 0;
304
305         /* Can not set i_flags here - they get immediately overwritten
306            to zero by the VFS */
307 /*      cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
308         INIT_LIST_HEAD(&cifs_inode->openFileList);
309         return &cifs_inode->vfs_inode;
310 }
311
312 static void cifs_i_callback(struct rcu_head *head)
313 {
314         struct inode *inode = container_of(head, struct inode, i_rcu);
315         INIT_LIST_HEAD(&inode->i_dentry);
316         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
317 }
318
319 static void
320 cifs_destroy_inode(struct inode *inode)
321 {
322         call_rcu(&inode->i_rcu, cifs_i_callback);
323 }
324
325 static void
326 cifs_evict_inode(struct inode *inode)
327 {
328         truncate_inode_pages(&inode->i_data, 0);
329         end_writeback(inode);
330         cifs_fscache_release_inode_cookie(inode);
331 }
332
333 static void
334 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
335 {
336         struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
337         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
338
339         seq_printf(s, ",addr=");
340
341         switch (server->dstaddr.ss_family) {
342         case AF_INET:
343                 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
344                 break;
345         case AF_INET6:
346                 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
347                 if (sa6->sin6_scope_id)
348                         seq_printf(s, "%%%u", sa6->sin6_scope_id);
349                 break;
350         default:
351                 seq_printf(s, "(unknown)");
352         }
353 }
354
355 /*
356  * cifs_show_options() is for displaying mount options in /proc/mounts.
357  * Not all settable options are displayed but most of the important
358  * ones are.
359  */
360 static int
361 cifs_show_options(struct seq_file *s, struct vfsmount *m)
362 {
363         struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
364         struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
365         struct sockaddr *srcaddr;
366         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
367
368         seq_printf(s, ",unc=%s", tcon->treeName);
369
370         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
371                 seq_printf(s, ",multiuser");
372         else if (tcon->ses->user_name)
373                 seq_printf(s, ",username=%s", tcon->ses->user_name);
374
375         if (tcon->ses->domainName)
376                 seq_printf(s, ",domain=%s", tcon->ses->domainName);
377
378         if (srcaddr->sa_family != AF_UNSPEC) {
379                 struct sockaddr_in *saddr4;
380                 struct sockaddr_in6 *saddr6;
381                 saddr4 = (struct sockaddr_in *)srcaddr;
382                 saddr6 = (struct sockaddr_in6 *)srcaddr;
383                 if (srcaddr->sa_family == AF_INET6)
384                         seq_printf(s, ",srcaddr=%pI6c",
385                                    &saddr6->sin6_addr);
386                 else if (srcaddr->sa_family == AF_INET)
387                         seq_printf(s, ",srcaddr=%pI4",
388                                    &saddr4->sin_addr.s_addr);
389                 else
390                         seq_printf(s, ",srcaddr=BAD-AF:%i",
391                                    (int)(srcaddr->sa_family));
392         }
393
394         seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
395         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
396                 seq_printf(s, ",forceuid");
397         else
398                 seq_printf(s, ",noforceuid");
399
400         seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
401         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
402                 seq_printf(s, ",forcegid");
403         else
404                 seq_printf(s, ",noforcegid");
405
406         cifs_show_address(s, tcon->ses->server);
407
408         if (!tcon->unix_ext)
409                 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
410                                            cifs_sb->mnt_file_mode,
411                                            cifs_sb->mnt_dir_mode);
412         if (tcon->seal)
413                 seq_printf(s, ",seal");
414         if (tcon->nocase)
415                 seq_printf(s, ",nocase");
416         if (tcon->retry)
417                 seq_printf(s, ",hard");
418         if (cifs_sb->prepath)
419                 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
420         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
421                 seq_printf(s, ",posixpaths");
422         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
423                 seq_printf(s, ",setuids");
424         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
425                 seq_printf(s, ",serverino");
426         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
427                 seq_printf(s, ",directio");
428         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
429                 seq_printf(s, ",nouser_xattr");
430         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
431                 seq_printf(s, ",mapchars");
432         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
433                 seq_printf(s, ",sfu");
434         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
435                 seq_printf(s, ",nobrl");
436         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
437                 seq_printf(s, ",cifsacl");
438         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
439                 seq_printf(s, ",dynperm");
440         if (m->mnt_sb->s_flags & MS_POSIXACL)
441                 seq_printf(s, ",acl");
442         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
443                 seq_printf(s, ",mfsymlinks");
444         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
445                 seq_printf(s, ",fsc");
446
447         seq_printf(s, ",rsize=%d", cifs_sb->rsize);
448         seq_printf(s, ",wsize=%d", cifs_sb->wsize);
449         /* convert actimeo and display it in seconds */
450                 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
451
452         return 0;
453 }
454
455 static void cifs_umount_begin(struct super_block *sb)
456 {
457         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
458         struct cifsTconInfo *tcon;
459
460         if (cifs_sb == NULL)
461                 return;
462
463         tcon = cifs_sb_master_tcon(cifs_sb);
464
465         spin_lock(&cifs_tcp_ses_lock);
466         if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
467                 /* we have other mounts to same share or we have
468                    already tried to force umount this and woken up
469                    all waiting network requests, nothing to do */
470                 spin_unlock(&cifs_tcp_ses_lock);
471                 return;
472         } else if (tcon->tc_count == 1)
473                 tcon->tidStatus = CifsExiting;
474         spin_unlock(&cifs_tcp_ses_lock);
475
476         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
477         /* cancel_notify_requests(tcon); */
478         if (tcon->ses && tcon->ses->server) {
479                 cFYI(1, "wake up tasks now - umount begin not complete");
480                 wake_up_all(&tcon->ses->server->request_q);
481                 wake_up_all(&tcon->ses->server->response_q);
482                 msleep(1); /* yield */
483                 /* we have to kick the requests once more */
484                 wake_up_all(&tcon->ses->server->response_q);
485                 msleep(1);
486         }
487
488         return;
489 }
490
491 #ifdef CONFIG_CIFS_STATS2
492 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
493 {
494         /* BB FIXME */
495         return 0;
496 }
497 #endif
498
499 static int cifs_remount(struct super_block *sb, int *flags, char *data)
500 {
501         *flags |= MS_NODIRATIME;
502         return 0;
503 }
504
505 static int cifs_drop_inode(struct inode *inode)
506 {
507         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
508
509         /* no serverino => unconditional eviction */
510         return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
511                 generic_drop_inode(inode);
512 }
513
514 static const struct super_operations cifs_super_ops = {
515         .put_super = cifs_put_super,
516         .statfs = cifs_statfs,
517         .alloc_inode = cifs_alloc_inode,
518         .destroy_inode = cifs_destroy_inode,
519         .drop_inode     = cifs_drop_inode,
520         .evict_inode    = cifs_evict_inode,
521 /*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
522         function unless later we add lazy close of inodes or unless the
523         kernel forgets to call us with the same number of releases (closes)
524         as opens */
525         .show_options = cifs_show_options,
526         .umount_begin   = cifs_umount_begin,
527         .remount_fs = cifs_remount,
528 #ifdef CONFIG_CIFS_STATS2
529         .show_stats = cifs_show_stats,
530 #endif
531 };
532
533 static struct dentry *
534 cifs_do_mount(struct file_system_type *fs_type,
535               int flags, const char *dev_name, void *data)
536 {
537         int rc;
538         struct super_block *sb;
539         struct cifs_sb_info *cifs_sb;
540         struct smb_vol *volume_info;
541         struct dentry *root;
542
543         cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
544
545         rc = cifs_setup_volume_info(&volume_info, (char *)data, dev_name);
546         if (rc)
547                 return ERR_PTR(rc);
548
549         cifs_sb = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
550         if (cifs_sb == NULL) {
551                 root = ERR_PTR(-ENOMEM);
552                 goto out;
553         }
554
555         cifs_setup_cifs_sb(volume_info, cifs_sb);
556
557         sb = sget(fs_type, NULL, set_anon_super, NULL);
558         if (IS_ERR(sb)) {
559                 kfree(cifs_sb);
560                 root = ERR_CAST(sb);
561                 goto out;
562         }
563
564         /*
565          * Copy mount params for use in submounts. Better to do
566          * the copy here and deal with the error before cleanup gets
567          * complicated post-mount.
568          */
569         cifs_sb->mountdata = kstrndup(data, PAGE_SIZE, GFP_KERNEL);
570         if (cifs_sb->mountdata == NULL) {
571                 root = ERR_PTR(-ENOMEM);
572                 goto err_out;
573         }
574
575         sb->s_flags = flags;
576         /* BB should we make this contingent on mount parm? */
577         sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
578         sb->s_fs_info = cifs_sb;
579
580         rc = cifs_read_super(sb, volume_info, dev_name,
581                              flags & MS_SILENT ? 1 : 0);
582         if (rc) {
583                 root = ERR_PTR(rc);
584                 goto err_out;
585         }
586
587         sb->s_flags |= MS_ACTIVE;
588
589         root = dget(sb->s_root);
590 out:
591         cifs_cleanup_volume_info(&volume_info);
592         return root;
593
594 err_out:
595         kfree(cifs_sb->mountdata);
596         unload_nls(cifs_sb->local_nls);
597         kfree(cifs_sb);
598         deactivate_locked_super(sb);
599         cifs_cleanup_volume_info(&volume_info);
600         return root;
601 }
602
603 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
604                                    unsigned long nr_segs, loff_t pos)
605 {
606         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
607         ssize_t written;
608         int rc;
609
610         written = generic_file_aio_write(iocb, iov, nr_segs, pos);
611
612         if (CIFS_I(inode)->clientCanCacheAll)
613                 return written;
614
615         rc = filemap_fdatawrite(inode->i_mapping);
616         if (rc)
617                 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
618
619         return written;
620 }
621
622 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
623 {
624         /* origin == SEEK_END => we must revalidate the cached file length */
625         if (origin == SEEK_END) {
626                 int rc;
627                 struct inode *inode = file->f_path.dentry->d_inode;
628
629                 /*
630                  * We need to be sure that all dirty pages are written and the
631                  * server has the newest file length.
632                  */
633                 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
634                     inode->i_mapping->nrpages != 0) {
635                         rc = filemap_fdatawait(inode->i_mapping);
636                         if (rc) {
637                                 mapping_set_error(inode->i_mapping, rc);
638                                 return rc;
639                         }
640                 }
641                 /*
642                  * Some applications poll for the file length in this strange
643                  * way so we must seek to end on non-oplocked files by
644                  * setting the revalidate time to zero.
645                  */
646                 CIFS_I(inode)->time = 0;
647
648                 rc = cifs_revalidate_file_attr(file);
649                 if (rc < 0)
650                         return (loff_t)rc;
651         }
652         return generic_file_llseek_unlocked(file, offset, origin);
653 }
654
655 static int cifs_setlease(struct file *file, long arg, struct file_lock **lease)
656 {
657         /* note that this is called by vfs setlease with lock_flocks held
658            to protect *lease from going away */
659         struct inode *inode = file->f_path.dentry->d_inode;
660         struct cifsFileInfo *cfile = file->private_data;
661
662         if (!(S_ISREG(inode->i_mode)))
663                 return -EINVAL;
664
665         /* check if file is oplocked */
666         if (((arg == F_RDLCK) &&
667                 (CIFS_I(inode)->clientCanCacheRead)) ||
668             ((arg == F_WRLCK) &&
669                 (CIFS_I(inode)->clientCanCacheAll)))
670                 return generic_setlease(file, arg, lease);
671         else if (tlink_tcon(cfile->tlink)->local_lease &&
672                  !CIFS_I(inode)->clientCanCacheRead)
673                 /* If the server claims to support oplock on this
674                    file, then we still need to check oplock even
675                    if the local_lease mount option is set, but there
676                    are servers which do not support oplock for which
677                    this mount option may be useful if the user
678                    knows that the file won't be changed on the server
679                    by anyone else */
680                 return generic_setlease(file, arg, lease);
681         else
682                 return -EAGAIN;
683 }
684
685 struct file_system_type cifs_fs_type = {
686         .owner = THIS_MODULE,
687         .name = "cifs",
688         .mount = cifs_do_mount,
689         .kill_sb = kill_anon_super,
690         /*  .fs_flags */
691 };
692 const struct inode_operations cifs_dir_inode_ops = {
693         .create = cifs_create,
694         .lookup = cifs_lookup,
695         .getattr = cifs_getattr,
696         .unlink = cifs_unlink,
697         .link = cifs_hardlink,
698         .mkdir = cifs_mkdir,
699         .rmdir = cifs_rmdir,
700         .rename = cifs_rename,
701         .permission = cifs_permission,
702 /*      revalidate:cifs_revalidate,   */
703         .setattr = cifs_setattr,
704         .symlink = cifs_symlink,
705         .mknod   = cifs_mknod,
706 #ifdef CONFIG_CIFS_XATTR
707         .setxattr = cifs_setxattr,
708         .getxattr = cifs_getxattr,
709         .listxattr = cifs_listxattr,
710         .removexattr = cifs_removexattr,
711 #endif
712 };
713
714 const struct inode_operations cifs_file_inode_ops = {
715 /*      revalidate:cifs_revalidate, */
716         .setattr = cifs_setattr,
717         .getattr = cifs_getattr, /* do we need this anymore? */
718         .rename = cifs_rename,
719         .permission = cifs_permission,
720 #ifdef CONFIG_CIFS_XATTR
721         .setxattr = cifs_setxattr,
722         .getxattr = cifs_getxattr,
723         .listxattr = cifs_listxattr,
724         .removexattr = cifs_removexattr,
725 #endif
726 };
727
728 const struct inode_operations cifs_symlink_inode_ops = {
729         .readlink = generic_readlink,
730         .follow_link = cifs_follow_link,
731         .put_link = cifs_put_link,
732         .permission = cifs_permission,
733         /* BB add the following two eventually */
734         /* revalidate: cifs_revalidate,
735            setattr:    cifs_notify_change, *//* BB do we need notify change */
736 #ifdef CONFIG_CIFS_XATTR
737         .setxattr = cifs_setxattr,
738         .getxattr = cifs_getxattr,
739         .listxattr = cifs_listxattr,
740         .removexattr = cifs_removexattr,
741 #endif
742 };
743
744 const struct file_operations cifs_file_ops = {
745         .read = do_sync_read,
746         .write = do_sync_write,
747         .aio_read = generic_file_aio_read,
748         .aio_write = cifs_file_aio_write,
749         .open = cifs_open,
750         .release = cifs_close,
751         .lock = cifs_lock,
752         .fsync = cifs_fsync,
753         .flush = cifs_flush,
754         .mmap  = cifs_file_mmap,
755         .splice_read = generic_file_splice_read,
756         .llseek = cifs_llseek,
757 #ifdef CONFIG_CIFS_POSIX
758         .unlocked_ioctl = cifs_ioctl,
759 #endif /* CONFIG_CIFS_POSIX */
760         .setlease = cifs_setlease,
761 };
762
763 const struct file_operations cifs_file_strict_ops = {
764         .read = do_sync_read,
765         .write = do_sync_write,
766         .aio_read = cifs_strict_readv,
767         .aio_write = cifs_strict_writev,
768         .open = cifs_open,
769         .release = cifs_close,
770         .lock = cifs_lock,
771         .fsync = cifs_strict_fsync,
772         .flush = cifs_flush,
773         .mmap = cifs_file_strict_mmap,
774         .splice_read = generic_file_splice_read,
775         .llseek = cifs_llseek,
776 #ifdef CONFIG_CIFS_POSIX
777         .unlocked_ioctl = cifs_ioctl,
778 #endif /* CONFIG_CIFS_POSIX */
779         .setlease = cifs_setlease,
780 };
781
782 const struct file_operations cifs_file_direct_ops = {
783         /* BB reevaluate whether they can be done with directio, no cache */
784         .read = do_sync_read,
785         .write = do_sync_write,
786         .aio_read = cifs_user_readv,
787         .aio_write = cifs_user_writev,
788         .open = cifs_open,
789         .release = cifs_close,
790         .lock = cifs_lock,
791         .fsync = cifs_fsync,
792         .flush = cifs_flush,
793         .mmap = cifs_file_mmap,
794         .splice_read = generic_file_splice_read,
795 #ifdef CONFIG_CIFS_POSIX
796         .unlocked_ioctl  = cifs_ioctl,
797 #endif /* CONFIG_CIFS_POSIX */
798         .llseek = cifs_llseek,
799         .setlease = cifs_setlease,
800 };
801
802 const struct file_operations cifs_file_nobrl_ops = {
803         .read = do_sync_read,
804         .write = do_sync_write,
805         .aio_read = generic_file_aio_read,
806         .aio_write = cifs_file_aio_write,
807         .open = cifs_open,
808         .release = cifs_close,
809         .fsync = cifs_fsync,
810         .flush = cifs_flush,
811         .mmap  = cifs_file_mmap,
812         .splice_read = generic_file_splice_read,
813         .llseek = cifs_llseek,
814 #ifdef CONFIG_CIFS_POSIX
815         .unlocked_ioctl = cifs_ioctl,
816 #endif /* CONFIG_CIFS_POSIX */
817         .setlease = cifs_setlease,
818 };
819
820 const struct file_operations cifs_file_strict_nobrl_ops = {
821         .read = do_sync_read,
822         .write = do_sync_write,
823         .aio_read = cifs_strict_readv,
824         .aio_write = cifs_strict_writev,
825         .open = cifs_open,
826         .release = cifs_close,
827         .fsync = cifs_strict_fsync,
828         .flush = cifs_flush,
829         .mmap = cifs_file_strict_mmap,
830         .splice_read = generic_file_splice_read,
831         .llseek = cifs_llseek,
832 #ifdef CONFIG_CIFS_POSIX
833         .unlocked_ioctl = cifs_ioctl,
834 #endif /* CONFIG_CIFS_POSIX */
835         .setlease = cifs_setlease,
836 };
837
838 const struct file_operations cifs_file_direct_nobrl_ops = {
839         /* BB reevaluate whether they can be done with directio, no cache */
840         .read = do_sync_read,
841         .write = do_sync_write,
842         .aio_read = cifs_user_readv,
843         .aio_write = cifs_user_writev,
844         .open = cifs_open,
845         .release = cifs_close,
846         .fsync = cifs_fsync,
847         .flush = cifs_flush,
848         .mmap = cifs_file_mmap,
849         .splice_read = generic_file_splice_read,
850 #ifdef CONFIG_CIFS_POSIX
851         .unlocked_ioctl  = cifs_ioctl,
852 #endif /* CONFIG_CIFS_POSIX */
853         .llseek = cifs_llseek,
854         .setlease = cifs_setlease,
855 };
856
857 const struct file_operations cifs_dir_ops = {
858         .readdir = cifs_readdir,
859         .release = cifs_closedir,
860         .read    = generic_read_dir,
861         .unlocked_ioctl  = cifs_ioctl,
862         .llseek = generic_file_llseek,
863 };
864
865 static void
866 cifs_init_once(void *inode)
867 {
868         struct cifsInodeInfo *cifsi = inode;
869
870         inode_init_once(&cifsi->vfs_inode);
871         INIT_LIST_HEAD(&cifsi->lockList);
872 }
873
874 static int
875 cifs_init_inodecache(void)
876 {
877         cifs_inode_cachep = kmem_cache_create("cifs_inode_cache",
878                                               sizeof(struct cifsInodeInfo),
879                                               0, (SLAB_RECLAIM_ACCOUNT|
880                                                 SLAB_MEM_SPREAD),
881                                               cifs_init_once);
882         if (cifs_inode_cachep == NULL)
883                 return -ENOMEM;
884
885         return 0;
886 }
887
888 static void
889 cifs_destroy_inodecache(void)
890 {
891         kmem_cache_destroy(cifs_inode_cachep);
892 }
893
894 static int
895 cifs_init_request_bufs(void)
896 {
897         if (CIFSMaxBufSize < 8192) {
898         /* Buffer size can not be smaller than 2 * PATH_MAX since maximum
899         Unicode path name has to fit in any SMB/CIFS path based frames */
900                 CIFSMaxBufSize = 8192;
901         } else if (CIFSMaxBufSize > 1024*127) {
902                 CIFSMaxBufSize = 1024 * 127;
903         } else {
904                 CIFSMaxBufSize &= 0x1FE00; /* Round size to even 512 byte mult*/
905         }
906 /*      cERROR(1, "CIFSMaxBufSize %d 0x%x",CIFSMaxBufSize,CIFSMaxBufSize); */
907         cifs_req_cachep = kmem_cache_create("cifs_request",
908                                             CIFSMaxBufSize +
909                                             MAX_CIFS_HDR_SIZE, 0,
910                                             SLAB_HWCACHE_ALIGN, NULL);
911         if (cifs_req_cachep == NULL)
912                 return -ENOMEM;
913
914         if (cifs_min_rcv < 1)
915                 cifs_min_rcv = 1;
916         else if (cifs_min_rcv > 64) {
917                 cifs_min_rcv = 64;
918                 cERROR(1, "cifs_min_rcv set to maximum (64)");
919         }
920
921         cifs_req_poolp = mempool_create_slab_pool(cifs_min_rcv,
922                                                   cifs_req_cachep);
923
924         if (cifs_req_poolp == NULL) {
925                 kmem_cache_destroy(cifs_req_cachep);
926                 return -ENOMEM;
927         }
928         /* MAX_CIFS_SMALL_BUFFER_SIZE bytes is enough for most SMB responses and
929         almost all handle based requests (but not write response, nor is it
930         sufficient for path based requests).  A smaller size would have
931         been more efficient (compacting multiple slab items on one 4k page)
932         for the case in which debug was on, but this larger size allows
933         more SMBs to use small buffer alloc and is still much more
934         efficient to alloc 1 per page off the slab compared to 17K (5page)
935         alloc of large cifs buffers even when page debugging is on */
936         cifs_sm_req_cachep = kmem_cache_create("cifs_small_rq",
937                         MAX_CIFS_SMALL_BUFFER_SIZE, 0, SLAB_HWCACHE_ALIGN,
938                         NULL);
939         if (cifs_sm_req_cachep == NULL) {
940                 mempool_destroy(cifs_req_poolp);
941                 kmem_cache_destroy(cifs_req_cachep);
942                 return -ENOMEM;
943         }
944
945         if (cifs_min_small < 2)
946                 cifs_min_small = 2;
947         else if (cifs_min_small > 256) {
948                 cifs_min_small = 256;
949                 cFYI(1, "cifs_min_small set to maximum (256)");
950         }
951
952         cifs_sm_req_poolp = mempool_create_slab_pool(cifs_min_small,
953                                                      cifs_sm_req_cachep);
954
955         if (cifs_sm_req_poolp == NULL) {
956                 mempool_destroy(cifs_req_poolp);
957                 kmem_cache_destroy(cifs_req_cachep);
958                 kmem_cache_destroy(cifs_sm_req_cachep);
959                 return -ENOMEM;
960         }
961
962         return 0;
963 }
964
965 static void
966 cifs_destroy_request_bufs(void)
967 {
968         mempool_destroy(cifs_req_poolp);
969         kmem_cache_destroy(cifs_req_cachep);
970         mempool_destroy(cifs_sm_req_poolp);
971         kmem_cache_destroy(cifs_sm_req_cachep);
972 }
973
974 static int
975 cifs_init_mids(void)
976 {
977         cifs_mid_cachep = kmem_cache_create("cifs_mpx_ids",
978                                             sizeof(struct mid_q_entry), 0,
979                                             SLAB_HWCACHE_ALIGN, NULL);
980         if (cifs_mid_cachep == NULL)
981                 return -ENOMEM;
982
983         /* 3 is a reasonable minimum number of simultaneous operations */
984         cifs_mid_poolp = mempool_create_slab_pool(3, cifs_mid_cachep);
985         if (cifs_mid_poolp == NULL) {
986                 kmem_cache_destroy(cifs_mid_cachep);
987                 return -ENOMEM;
988         }
989
990         return 0;
991 }
992
993 static void
994 cifs_destroy_mids(void)
995 {
996         mempool_destroy(cifs_mid_poolp);
997         kmem_cache_destroy(cifs_mid_cachep);
998 }
999
1000 static int __init
1001 init_cifs(void)
1002 {
1003         int rc = 0;
1004         cifs_proc_init();
1005         INIT_LIST_HEAD(&cifs_tcp_ses_list);
1006 #ifdef CONFIG_CIFS_DNOTIFY_EXPERIMENTAL /* unused temporarily */
1007         INIT_LIST_HEAD(&GlobalDnotifyReqList);
1008         INIT_LIST_HEAD(&GlobalDnotifyRsp_Q);
1009 #endif /* was needed for dnotify, and will be needed for inotify when VFS fix */
1010 /*
1011  *  Initialize Global counters
1012  */
1013         atomic_set(&sesInfoAllocCount, 0);
1014         atomic_set(&tconInfoAllocCount, 0);
1015         atomic_set(&tcpSesAllocCount, 0);
1016         atomic_set(&tcpSesReconnectCount, 0);
1017         atomic_set(&tconInfoReconnectCount, 0);
1018
1019         atomic_set(&bufAllocCount, 0);
1020         atomic_set(&smBufAllocCount, 0);
1021 #ifdef CONFIG_CIFS_STATS2
1022         atomic_set(&totBufAllocCount, 0);
1023         atomic_set(&totSmBufAllocCount, 0);
1024 #endif /* CONFIG_CIFS_STATS2 */
1025
1026         atomic_set(&midCount, 0);
1027         GlobalCurrentXid = 0;
1028         GlobalTotalActiveXid = 0;
1029         GlobalMaxActiveXid = 0;
1030         spin_lock_init(&cifs_tcp_ses_lock);
1031         spin_lock_init(&cifs_file_list_lock);
1032         spin_lock_init(&GlobalMid_Lock);
1033
1034         if (cifs_max_pending < 2) {
1035                 cifs_max_pending = 2;
1036                 cFYI(1, "cifs_max_pending set to min of 2");
1037         } else if (cifs_max_pending > 256) {
1038                 cifs_max_pending = 256;
1039                 cFYI(1, "cifs_max_pending set to max of 256");
1040         }
1041
1042         rc = cifs_fscache_register();
1043         if (rc)
1044                 goto out_clean_proc;
1045
1046         rc = cifs_init_inodecache();
1047         if (rc)
1048                 goto out_unreg_fscache;
1049
1050         rc = cifs_init_mids();
1051         if (rc)
1052                 goto out_destroy_inodecache;
1053
1054         rc = cifs_init_request_bufs();
1055         if (rc)
1056                 goto out_destroy_mids;
1057
1058 #ifdef CONFIG_CIFS_UPCALL
1059         rc = register_key_type(&cifs_spnego_key_type);
1060         if (rc)
1061                 goto out_destroy_request_bufs;
1062 #endif /* CONFIG_CIFS_UPCALL */
1063
1064 #ifdef CONFIG_CIFS_ACL
1065         rc = init_cifs_idmap();
1066         if (rc)
1067                 goto out_register_key_type;
1068 #endif /* CONFIG_CIFS_ACL */
1069
1070         rc = register_filesystem(&cifs_fs_type);
1071         if (rc)
1072                 goto out_init_cifs_idmap;
1073
1074         return 0;
1075
1076 out_init_cifs_idmap:
1077 #ifdef CONFIG_CIFS_ACL
1078         exit_cifs_idmap();
1079 out_register_key_type:
1080 #endif
1081 #ifdef CONFIG_CIFS_UPCALL
1082         unregister_key_type(&cifs_spnego_key_type);
1083 out_destroy_request_bufs:
1084 #endif
1085         cifs_destroy_request_bufs();
1086 out_destroy_mids:
1087         cifs_destroy_mids();
1088 out_destroy_inodecache:
1089         cifs_destroy_inodecache();
1090 out_unreg_fscache:
1091         cifs_fscache_unregister();
1092 out_clean_proc:
1093         cifs_proc_clean();
1094         return rc;
1095 }
1096
1097 static void __exit
1098 exit_cifs(void)
1099 {
1100         cFYI(DBG2, "exit_cifs");
1101         cifs_proc_clean();
1102         cifs_fscache_unregister();
1103 #ifdef CONFIG_CIFS_DFS_UPCALL
1104         cifs_dfs_release_automount_timer();
1105 #endif
1106 #ifdef CONFIG_CIFS_ACL
1107         cifs_destroy_idmaptrees();
1108         exit_cifs_idmap();
1109 #endif
1110 #ifdef CONFIG_CIFS_UPCALL
1111         unregister_key_type(&cifs_spnego_key_type);
1112 #endif
1113         unregister_filesystem(&cifs_fs_type);
1114         cifs_destroy_inodecache();
1115         cifs_destroy_mids();
1116         cifs_destroy_request_bufs();
1117 }
1118
1119 MODULE_AUTHOR("Steve French <sfrench@us.ibm.com>");
1120 MODULE_LICENSE("GPL");  /* combination of LGPL + GPL source behaves as GPL */
1121 MODULE_DESCRIPTION
1122     ("VFS to access servers complying with the SNIA CIFS Specification "
1123      "e.g. Samba and Windows");
1124 MODULE_VERSION(CIFS_VERSION);
1125 module_init(init_cifs)
1126 module_exit(exit_cifs)