[CIFS] Warn on requesting default security (ntlm) on mount
[pandora-kernel.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 bool sign_zero_copy;  /* globals init to false automatically */
85 module_param(sign_zero_copy, bool, 0644);
86 MODULE_PARM_DESC(sign_zero_copy, "Don't copy pages on write with signing "
87                                  "enabled. Default: N");
88 extern mempool_t *cifs_sm_req_poolp;
89 extern mempool_t *cifs_req_poolp;
90 extern mempool_t *cifs_mid_poolp;
91
92 void
93 cifs_sb_active(struct super_block *sb)
94 {
95         struct cifs_sb_info *server = CIFS_SB(sb);
96
97         if (atomic_inc_return(&server->active) == 1)
98                 atomic_inc(&sb->s_active);
99 }
100
101 void
102 cifs_sb_deactive(struct super_block *sb)
103 {
104         struct cifs_sb_info *server = CIFS_SB(sb);
105
106         if (atomic_dec_and_test(&server->active))
107                 deactivate_super(sb);
108 }
109
110 static int
111 cifs_read_super(struct super_block *sb, void *data,
112                 const char *devname, int silent)
113 {
114         struct inode *inode;
115         struct cifs_sb_info *cifs_sb;
116         int rc = 0;
117
118         /* BB should we make this contingent on mount parm? */
119         sb->s_flags |= MS_NODIRATIME | MS_NOATIME;
120         sb->s_fs_info = kzalloc(sizeof(struct cifs_sb_info), GFP_KERNEL);
121         cifs_sb = CIFS_SB(sb);
122         if (cifs_sb == NULL)
123                 return -ENOMEM;
124
125         spin_lock_init(&cifs_sb->tlink_tree_lock);
126         cifs_sb->tlink_tree = RB_ROOT;
127
128         rc = bdi_setup_and_register(&cifs_sb->bdi, "cifs", BDI_CAP_MAP_COPY);
129         if (rc) {
130                 kfree(cifs_sb);
131                 return rc;
132         }
133         cifs_sb->bdi.ra_pages = default_backing_dev_info.ra_pages;
134
135 #ifdef CONFIG_CIFS_DFS_UPCALL
136         /* copy mount params to sb for use in submounts */
137         /* BB: should we move this after the mount so we
138          * do not have to do the copy on failed mounts?
139          * BB: May be it is better to do simple copy before
140          * complex operation (mount), and in case of fail
141          * just exit instead of doing mount and attempting
142          * undo it if this copy fails?*/
143         if (data) {
144                 int len = strlen(data);
145                 cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
146                 if (cifs_sb->mountdata == NULL) {
147                         bdi_destroy(&cifs_sb->bdi);
148                         kfree(sb->s_fs_info);
149                         sb->s_fs_info = NULL;
150                         return -ENOMEM;
151                 }
152                 strncpy(cifs_sb->mountdata, data, len + 1);
153                 cifs_sb->mountdata[len] = '\0';
154         }
155 #endif
156
157         rc = cifs_mount(sb, cifs_sb, data, devname);
158
159         if (rc) {
160                 if (!silent)
161                         cERROR(1, "cifs_mount failed w/return code = %d", rc);
162                 goto out_mount_failed;
163         }
164
165         sb->s_magic = CIFS_MAGIC_NUMBER;
166         sb->s_op = &cifs_super_ops;
167         sb->s_bdi = &cifs_sb->bdi;
168         sb->s_blocksize = CIFS_MAX_MSGSIZE;
169         sb->s_blocksize_bits = 14;      /* default 2**14 = CIFS_MAX_MSGSIZE */
170         inode = cifs_root_iget(sb, ROOT_I);
171
172         if (IS_ERR(inode)) {
173                 rc = PTR_ERR(inode);
174                 inode = NULL;
175                 goto out_no_root;
176         }
177
178         sb->s_root = d_alloc_root(inode);
179
180         if (!sb->s_root) {
181                 rc = -ENOMEM;
182                 goto out_no_root;
183         }
184
185         /* do that *after* d_alloc_root() - we want NULL ->d_op for root here */
186         if (cifs_sb_master_tcon(cifs_sb)->nocase)
187                 sb->s_d_op = &cifs_ci_dentry_ops;
188         else
189                 sb->s_d_op = &cifs_dentry_ops;
190
191 #ifdef CONFIG_CIFS_EXPERIMENTAL
192         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
193                 cFYI(1, "export ops supported");
194                 sb->s_export_op = &cifs_export_ops;
195         }
196 #endif /* EXPERIMENTAL */
197
198         return 0;
199
200 out_no_root:
201         cERROR(1, "cifs_read_super: get root inode failed");
202         if (inode)
203                 iput(inode);
204
205         cifs_umount(sb, cifs_sb);
206
207 out_mount_failed:
208         if (cifs_sb) {
209 #ifdef CONFIG_CIFS_DFS_UPCALL
210                 if (cifs_sb->mountdata) {
211                         kfree(cifs_sb->mountdata);
212                         cifs_sb->mountdata = NULL;
213                 }
214 #endif
215                 unload_nls(cifs_sb->local_nls);
216                 bdi_destroy(&cifs_sb->bdi);
217                 kfree(cifs_sb);
218         }
219         return rc;
220 }
221
222 static void
223 cifs_put_super(struct super_block *sb)
224 {
225         int rc = 0;
226         struct cifs_sb_info *cifs_sb;
227
228         cFYI(1, "In cifs_put_super");
229         cifs_sb = CIFS_SB(sb);
230         if (cifs_sb == NULL) {
231                 cFYI(1, "Empty cifs superblock info passed to unmount");
232                 return;
233         }
234
235         rc = cifs_umount(sb, cifs_sb);
236         if (rc)
237                 cERROR(1, "cifs_umount failed with return code %d", rc);
238 #ifdef CONFIG_CIFS_DFS_UPCALL
239         if (cifs_sb->mountdata) {
240                 kfree(cifs_sb->mountdata);
241                 cifs_sb->mountdata = NULL;
242         }
243 #endif
244
245         unload_nls(cifs_sb->local_nls);
246         bdi_destroy(&cifs_sb->bdi);
247         kfree(cifs_sb);
248 }
249
250 static int
251 cifs_statfs(struct dentry *dentry, struct kstatfs *buf)
252 {
253         struct super_block *sb = dentry->d_sb;
254         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
255         struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
256         int rc = -EOPNOTSUPP;
257         int xid;
258
259         xid = GetXid();
260
261         buf->f_type = CIFS_MAGIC_NUMBER;
262
263         /*
264          * PATH_MAX may be too long - it would presumably be total path,
265          * but note that some servers (includinng Samba 3) have a shorter
266          * maximum path.
267          *
268          * Instead could get the real value via SMB_QUERY_FS_ATTRIBUTE_INFO.
269          */
270         buf->f_namelen = PATH_MAX;
271         buf->f_files = 0;       /* undefined */
272         buf->f_ffree = 0;       /* unlimited */
273
274         /*
275          * We could add a second check for a QFS Unix capability bit
276          */
277         if ((tcon->ses->capabilities & CAP_UNIX) &&
278             (CIFS_POSIX_EXTENSIONS & le64_to_cpu(tcon->fsUnixInfo.Capability)))
279                 rc = CIFSSMBQFSPosixInfo(xid, tcon, buf);
280
281         /*
282          * Only need to call the old QFSInfo if failed on newer one,
283          * e.g. by OS/2.
284          **/
285         if (rc && (tcon->ses->capabilities & CAP_NT_SMBS))
286                 rc = CIFSSMBQFSInfo(xid, tcon, buf);
287
288         /*
289          * Some old Windows servers also do not support level 103, retry with
290          * older level one if old server failed the previous call or we
291          * bypassed it because we detected that this was an older LANMAN sess
292          */
293         if (rc)
294                 rc = SMBOldQFSInfo(xid, tcon, buf);
295
296         FreeXid(xid);
297         return 0;
298 }
299
300 static int cifs_permission(struct inode *inode, int mask, unsigned int flags)
301 {
302         struct cifs_sb_info *cifs_sb;
303
304         if (flags & IPERM_FLAG_RCU)
305                 return -ECHILD;
306
307         cifs_sb = CIFS_SB(inode->i_sb);
308
309         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) {
310                 if ((mask & MAY_EXEC) && !execute_ok(inode))
311                         return -EACCES;
312                 else
313                         return 0;
314         } else /* file mode might have been restricted at mount time
315                 on the client (above and beyond ACL on servers) for
316                 servers which do not support setting and viewing mode bits,
317                 so allowing client to check permissions is useful */
318                 return generic_permission(inode, mask, flags, NULL);
319 }
320
321 static struct kmem_cache *cifs_inode_cachep;
322 static struct kmem_cache *cifs_req_cachep;
323 static struct kmem_cache *cifs_mid_cachep;
324 static struct kmem_cache *cifs_sm_req_cachep;
325 mempool_t *cifs_sm_req_poolp;
326 mempool_t *cifs_req_poolp;
327 mempool_t *cifs_mid_poolp;
328
329 static struct inode *
330 cifs_alloc_inode(struct super_block *sb)
331 {
332         struct cifsInodeInfo *cifs_inode;
333         cifs_inode = kmem_cache_alloc(cifs_inode_cachep, GFP_KERNEL);
334         if (!cifs_inode)
335                 return NULL;
336         cifs_inode->cifsAttrs = 0x20;   /* default */
337         cifs_inode->time = 0;
338         /* Until the file is open and we have gotten oplock
339         info back from the server, can not assume caching of
340         file data or metadata */
341         cifs_set_oplock_level(cifs_inode, 0);
342         cifs_inode->delete_pending = false;
343         cifs_inode->invalid_mapping = false;
344         cifs_inode->vfs_inode.i_blkbits = 14;  /* 2**14 = CIFS_MAX_MSGSIZE */
345         cifs_inode->server_eof = 0;
346         cifs_inode->uniqueid = 0;
347         cifs_inode->createtime = 0;
348
349         /* Can not set i_flags here - they get immediately overwritten
350            to zero by the VFS */
351 /*      cifs_inode->vfs_inode.i_flags = S_NOATIME | S_NOCMTIME;*/
352         INIT_LIST_HEAD(&cifs_inode->openFileList);
353         return &cifs_inode->vfs_inode;
354 }
355
356 static void cifs_i_callback(struct rcu_head *head)
357 {
358         struct inode *inode = container_of(head, struct inode, i_rcu);
359         INIT_LIST_HEAD(&inode->i_dentry);
360         kmem_cache_free(cifs_inode_cachep, CIFS_I(inode));
361 }
362
363 static void
364 cifs_destroy_inode(struct inode *inode)
365 {
366         call_rcu(&inode->i_rcu, cifs_i_callback);
367 }
368
369 static void
370 cifs_evict_inode(struct inode *inode)
371 {
372         truncate_inode_pages(&inode->i_data, 0);
373         end_writeback(inode);
374         cifs_fscache_release_inode_cookie(inode);
375 }
376
377 static void
378 cifs_show_address(struct seq_file *s, struct TCP_Server_Info *server)
379 {
380         struct sockaddr_in *sa = (struct sockaddr_in *) &server->dstaddr;
381         struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) &server->dstaddr;
382
383         seq_printf(s, ",addr=");
384
385         switch (server->dstaddr.ss_family) {
386         case AF_INET:
387                 seq_printf(s, "%pI4", &sa->sin_addr.s_addr);
388                 break;
389         case AF_INET6:
390                 seq_printf(s, "%pI6", &sa6->sin6_addr.s6_addr);
391                 if (sa6->sin6_scope_id)
392                         seq_printf(s, "%%%u", sa6->sin6_scope_id);
393                 break;
394         default:
395                 seq_printf(s, "(unknown)");
396         }
397 }
398
399 /*
400  * cifs_show_options() is for displaying mount options in /proc/mounts.
401  * Not all settable options are displayed but most of the important
402  * ones are.
403  */
404 static int
405 cifs_show_options(struct seq_file *s, struct vfsmount *m)
406 {
407         struct cifs_sb_info *cifs_sb = CIFS_SB(m->mnt_sb);
408         struct cifsTconInfo *tcon = cifs_sb_master_tcon(cifs_sb);
409         struct sockaddr *srcaddr;
410         srcaddr = (struct sockaddr *)&tcon->ses->server->srcaddr;
411
412         seq_printf(s, ",unc=%s", tcon->treeName);
413
414         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)
415                 seq_printf(s, ",multiuser");
416         else if (tcon->ses->user_name)
417                 seq_printf(s, ",username=%s", tcon->ses->user_name);
418
419         if (tcon->ses->domainName)
420                 seq_printf(s, ",domain=%s", tcon->ses->domainName);
421
422         if (srcaddr->sa_family != AF_UNSPEC) {
423                 struct sockaddr_in *saddr4;
424                 struct sockaddr_in6 *saddr6;
425                 saddr4 = (struct sockaddr_in *)srcaddr;
426                 saddr6 = (struct sockaddr_in6 *)srcaddr;
427                 if (srcaddr->sa_family == AF_INET6)
428                         seq_printf(s, ",srcaddr=%pI6c",
429                                    &saddr6->sin6_addr);
430                 else if (srcaddr->sa_family == AF_INET)
431                         seq_printf(s, ",srcaddr=%pI4",
432                                    &saddr4->sin_addr.s_addr);
433                 else
434                         seq_printf(s, ",srcaddr=BAD-AF:%i",
435                                    (int)(srcaddr->sa_family));
436         }
437
438         seq_printf(s, ",uid=%d", cifs_sb->mnt_uid);
439         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
440                 seq_printf(s, ",forceuid");
441         else
442                 seq_printf(s, ",noforceuid");
443
444         seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
445         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
446                 seq_printf(s, ",forcegid");
447         else
448                 seq_printf(s, ",noforcegid");
449
450         cifs_show_address(s, tcon->ses->server);
451
452         if (!tcon->unix_ext)
453                 seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
454                                            cifs_sb->mnt_file_mode,
455                                            cifs_sb->mnt_dir_mode);
456         if (tcon->seal)
457                 seq_printf(s, ",seal");
458         if (tcon->nocase)
459                 seq_printf(s, ",nocase");
460         if (tcon->retry)
461                 seq_printf(s, ",hard");
462         if (cifs_sb->prepath)
463                 seq_printf(s, ",prepath=%s", cifs_sb->prepath);
464         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
465                 seq_printf(s, ",posixpaths");
466         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
467                 seq_printf(s, ",setuids");
468         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
469                 seq_printf(s, ",serverino");
470         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
471                 seq_printf(s, ",directio");
472         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
473                 seq_printf(s, ",nouser_xattr");
474         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
475                 seq_printf(s, ",mapchars");
476         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
477                 seq_printf(s, ",sfu");
478         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
479                 seq_printf(s, ",nobrl");
480         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
481                 seq_printf(s, ",cifsacl");
482         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
483                 seq_printf(s, ",dynperm");
484         if (m->mnt_sb->s_flags & MS_POSIXACL)
485                 seq_printf(s, ",acl");
486         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS)
487                 seq_printf(s, ",mfsymlinks");
488         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE)
489                 seq_printf(s, ",fsc");
490
491         seq_printf(s, ",rsize=%d", cifs_sb->rsize);
492         seq_printf(s, ",wsize=%d", cifs_sb->wsize);
493         /* convert actimeo and display it in seconds */
494                 seq_printf(s, ",actimeo=%lu", cifs_sb->actimeo / HZ);
495
496         return 0;
497 }
498
499 static void cifs_umount_begin(struct super_block *sb)
500 {
501         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
502         struct cifsTconInfo *tcon;
503
504         if (cifs_sb == NULL)
505                 return;
506
507         tcon = cifs_sb_master_tcon(cifs_sb);
508
509         spin_lock(&cifs_tcp_ses_lock);
510         if ((tcon->tc_count > 1) || (tcon->tidStatus == CifsExiting)) {
511                 /* we have other mounts to same share or we have
512                    already tried to force umount this and woken up
513                    all waiting network requests, nothing to do */
514                 spin_unlock(&cifs_tcp_ses_lock);
515                 return;
516         } else if (tcon->tc_count == 1)
517                 tcon->tidStatus = CifsExiting;
518         spin_unlock(&cifs_tcp_ses_lock);
519
520         /* cancel_brl_requests(tcon); */ /* BB mark all brl mids as exiting */
521         /* cancel_notify_requests(tcon); */
522         if (tcon->ses && tcon->ses->server) {
523                 cFYI(1, "wake up tasks now - umount begin not complete");
524                 wake_up_all(&tcon->ses->server->request_q);
525                 wake_up_all(&tcon->ses->server->response_q);
526                 msleep(1); /* yield */
527                 /* we have to kick the requests once more */
528                 wake_up_all(&tcon->ses->server->response_q);
529                 msleep(1);
530         }
531
532         return;
533 }
534
535 #ifdef CONFIG_CIFS_STATS2
536 static int cifs_show_stats(struct seq_file *s, struct vfsmount *mnt)
537 {
538         /* BB FIXME */
539         return 0;
540 }
541 #endif
542
543 static int cifs_remount(struct super_block *sb, int *flags, char *data)
544 {
545         *flags |= MS_NODIRATIME;
546         return 0;
547 }
548
549 static int cifs_drop_inode(struct inode *inode)
550 {
551         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
552
553         /* no serverino => unconditional eviction */
554         return !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) ||
555                 generic_drop_inode(inode);
556 }
557
558 static const struct super_operations cifs_super_ops = {
559         .put_super = cifs_put_super,
560         .statfs = cifs_statfs,
561         .alloc_inode = cifs_alloc_inode,
562         .destroy_inode = cifs_destroy_inode,
563         .drop_inode     = cifs_drop_inode,
564         .evict_inode    = cifs_evict_inode,
565 /*      .delete_inode   = cifs_delete_inode,  */  /* Do not need above
566         function unless later we add lazy close of inodes or unless the
567         kernel forgets to call us with the same number of releases (closes)
568         as opens */
569         .show_options = cifs_show_options,
570         .umount_begin   = cifs_umount_begin,
571         .remount_fs = cifs_remount,
572 #ifdef CONFIG_CIFS_STATS2
573         .show_stats = cifs_show_stats,
574 #endif
575 };
576
577 static struct dentry *
578 cifs_do_mount(struct file_system_type *fs_type,
579             int flags, const char *dev_name, void *data)
580 {
581         int rc;
582         struct super_block *sb;
583
584         sb = sget(fs_type, NULL, set_anon_super, NULL);
585
586         cFYI(1, "Devname: %s flags: %d ", dev_name, flags);
587
588         if (IS_ERR(sb))
589                 return ERR_CAST(sb);
590
591         sb->s_flags = flags;
592
593         rc = cifs_read_super(sb, data, dev_name, flags & MS_SILENT ? 1 : 0);
594         if (rc) {
595                 deactivate_locked_super(sb);
596                 return ERR_PTR(rc);
597         }
598         sb->s_flags |= MS_ACTIVE;
599         return dget(sb->s_root);
600 }
601
602 static ssize_t cifs_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
603                                    unsigned long nr_segs, loff_t pos)
604 {
605         struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
606         ssize_t written;
607         int rc;
608
609         written = generic_file_aio_write(iocb, iov, nr_segs, pos);
610
611         if (CIFS_I(inode)->clientCanCacheAll)
612                 return written;
613
614         rc = filemap_fdatawrite(inode->i_mapping);
615         if (rc)
616                 cFYI(1, "cifs_file_aio_write: %d rc on %p inode", rc, inode);
617
618         return written;
619 }
620
621 static loff_t cifs_llseek(struct file *file, loff_t offset, int origin)
622 {
623         /* origin == SEEK_END => we must revalidate the cached file length */
624         if (origin == SEEK_END) {
625                 int retval;
626
627                 /* some applications poll for the file length in this strange
628                &nbs