Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6
[linux-3.10.git] / fs / cifs / file.c
1 /*
2  *   fs/cifs/file.c
3  *
4  *   vfs operations that deal with files
5  *
6  *   Copyright (C) International Business Machines  Corp., 2002,2010
7  *   Author(s): Steve French (sfrench@us.ibm.com)
8  *              Jeremy Allison (jra@samba.org)
9  *
10  *   This library is free software; you can redistribute it and/or modify
11  *   it under the terms of the GNU Lesser General Public License as published
12  *   by the Free Software Foundation; either version 2.1 of the License, or
13  *   (at your option) any later version.
14  *
15  *   This library is distributed in the hope that it will be useful,
16  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
18  *   the GNU Lesser General Public License for more details.
19  *
20  *   You should have received a copy of the GNU Lesser General Public License
21  *   along with this library; if not, write to the Free Software
22  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23  */
24 #include <linux/fs.h>
25 #include <linux/backing-dev.h>
26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
28 #include <linux/pagemap.h>
29 #include <linux/pagevec.h>
30 #include <linux/writeback.h>
31 #include <linux/task_io_accounting_ops.h>
32 #include <linux/delay.h>
33 #include <linux/mount.h>
34 #include <linux/slab.h>
35 #include <asm/div64.h>
36 #include "cifsfs.h"
37 #include "cifspdu.h"
38 #include "cifsglob.h"
39 #include "cifsproto.h"
40 #include "cifs_unicode.h"
41 #include "cifs_debug.h"
42 #include "cifs_fs_sb.h"
43 #include "fscache.h"
44
45 static inline int cifs_convert_flags(unsigned int flags)
46 {
47         if ((flags & O_ACCMODE) == O_RDONLY)
48                 return GENERIC_READ;
49         else if ((flags & O_ACCMODE) == O_WRONLY)
50                 return GENERIC_WRITE;
51         else if ((flags & O_ACCMODE) == O_RDWR) {
52                 /* GENERIC_ALL is too much permission to request
53                    can cause unnecessary access denied on create */
54                 /* return GENERIC_ALL; */
55                 return (GENERIC_READ | GENERIC_WRITE);
56         }
57
58         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
59                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
60                 FILE_READ_DATA);
61 }
62
63 static u32 cifs_posix_convert_flags(unsigned int flags)
64 {
65         u32 posix_flags = 0;
66
67         if ((flags & O_ACCMODE) == O_RDONLY)
68                 posix_flags = SMB_O_RDONLY;
69         else if ((flags & O_ACCMODE) == O_WRONLY)
70                 posix_flags = SMB_O_WRONLY;
71         else if ((flags & O_ACCMODE) == O_RDWR)
72                 posix_flags = SMB_O_RDWR;
73
74         if (flags & O_CREAT)
75                 posix_flags |= SMB_O_CREAT;
76         if (flags & O_EXCL)
77                 posix_flags |= SMB_O_EXCL;
78         if (flags & O_TRUNC)
79                 posix_flags |= SMB_O_TRUNC;
80         /* be safe and imply O_SYNC for O_DSYNC */
81         if (flags & O_DSYNC)
82                 posix_flags |= SMB_O_SYNC;
83         if (flags & O_DIRECTORY)
84                 posix_flags |= SMB_O_DIRECTORY;
85         if (flags & O_NOFOLLOW)
86                 posix_flags |= SMB_O_NOFOLLOW;
87         if (flags & O_DIRECT)
88                 posix_flags |= SMB_O_DIRECT;
89
90         return posix_flags;
91 }
92
93 static inline int cifs_get_disposition(unsigned int flags)
94 {
95         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
96                 return FILE_CREATE;
97         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
98                 return FILE_OVERWRITE_IF;
99         else if ((flags & O_CREAT) == O_CREAT)
100                 return FILE_OPEN_IF;
101         else if ((flags & O_TRUNC) == O_TRUNC)
102                 return FILE_OVERWRITE;
103         else
104                 return FILE_OPEN;
105 }
106
107 int cifs_posix_open(char *full_path, struct inode **pinode,
108                         struct super_block *sb, int mode, unsigned int f_flags,
109                         __u32 *poplock, __u16 *pnetfid, int xid)
110 {
111         int rc;
112         FILE_UNIX_BASIC_INFO *presp_data;
113         __u32 posix_flags = 0;
114         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
115         struct cifs_fattr fattr;
116         struct tcon_link *tlink;
117         struct cifs_tcon *tcon;
118
119         cFYI(1, "posix open %s", full_path);
120
121         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
122         if (presp_data == NULL)
123                 return -ENOMEM;
124
125         tlink = cifs_sb_tlink(cifs_sb);
126         if (IS_ERR(tlink)) {
127                 rc = PTR_ERR(tlink);
128                 goto posix_open_ret;
129         }
130
131         tcon = tlink_tcon(tlink);
132         mode &= ~current_umask();
133
134         posix_flags = cifs_posix_convert_flags(f_flags);
135         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
136                              poplock, full_path, cifs_sb->local_nls,
137                              cifs_sb->mnt_cifs_flags &
138                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
139         cifs_put_tlink(tlink);
140
141         if (rc)
142                 goto posix_open_ret;
143
144         if (presp_data->Type == cpu_to_le32(-1))
145                 goto posix_open_ret; /* open ok, caller does qpathinfo */
146
147         if (!pinode)
148                 goto posix_open_ret; /* caller does not need info */
149
150         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
151
152         /* get new inode and set it up */
153         if (*pinode == NULL) {
154                 cifs_fill_uniqueid(sb, &fattr);
155                 *pinode = cifs_iget(sb, &fattr);
156                 if (!*pinode) {
157                         rc = -ENOMEM;
158                         goto posix_open_ret;
159                 }
160         } else {
161                 cifs_fattr_to_inode(*pinode, &fattr);
162         }
163
164 posix_open_ret:
165         kfree(presp_data);
166         return rc;
167 }
168
169 static int
170 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
171              struct cifs_tcon *tcon, unsigned int f_flags, __u32 *poplock,
172              __u16 *pnetfid, int xid)
173 {
174         int rc;
175         int desiredAccess;
176         int disposition;
177         FILE_ALL_INFO *buf;
178
179         desiredAccess = cifs_convert_flags(f_flags);
180
181 /*********************************************************************
182  *  open flag mapping table:
183  *
184  *      POSIX Flag            CIFS Disposition
185  *      ----------            ----------------
186  *      O_CREAT               FILE_OPEN_IF
187  *      O_CREAT | O_EXCL      FILE_CREATE
188  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
189  *      O_TRUNC               FILE_OVERWRITE
190  *      none of the above     FILE_OPEN
191  *
192  *      Note that there is not a direct match between disposition
193  *      FILE_SUPERSEDE (ie create whether or not file exists although
194  *      O_CREAT | O_TRUNC is similar but truncates the existing
195  *      file rather than creating a new file as FILE_SUPERSEDE does
196  *      (which uses the attributes / metadata passed in on open call)
197  *?
198  *?  O_SYNC is a reasonable match to CIFS writethrough flag
199  *?  and the read write flags match reasonably.  O_LARGEFILE
200  *?  is irrelevant because largefile support is always used
201  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
202  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
203  *********************************************************************/
204
205         disposition = cifs_get_disposition(f_flags);
206
207         /* BB pass O_SYNC flag through on file attributes .. BB */
208
209         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
210         if (!buf)
211                 return -ENOMEM;
212
213         if (tcon->ses->capabilities & CAP_NT_SMBS)
214                 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
215                          desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
216                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
217                                  & CIFS_MOUNT_MAP_SPECIAL_CHR);
218         else
219                 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
220                         desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
221                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
222                                 & CIFS_MOUNT_MAP_SPECIAL_CHR);
223
224         if (rc)
225                 goto out;
226
227         if (tcon->unix_ext)
228                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
229                                               xid);
230         else
231                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
232                                          xid, pnetfid);
233
234 out:
235         kfree(buf);
236         return rc;
237 }
238
239 struct cifsFileInfo *
240 cifs_new_fileinfo(__u16 fileHandle, struct file *file,
241                   struct tcon_link *tlink, __u32 oplock)
242 {
243         struct dentry *dentry = file->f_path.dentry;
244         struct inode *inode = dentry->d_inode;
245         struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
246         struct cifsFileInfo *pCifsFile;
247
248         pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
249         if (pCifsFile == NULL)
250                 return pCifsFile;
251
252         pCifsFile->count = 1;
253         pCifsFile->netfid = fileHandle;
254         pCifsFile->pid = current->tgid;
255         pCifsFile->uid = current_fsuid();
256         pCifsFile->dentry = dget(dentry);
257         pCifsFile->f_flags = file->f_flags;
258         pCifsFile->invalidHandle = false;
259         pCifsFile->tlink = cifs_get_tlink(tlink);
260         mutex_init(&pCifsFile->fh_mutex);
261         mutex_init(&pCifsFile->lock_mutex);
262         INIT_LIST_HEAD(&pCifsFile->llist);
263         INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
264
265         spin_lock(&cifs_file_list_lock);
266         list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
267         /* if readable file instance put first in list*/
268         if (file->f_mode & FMODE_READ)
269                 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
270         else
271                 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
272         spin_unlock(&cifs_file_list_lock);
273
274         cifs_set_oplock_level(pCifsInode, oplock);
275
276         file->private_data = pCifsFile;
277         return pCifsFile;
278 }
279
280 /*
281  * Release a reference on the file private data. This may involve closing
282  * the filehandle out on the server. Must be called without holding
283  * cifs_file_list_lock.
284  */
285 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
286 {
287         struct inode *inode = cifs_file->dentry->d_inode;
288         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
289         struct cifsInodeInfo *cifsi = CIFS_I(inode);
290         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
291         struct cifsLockInfo *li, *tmp;
292
293         spin_lock(&cifs_file_list_lock);
294         if (--cifs_file->count > 0) {
295                 spin_unlock(&cifs_file_list_lock);
296                 return;
297         }
298
299         /* remove it from the lists */
300         list_del(&cifs_file->flist);
301         list_del(&cifs_file->tlist);
302
303         if (list_empty(&cifsi->openFileList)) {
304                 cFYI(1, "closing last open instance for inode %p",
305                         cifs_file->dentry->d_inode);
306
307                 /* in strict cache mode we need invalidate mapping on the last
308                    close  because it may cause a error when we open this file
309                    again and get at least level II oplock */
310                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
311                         CIFS_I(inode)->invalid_mapping = true;
312
313                 cifs_set_oplock_level(cifsi, 0);
314         }
315         spin_unlock(&cifs_file_list_lock);
316
317         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
318                 int xid, rc;
319
320                 xid = GetXid();
321                 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
322                 FreeXid(xid);
323         }
324
325         /* Delete any outstanding lock records. We'll lose them when the file
326          * is closed anyway.
327          */
328         mutex_lock(&cifs_file->lock_mutex);
329         list_for_each_entry_safe(li, tmp, &cifs_file->llist, llist) {
330                 list_del(&li->llist);
331                 kfree(li);
332         }
333         mutex_unlock(&cifs_file->lock_mutex);
334
335         cifs_put_tlink(cifs_file->tlink);
336         dput(cifs_file->dentry);
337         kfree(cifs_file);
338 }
339
340 int cifs_open(struct inode *inode, struct file *file)
341 {
342         int rc = -EACCES;
343         int xid;
344         __u32 oplock;
345         struct cifs_sb_info *cifs_sb;
346         struct cifs_tcon *tcon;
347         struct tcon_link *tlink;
348         struct cifsFileInfo *pCifsFile = NULL;
349         char *full_path = NULL;
350         bool posix_open_ok = false;
351         __u16 netfid;
352
353         xid = GetXid();
354
355         cifs_sb = CIFS_SB(inode->i_sb);
356         tlink = cifs_sb_tlink(cifs_sb);
357         if (IS_ERR(tlink)) {
358                 FreeXid(xid);
359                 return PTR_ERR(tlink);
360         }
361         tcon = tlink_tcon(tlink);
362
363         full_path = build_path_from_dentry(file->f_path.dentry);
364         if (full_path == NULL) {
365                 rc = -ENOMEM;
366                 goto out;
367         }
368
369         cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
370                  inode, file->f_flags, full_path);
371
372         if (oplockEnabled)
373                 oplock = REQ_OPLOCK;
374         else
375                 oplock = 0;
376
377         if (!tcon->broken_posix_open && tcon->unix_ext &&
378             (tcon->ses->capabilities & CAP_UNIX) &&
379             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
380                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
381                 /* can not refresh inode info since size could be stale */
382                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
383                                 cifs_sb->mnt_file_mode /* ignored */,
384                                 file->f_flags, &oplock, &netfid, xid);
385                 if (rc == 0) {
386                         cFYI(1, "posix open succeeded");
387                         posix_open_ok = true;
388                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
389                         if (tcon->ses->serverNOS)
390                                 cERROR(1, "server %s of type %s returned"
391                                            " unexpected error on SMB posix open"
392                                            ", disabling posix open support."
393                                            " Check if server update available.",
394                                            tcon->ses->serverName,
395                                            tcon->ses->serverNOS);
396                         tcon->broken_posix_open = true;
397                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
398                          (rc != -EOPNOTSUPP)) /* path not found or net err */
399                         goto out;
400                 /* else fallthrough to retry open the old way on network i/o
401                    or DFS errors */
402         }
403
404         if (!posix_open_ok) {
405                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
406                                   file->f_flags, &oplock, &netfid, xid);
407                 if (rc)
408                         goto out;
409         }
410
411         pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
412         if (pCifsFile == NULL) {
413                 CIFSSMBClose(xid, tcon, netfid);
414                 rc = -ENOMEM;
415                 goto out;
416         }
417
418         cifs_fscache_set_inode_cookie(inode, file);
419
420         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
421                 /* time to set mode which we can not set earlier due to
422                    problems creating new read-only files */
423                 struct cifs_unix_set_info_args args = {
424                         .mode   = inode->i_mode,
425                         .uid    = NO_CHANGE_64,
426                         .gid    = NO_CHANGE_64,
427                         .ctime  = NO_CHANGE_64,
428                         .atime  = NO_CHANGE_64,
429                         .mtime  = NO_CHANGE_64,
430                         .device = 0,
431                 };
432                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
433                                         pCifsFile->pid);
434         }
435
436 out:
437         kfree(full_path);
438         FreeXid(xid);
439         cifs_put_tlink(tlink);
440         return rc;
441 }
442
443 /* Try to reacquire byte range locks that were released when session */
444 /* to server was lost */
445 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
446 {
447         int rc = 0;
448
449 /* BB list all locks open on this file and relock */
450
451         return rc;
452 }
453
454 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
455 {
456         int rc = -EACCES;
457         int xid;
458         __u32 oplock;
459         struct cifs_sb_info *cifs_sb;
460         struct cifs_tcon *tcon;
461         struct cifsInodeInfo *pCifsInode;
462         struct inode *inode;
463         char *full_path = NULL;
464         int desiredAccess;
465         int disposition = FILE_OPEN;
466         __u16 netfid;
467
468         xid = GetXid();
469         mutex_lock(&pCifsFile->fh_mutex);
470         if (!pCifsFile->invalidHandle) {
471                 mutex_unlock(&pCifsFile->fh_mutex);
472                 rc = 0;
473                 FreeXid(xid);
474                 return rc;
475         }
476
477         inode = pCifsFile->dentry->d_inode;
478         cifs_sb = CIFS_SB(inode->i_sb);
479         tcon = tlink_tcon(pCifsFile->tlink);
480
481 /* can not grab rename sem here because various ops, including
482    those that already have the rename sem can end up causing writepage
483    to get called and if the server was down that means we end up here,
484    and we can never tell if the caller already has the rename_sem */
485         full_path = build_path_from_dentry(pCifsFile->dentry);
486         if (full_path == NULL) {
487                 rc = -ENOMEM;
488                 mutex_unlock(&pCifsFile->fh_mutex);
489                 FreeXid(xid);
490                 return rc;
491         }
492
493         cFYI(1, "inode = 0x%p file flags 0x%x for %s",
494                  inode, pCifsFile->f_flags, full_path);
495
496         if (oplockEnabled)
497                 oplock = REQ_OPLOCK;
498         else
499                 oplock = 0;
500
501         if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
502             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
503                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
504
505                 /*
506                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
507                  * original open. Must mask them off for a reopen.
508                  */
509                 unsigned int oflags = pCifsFile->f_flags &
510                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
511
512                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
513                                 cifs_sb->mnt_file_mode /* ignored */,
514                                 oflags, &oplock, &netfid, xid);
515                 if (rc == 0) {
516                         cFYI(1, "posix reopen succeeded");
517                         goto reopen_success;
518                 }
519                 /* fallthrough to retry open the old way on errors, especially
520                    in the reconnect path it is important to retry hard */
521         }
522
523         desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
524
525         /* Can not refresh inode by passing in file_info buf to be returned
526            by SMBOpen and then calling get_inode_info with returned buf
527            since file might have write behind data that needs to be flushed
528            and server version of file size can be stale. If we knew for sure
529            that inode was not dirty locally we could do this */
530
531         rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
532                          CREATE_NOT_DIR, &netfid, &oplock, NULL,
533                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
534                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
535         if (rc) {
536                 mutex_unlock(&pCifsFile->fh_mutex);
537                 cFYI(1, "cifs_open returned 0x%x", rc);
538                 cFYI(1, "oplock: %d", oplock);
539                 goto reopen_error_exit;
540         }
541
542 reopen_success:
543         pCifsFile->netfid = netfid;
544         pCifsFile->invalidHandle = false;
545         mutex_unlock(&pCifsFile->fh_mutex);
546         pCifsInode = CIFS_I(inode);
547
548         if (can_flush) {
549                 rc = filemap_write_and_wait(inode->i_mapping);
550                 mapping_set_error(inode->i_mapping, rc);
551
552                 if (tcon->unix_ext)
553                         rc = cifs_get_inode_info_unix(&inode,
554                                 full_path, inode->i_sb, xid);
555                 else
556                         rc = cifs_get_inode_info(&inode,
557                                 full_path, NULL, inode->i_sb,
558                                 xid, NULL);
559         } /* else we are writing out data to server already
560              and could deadlock if we tried to flush data, and
561              since we do not know if we have data that would
562              invalidate the current end of file on the server
563              we can not go to the server to get the new inod
564              info */
565
566         cifs_set_oplock_level(pCifsInode, oplock);
567
568         cifs_relock_file(pCifsFile);
569
570 reopen_error_exit:
571         kfree(full_path);
572         FreeXid(xid);
573         return rc;
574 }
575
576 int cifs_close(struct inode *inode, struct file *file)
577 {
578         if (file->private_data != NULL) {
579                 cifsFileInfo_put(file->private_data);
580                 file->private_data = NULL;
581         }
582
583         /* return code from the ->release op is always ignored */
584         return 0;
585 }
586
587 int cifs_closedir(struct inode *inode, struct file *file)
588 {
589         int rc = 0;
590         int xid;
591         struct cifsFileInfo *pCFileStruct = file->private_data;
592         char *ptmp;
593
594         cFYI(1, "Closedir inode = 0x%p", inode);
595
596         xid = GetXid();
597
598         if (pCFileStruct) {
599                 struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
600
601                 cFYI(1, "Freeing private data in close dir");
602                 spin_lock(&cifs_file_list_lock);
603                 if (!pCFileStruct->srch_inf.endOfSearch &&
604                     !pCFileStruct->invalidHandle) {
605                         pCFileStruct->invalidHandle = true;
606                         spin_unlock(&cifs_file_list_lock);
607                         rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
608                         cFYI(1, "Closing uncompleted readdir with rc %d",
609                                  rc);
610                         /* not much we can do if it fails anyway, ignore rc */
611                         rc = 0;
612                 } else
613                         spin_unlock(&cifs_file_list_lock);
614                 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
615                 if (ptmp) {
616                         cFYI(1, "closedir free smb buf in srch struct");
617                         pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
618                         if (pCFileStruct->srch_inf.smallBuf)
619                                 cifs_small_buf_release(ptmp);
620                         else
621                                 cifs_buf_release(ptmp);
622                 }
623                 cifs_put_tlink(pCFileStruct->tlink);
624                 kfree(file->private_data);
625                 file->private_data = NULL;
626         }
627         /* BB can we lock the filestruct while this is going on? */
628         FreeXid(xid);
629         return rc;
630 }
631
632 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
633                                 __u64 offset, __u8 lockType)
634 {
635         struct cifsLockInfo *li =
636                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
637         if (li == NULL)
638                 return -ENOMEM;
639         li->offset = offset;
640         li->length = len;
641         li->type = lockType;
642         mutex_lock(&fid->lock_mutex);
643         list_add(&li->llist, &fid->llist);
644         mutex_unlock(&fid->lock_mutex);
645         return 0;
646 }
647
648 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
649 {
650         int rc, xid;
651         __u32 numLock = 0;
652         __u32 numUnlock = 0;
653         __u64 length;
654         bool wait_flag = false;
655         struct cifs_sb_info *cifs_sb;
656         struct cifs_tcon *tcon;
657         __u16 netfid;
658         __u8 lockType = LOCKING_ANDX_LARGE_FILES;
659         bool posix_locking = 0;
660
661         length = 1 + pfLock->fl_end - pfLock->fl_start;
662         rc = -EACCES;
663         xid = GetXid();
664
665         cFYI(1, "Lock parm: 0x%x flockflags: "
666                  "0x%x flocktype: 0x%x start: %lld end: %lld",
667                 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
668                 pfLock->fl_end);
669
670         if (pfLock->fl_flags & FL_POSIX)
671                 cFYI(1, "Posix");
672         if (pfLock->fl_flags & FL_FLOCK)
673                 cFYI(1, "Flock");
674         if (pfLock->fl_flags & FL_SLEEP) {
675                 cFYI(1, "Blocking lock");
676                 wait_flag = true;
677         }
678         if (pfLock->fl_flags & FL_ACCESS)
679                 cFYI(1, "Process suspended by mandatory locking - "
680                          "not implemented yet");
681         if (pfLock->fl_flags & FL_LEASE)
682                 cFYI(1, "Lease on file - not implemented yet");
683         if (pfLock->fl_flags &
684             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
685                 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
686
687         if (pfLock->fl_type == F_WRLCK) {
688                 cFYI(1, "F_WRLCK ");
689                 numLock = 1;
690         } else if (pfLock->fl_type == F_UNLCK) {
691                 cFYI(1, "F_UNLCK");
692                 numUnlock = 1;
693                 /* Check if unlock includes more than
694                 one lock range */
695         } else if (pfLock->fl_type == F_RDLCK) {
696                 cFYI(1, "F_RDLCK");
697                 lockType |= LOCKING_ANDX_SHARED_LOCK;
698                 numLock = 1;
699         } else if (pfLock->fl_type == F_EXLCK) {
700                 cFYI(1, "F_EXLCK");
701                 numLock = 1;
702         } else if (pfLock->fl_type == F_SHLCK) {
703                 cFYI(1, "F_SHLCK");
704                 lockType |= LOCKING_ANDX_SHARED_LOCK;
705                 numLock = 1;
706         } else
707                 cFYI(1, "Unknown type of lock");
708
709         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
710         tcon = tlink_tcon(((struct cifsFileInfo *)file->private_data)->tlink);
711         netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
712
713         if ((tcon->ses->capabilities & CAP_UNIX) &&
714             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
715             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
716                 posix_locking = 1;
717         /* BB add code here to normalize offset and length to
718         account for negative length which we can not accept over the
719         wire */
720         if (IS_GETLK(cmd)) {
721                 if (posix_locking) {
722                         int posix_lock_type;
723                         if (lockType & LOCKING_ANDX_SHARED_LOCK)
724                                 posix_lock_type = CIFS_RDLCK;
725                         else
726                                 posix_lock_type = CIFS_WRLCK;
727                         rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
728                                         length, pfLock, posix_lock_type,
729                                         wait_flag);
730                         FreeXid(xid);
731                         return rc;
732                 }
733
734                 /* BB we could chain these into one lock request BB */
735                 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
736                                  0, 1, lockType, 0 /* wait flag */, 0);
737                 if (rc == 0) {
738                         rc = CIFSSMBLock(xid, tcon, netfid, length,
739                                          pfLock->fl_start, 1 /* numUnlock */ ,
740                                          0 /* numLock */ , lockType,
741                                          0 /* wait flag */, 0);
742                         pfLock->fl_type = F_UNLCK;
743                         if (rc != 0)
744                                 cERROR(1, "Error unlocking previously locked "
745                                            "range %d during test of lock", rc);
746                         rc = 0;
747
748                 } else {
749                         /* if rc == ERR_SHARING_VIOLATION ? */
750                         rc = 0;
751
752                         if (lockType & LOCKING_ANDX_SHARED_LOCK) {
753                                 pfLock->fl_type = F_WRLCK;
754                         } else {
755                                 rc = CIFSSMBLock(xid, tcon, netfid, length,
756                                         pfLock->fl_start, 0, 1,
757                                         lockType | LOCKING_ANDX_SHARED_LOCK,
758                                         0 /* wait flag */, 0);
759                                 if (rc == 0) {
760                                         rc = CIFSSMBLock(xid, tcon, netfid,
761                                                 length, pfLock->fl_start, 1, 0,
762                                                 lockType |
763                                                 LOCKING_ANDX_SHARED_LOCK,
764                                                 0 /* wait flag */, 0);
765                                         pfLock->fl_type = F_RDLCK;
766                                         if (rc != 0)
767                                                 cERROR(1, "Error unlocking "
768                                                 "previously locked range %d "
769                                                 "during test of lock", rc);
770                                         rc = 0;
771                                 } else {
772                                         pfLock->fl_type = F_WRLCK;
773                                         rc = 0;
774                                 }
775                         }
776                 }
777
778                 FreeXid(xid);
779                 return rc;
780         }
781
782         if (!numLock && !numUnlock) {
783                 /* if no lock or unlock then nothing
784                 to do since we do not know what it is */
785                 FreeXid(xid);
786                 return -EOPNOTSUPP;
787         }
788
789         if (posix_locking) {
790                 int posix_lock_type;
791                 if (lockType & LOCKING_ANDX_SHARED_LOCK)
792                         posix_lock_type = CIFS_RDLCK;
793                 else
794                         posix_lock_type = CIFS_WRLCK;
795
796                 if (numUnlock == 1)
797                         posix_lock_type = CIFS_UNLCK;
798
799                 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
800                                       length, pfLock, posix_lock_type,
801                                       wait_flag);
802         } else {
803                 struct cifsFileInfo *fid = file->private_data;
804
805                 if (numLock) {
806                         rc = CIFSSMBLock(xid, tcon, netfid, length,
807                                          pfLock->fl_start, 0, numLock, lockType,
808                                          wait_flag, 0);
809
810                         if (rc == 0) {
811                                 /* For Windows locks we must store them. */
812                                 rc = store_file_lock(fid, length,
813                                                 pfLock->fl_start, lockType);
814                         }
815                 } else if (numUnlock) {
816                         /* For each stored lock that this unlock overlaps
817                            completely, unlock it. */
818                         int stored_rc = 0;
819                         struct cifsLockInfo *li, *tmp;
820
821                         rc = 0;
822                         mutex_lock(&fid->lock_mutex);
823                         list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
824                                 if (pfLock->fl_start <= li->offset &&
825                                                 (pfLock->fl_start + length) >=
826                                                 (li->offset + li->length)) {
827                                         stored_rc = CIFSSMBLock(xid, tcon,
828                                                         netfid, li->length,
829                                                         li->offset, 1, 0,
830                                                         li->type, false, 0);
831                                         if (stored_rc)
832                                                 rc = stored_rc;
833                                         else {
834                                                 list_del(&li->llist);
835                                                 kfree(li);
836                                         }
837                                 }
838                         }
839                         mutex_unlock(&fid->lock_mutex);
840                 }
841         }
842
843         if (pfLock->fl_flags & FL_POSIX)
844                 posix_lock_file_wait(file, pfLock);
845         FreeXid(xid);
846         return rc;
847 }
848
849 /* update the file size (if needed) after a write */
850 void
851 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
852                       unsigned int bytes_written)
853 {
854         loff_t end_of_write = offset + bytes_written;
855
856         if (end_of_write > cifsi->server_eof)
857                 cifsi->server_eof = end_of_write;
858 }
859
860 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
861                           const char *write_data, size_t write_size,
862                           loff_t *poffset)
863 {
864         int rc = 0;
865         unsigned int bytes_written = 0;
866         unsigned int total_written;
867         struct cifs_sb_info *cifs_sb;
868         struct cifs_tcon *pTcon;
869         int xid;
870         struct dentry *dentry = open_file->dentry;
871         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
872         struct cifs_io_parms io_parms;
873
874         cifs_sb = CIFS_SB(dentry->d_sb);
875
876         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
877            *poffset, dentry->d_name.name);
878
879         pTcon = tlink_tcon(open_file->tlink);
880
881         xid = GetXid();
882
883         for (total_written = 0; write_size > total_written;
884              total_written += bytes_written) {
885                 rc = -EAGAIN;
886                 while (rc == -EAGAIN) {
887                         struct kvec iov[2];
888                         unsigned int len;
889
890                         if (open_file->invalidHandle) {
891                                 /* we could deadlock if we called
892                                    filemap_fdatawait from here so tell
893                                    reopen_file not to flush data to
894                                    server now */
895                                 rc = cifs_reopen_file(open_file, false);
896                                 if (rc != 0)
897                                         break;
898                         }
899
900                         len = min((size_t)cifs_sb->wsize,
901                                   write_size - total_written);
902                         /* iov[0] is reserved for smb header */
903                         iov[1].iov_base = (char *)write_data + total_written;
904                         iov[1].iov_len = len;
905                         io_parms.netfid = open_file->netfid;
906                         io_parms.pid = pid;
907                         io_parms.tcon = pTcon;
908                         io_parms.offset = *poffset;
909                         io_parms.length = len;
910                         rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
911                                            1, 0);
912                 }
913                 if (rc || (bytes_written == 0)) {
914                         if (total_written)
915                                 break;
916                         else {
917                                 FreeXid(xid);
918                                 return rc;
919                         }
920                 } else {
921                         cifs_update_eof(cifsi, *poffset, bytes_written);
922                         *poffset += bytes_written;
923                 }
924         }
925
926         cifs_stats_bytes_written(pTcon, total_written);
927
928         if (total_written > 0) {
929                 spin_lock(&dentry->d_inode->i_lock);
930                 if (*poffset > dentry->d_inode->i_size)
931                         i_size_write(dentry->d_inode, *poffset);
932                 spin_unlock(&dentry->d_inode->i_lock);
933         }
934         mark_inode_dirty_sync(dentry->d_inode);
935         FreeXid(xid);
936         return total_written;
937 }
938
939 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
940                                         bool fsuid_only)
941 {
942         struct cifsFileInfo *open_file = NULL;
943         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
944
945         /* only filter by fsuid on multiuser mounts */
946         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
947                 fsuid_only = false;
948
949         spin_lock(&cifs_file_list_lock);
950         /* we could simply get the first_list_entry since write-only entries
951            are always at the end of the list but since the first entry might
952            have a close pending, we go through the whole list */
953         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
954                 if (fsuid_only && open_file->uid != current_fsuid())
955                         continue;
956                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
957                         if (!open_file->invalidHandle) {
958                                 /* found a good file */
959                                 /* lock it so it will not be closed on us */
960                                 cifsFileInfo_get(open_file);
961                                 spin_unlock(&cifs_file_list_lock);
962                                 return open_file;
963                         } /* else might as well continue, and look for
964                              another, or simply have the caller reopen it
965                              again rather than trying to fix this handle */
966                 } else /* write only file */
967                         break; /* write only files are last so must be done */
968         }
969         spin_unlock(&cifs_file_list_lock);
970         return NULL;
971 }
972
973 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
974                                         bool fsuid_only)
975 {
976         struct cifsFileInfo *open_file;
977         struct cifs_sb_info *cifs_sb;
978         bool any_available = false;
979         int rc;
980
981         /* Having a null inode here (because mapping->host was set to zero by
982         the VFS or MM) should not happen but we had reports of on oops (due to
983         it being zero) during stress testcases so we need to check for it */
984
985         if (cifs_inode == NULL) {
986                 cERROR(1, "Null inode passed to cifs_writeable_file");
987                 dump_stack();
988                 return NULL;
989         }
990
991         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
992
993         /* only filter by fsuid on multiuser mounts */
994         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
995                 fsuid_only = false;
996
997         spin_lock(&cifs_file_list_lock);
998 refind_writable:
999         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1000                 if (!any_available && open_file->pid != current->tgid)
1001                         continue;
1002                 if (fsuid_only && open_file->uid != current_fsuid())
1003                         continue;
1004                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1005                         cifsFileInfo_get(open_file);
1006
1007                         if (!open_file->invalidHandle) {
1008                                 /* found a good writable file */
1009                                 spin_unlock(&cifs_file_list_lock);
1010                                 return open_file;
1011                         }
1012
1013                         spin_unlock(&cifs_file_list_lock);
1014
1015                         /* Had to unlock since following call can block */
1016                         rc = cifs_reopen_file(open_file, false);
1017                         if (!rc)
1018                                 return open_file;
1019
1020                         /* if it fails, try another handle if possible */
1021                         cFYI(1, "wp failed on reopen file");
1022                         cifsFileInfo_put(open_file);
1023
1024                         spin_lock(&cifs_file_list_lock);
1025
1026                         /* else we simply continue to the next entry. Thus
1027                            we do not loop on reopen errors.  If we
1028                            can not reopen the file, for example if we
1029                            reconnected to a server with another client
1030                            racing to delete or lock the file we would not
1031                            make progress if we restarted before the beginning
1032                            of the loop here. */
1033                 }
1034         }
1035         /* couldn't find useable FH with same pid, try any available */
1036         if (!any_available) {
1037                 any_available = true;
1038                 goto refind_writable;
1039         }
1040         spin_unlock(&cifs_file_list_lock);
1041         return NULL;
1042 }
1043
1044 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1045 {
1046         struct address_space *mapping = page->mapping;
1047         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1048         char *write_data;
1049         int rc = -EFAULT;
1050         int bytes_written = 0;
1051         struct inode *inode;
1052         struct cifsFileInfo *open_file;
1053
1054         if (!mapping || !mapping->host)
1055                 return -EFAULT;
1056
1057         inode = page->mapping->host;
1058
1059         offset += (loff_t)from;
1060         write_data = kmap(page);
1061         write_data += from;
1062
1063         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1064                 kunmap(page);
1065                 return -EIO;
1066         }
1067
1068         /* racing with truncate? */
1069         if (offset > mapping->host->i_size) {
1070                 kunmap(page);
1071                 return 0; /* don't care */
1072         }
1073
1074         /* check to make sure that we are not extending the file */
1075         if (mapping->host->i_size - offset < (loff_t)to)
1076                 to = (unsigned)(mapping->host->i_size - offset);
1077
1078         open_file = find_writable_file(CIFS_I(mapping->host), false);
1079         if (open_file) {
1080                 bytes_written = cifs_write(open_file, open_file->pid,
1081                                            write_data, to - from, &offset);
1082                 cifsFileInfo_put(open_file);
1083                 /* Does mm or vfs already set times? */
1084                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1085                 if ((bytes_written > 0) && (offset))
1086                         rc = 0;
1087                 else if (bytes_written < 0)
1088                         rc = bytes_written;
1089         } else {
1090                 cFYI(1, "No writeable filehandles for inode");
1091                 rc = -EIO;
1092         }
1093
1094         kunmap(page);
1095         return rc;
1096 }
1097
1098 static int cifs_writepages(struct address_space *mapping,
1099                            struct writeback_control *wbc)
1100 {
1101         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1102         bool done = false, scanned = false, range_whole = false;
1103         pgoff_t end, index;
1104         struct cifs_writedata *wdata;
1105         struct page *page;
1106         int rc = 0;
1107
1108         /*
1109          * If wsize is smaller than the page cache size, default to writing
1110          * one page at a time via cifs_writepage
1111          */
1112         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1113                 return generic_writepages(mapping, wbc);
1114
1115         if (wbc->range_cyclic) {
1116                 index = mapping->writeback_index; /* Start from prev offset */
1117                 end = -1;
1118         } else {
1119                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1120                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1121                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1122                         range_whole = true;
1123                 scanned = true;
1124         }
1125 retry:
1126         while (!done && index <= end) {
1127                 unsigned int i, nr_pages, found_pages;
1128                 pgoff_t next = 0, tofind;
1129                 struct page **pages;
1130
1131                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1132                                 end - index) + 1;
1133
1134                 wdata = cifs_writedata_alloc((unsigned int)tofind);
1135                 if (!wdata) {
1136                         rc = -ENOMEM;
1137                         break;
1138                 }
1139
1140                 /*
1141                  * find_get_pages_tag seems to return a max of 256 on each
1142                  * iteration, so we must call it several times in order to
1143                  * fill the array or the wsize is effectively limited to
1144                  * 256 * PAGE_CACHE_SIZE.
1145                  */
1146                 found_pages = 0;
1147                 pages = wdata->pages;
1148                 do {
1149                         nr_pages = find_get_pages_tag(mapping, &index,
1150                                                         PAGECACHE_TAG_DIRTY,
1151                                                         tofind, pages);
1152                         found_pages += nr_pages;
1153                         tofind -= nr_pages;
1154                         pages += nr_pages;
1155                 } while (nr_pages && tofind && index <= end);
1156
1157                 if (found_pages == 0) {
1158                         kref_put(&wdata->refcount, cifs_writedata_release);
1159                         break;
1160                 }
1161
1162                 nr_pages = 0;
1163                 for (i = 0; i < found_pages; i++) {
1164                         page = wdata->pages[i];
1165                         /*
1166                          * At this point we hold neither mapping->tree_lock nor
1167                          * lock on the page itself: the page may be truncated or
1168                          * invalidated (changing page->mapping to NULL), or even
1169                          * swizzled back from swapper_space to tmpfs file
1170                          * mapping
1171                          */
1172
1173                         if (nr_pages == 0)
1174                                 lock_page(page);
1175                         else if (!trylock_page(page))
1176                                 break;
1177
1178                         if (unlikely(page->mapping != mapping)) {
1179                                 unlock_page(page);
1180                                 break;
1181                         }
1182
1183                         if (!wbc->range_cyclic && page->index > end) {
1184                                 done = true;
1185                                 unlock_page(page);
1186                                 break;
1187                         }
1188
1189                         if (next && (page->index != next)) {
1190                                 /* Not next consecutive page */
1191                                 unlock_page(page);
1192                                 break;
1193                         }
1194
1195                         if (wbc->sync_mode != WB_SYNC_NONE)
1196                                 wait_on_page_writeback(page);
1197
1198                         if (PageWriteback(page) ||
1199                                         !clear_page_dirty_for_io(page)) {
1200                                 unlock_page(page);
1201                                 break;
1202                         }
1203
1204                         /*
1205                          * This actually clears the dirty bit in the radix tree.
1206                          * See cifs_writepage() for more commentary.
1207                          */
1208                         set_page_writeback(page);
1209
1210                         if (page_offset(page) >= mapping->host->i_size) {
1211                                 done = true;
1212                                 unlock_page(page);
1213                                 end_page_writeback(page);
1214                                 break;
1215                         }
1216
1217                         wdata->pages[i] = page;
1218                         next = page->index + 1;
1219                         ++nr_pages;
1220                 }
1221
1222                 /* reset index to refind any pages skipped */
1223                 if (nr_pages == 0)
1224                         index = wdata->pages[0]->index + 1;
1225
1226                 /* put any pages we aren't going to use */
1227                 for (i = nr_pages; i < found_pages; i++) {
1228                         page_cache_release(wdata->pages[i]);
1229                         wdata->pages[i] = NULL;
1230                 }
1231
1232                 /* nothing to write? */
1233                 if (nr_pages == 0) {
1234                         kref_put(&wdata->refcount, cifs_writedata_release);
1235                         continue;
1236                 }
1237
1238                 wdata->sync_mode = wbc->sync_mode;
1239                 wdata->nr_pages = nr_pages;
1240                 wdata->offset = page_offset(wdata->pages[0]);
1241
1242                 do {
1243                         if (wdata->cfile != NULL)
1244                                 cifsFileInfo_put(wdata->cfile);
1245                         wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1246                                                           false);
1247                         if (!wdata->cfile) {
1248                                 cERROR(1, "No writable handles for inode");
1249                                 rc = -EBADF;
1250                                 break;
1251                         }
1252                         rc = cifs_async_writev(wdata);
1253                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1254
1255                 for (i = 0; i < nr_pages; ++i)
1256                         unlock_page(wdata->pages[i]);
1257
1258                 /* send failure -- clean up the mess */
1259                 if (rc != 0) {
1260                         for (i = 0; i < nr_pages; ++i) {
1261                                 if (rc == -EAGAIN)
1262                                         redirty_page_for_writepage(wbc,
1263                                                            wdata->pages[i]);
1264                                 else
1265                                         SetPageError(wdata->pages[i]);
1266                                 end_page_writeback(wdata->pages[i]);
1267                                 page_cache_release(wdata->pages[i]);
1268                         }
1269                         if (rc != -EAGAIN)
1270                                 mapping_set_error(mapping, rc);
1271                 }
1272                 kref_put(&wdata->refcount, cifs_writedata_release);
1273
1274                 wbc->nr_to_write -= nr_pages;
1275                 if (wbc->nr_to_write <= 0)
1276                         done = true;
1277
1278                 index = next;
1279         }
1280
1281         if (!scanned && !done) {
1282                 /*
1283                  * We hit the last page and there is more work to be done: wrap
1284                  * back to the start of the file
1285                  */
1286                 scanned = true;
1287                 index = 0;
1288                 goto retry;
1289         }
1290
1291         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1292                 mapping->writeback_index = index;
1293
1294         return rc;
1295 }
1296
1297 static int
1298 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1299 {
1300         int rc;
1301         int xid;
1302
1303         xid = GetXid();
1304 /* BB add check for wbc flags */
1305         page_cache_get(page);
1306         if (!PageUptodate(page))
1307                 cFYI(1, "ppw - page not up to date");
1308
1309         /*
1310          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1311          *
1312          * A writepage() implementation always needs to do either this,
1313          * or re-dirty the page with "redirty_page_for_writepage()" in
1314          * the case of a failure.
1315          *
1316          * Just unlocking the page will cause the radix tree tag-bits
1317          * to fail to update with the state of the page correctly.
1318          */
1319         set_page_writeback(page);
1320 retry_write:
1321         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1322         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1323                 goto retry_write;
1324         else if (rc == -EAGAIN)
1325                 redirty_page_for_writepage(wbc, page);
1326         else if (rc != 0)
1327                 SetPageError(page);
1328         else
1329                 SetPageUptodate(page);
1330         end_page_writeback(page);
1331         page_cache_release(page);
1332         FreeXid(xid);
1333         return rc;
1334 }
1335
1336 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1337 {
1338         int rc = cifs_writepage_locked(page, wbc);
1339         unlock_page(page);
1340         return rc;
1341 }
1342
1343 static int cifs_write_end(struct file *file, struct address_space *mapping,
1344                         loff_t pos, unsigned len, unsigned copied,
1345                         struct page *page, void *fsdata)
1346 {
1347         int rc;
1348         struct inode *inode = mapping->host;
1349         struct cifsFileInfo *cfile = file->private_data;
1350         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1351         __u32 pid;
1352
1353         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1354                 pid = cfile->pid;
1355         else
1356                 pid = current->tgid;
1357
1358         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1359                  page, pos, copied);
1360
1361         if (PageChecked(page)) {
1362                 if (copied == len)
1363                         SetPageUptodate(page);
1364                 ClearPageChecked(page);
1365         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1366                 SetPageUptodate(page);
1367
1368         if (!PageUptodate(page)) {
1369                 char *page_data;
1370                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1371                 int xid;
1372
1373                 xid = GetXid();
1374                 /* this is probably better than directly calling
1375                    partialpage_write since in this function the file handle is
1376                    known which we might as well leverage */
1377                 /* BB check if anything else missing out of ppw
1378                    such as updating last write time */
1379                 page_data = kmap(page);
1380                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1381                 /* if (rc < 0) should we set writebehind rc? */
1382                 kunmap(page);
1383
1384                 FreeXid(xid);
1385         } else {
1386                 rc = copied;
1387                 pos += copied;
1388                 set_page_dirty(page);
1389         }
1390
1391         if (rc > 0) {
1392                 spin_lock(&inode->i_lock);
1393                 if (pos > inode->i_size)
1394                         i_size_write(inode, pos);
1395                 spin_unlock(&inode->i_lock);
1396         }
1397
1398         unlock_page(page);
1399         page_cache_release(page);
1400
1401         return rc;
1402 }
1403
1404 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1405                       int datasync)
1406 {
1407         int xid;
1408         int rc = 0;
1409         struct cifs_tcon *tcon;
1410         struct cifsFileInfo *smbfile = file->private_data;
1411         struct inode *inode = file->f_path.dentry->d_inode;
1412         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1413
1414         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1415         if (rc)
1416                 return rc;
1417         mutex_lock(&inode->i_mutex);
1418
1419         xid = GetXid();
1420
1421         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1422                 file->f_path.dentry->d_name.name, datasync);
1423
1424         if (!CIFS_I(inode)->clientCanCacheRead) {
1425                 rc = cifs_invalidate_mapping(inode);
1426                 if (rc) {
1427                         cFYI(1, "rc: %d during invalidate phase", rc);
1428                         rc = 0; /* don't care about it in fsync */
1429                 }
1430         }
1431
1432         tcon = tlink_tcon(smbfile->tlink);
1433         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1434                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1435
1436         FreeXid(xid);
1437         mutex_unlock(&inode->i_mutex);
1438         return rc;
1439 }
1440
1441 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1442 {
1443         int xid;
1444         int rc = 0;
1445         struct cifs_tcon *tcon;
1446         struct cifsFileInfo *smbfile = file->private_data;
1447         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1448         struct inode *inode = file->f_mapping->host;
1449
1450         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1451         if (rc)
1452                 return rc;
1453         mutex_lock(&inode->i_mutex);
1454
1455         xid = GetXid();
1456
1457         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1458                 file->f_path.dentry->d_name.name, datasync);
1459
1460         tcon = tlink_tcon(smbfile->tlink);
1461         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1462                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1463
1464         FreeXid(xid);
1465         mutex_unlock(&inode->i_mutex);
1466         return rc;
1467 }
1468
1469 /*
1470  * As file closes, flush all cached write data for this inode checking
1471  * for write behind errors.
1472  */
1473 int cifs_flush(struct file *file, fl_owner_t id)
1474 {
1475         struct inode *inode = file->f_path.dentry->d_inode;
1476         int rc = 0;
1477
1478         if (file->f_mode & FMODE_WRITE)
1479                 rc = filemap_write_and_wait(inode->i_mapping);
1480
1481         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1482
1483         return rc;
1484 }
1485
1486 static int
1487 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
1488 {
1489         int rc = 0;
1490         unsigned long i;
1491
1492         for (i = 0; i < num_pages; i++) {
1493                 pages[i] = alloc_page(__GFP_HIGHMEM);
1494                 if (!pages[i]) {
1495                         /*
1496                          * save number of pages we have already allocated and
1497                          * return with ENOMEM error
1498                          */
1499                         num_pages = i;
1500                         rc = -ENOMEM;
1501                         goto error;
1502                 }
1503         }
1504
1505         return rc;
1506
1507 error:
1508         for (i = 0; i < num_pages; i++)
1509                 put_page(pages[i]);
1510         return rc;
1511 }
1512
1513 static inline
1514 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
1515 {
1516         size_t num_pages;
1517         size_t clen;
1518
1519         clen = min_t(const size_t, len, wsize);
1520         num_pages = clen / PAGE_CACHE_SIZE;
1521         if (clen % PAGE_CACHE_SIZE)
1522                 num_pages++;
1523
1524         if (cur_len)
1525                 *cur_len = clen;
1526
1527         return num_pages;
1528 }
1529
1530 static ssize_t
1531 cifs_iovec_write(struct file *file, const struct iovec *iov,
1532                  unsigned long nr_segs, loff_t *poffset)
1533 {
1534         unsigned int written;
1535         unsigned long num_pages, npages, i;
1536         size_t copied, len, cur_len;
1537         ssize_t total_written = 0;
1538         struct kvec *to_send;
1539         struct page **pages;
1540         struct iov_iter it;
1541         struct inode *inode;
1542         struct cifsFileInfo *open_file;
1543         struct cifs_tcon *pTcon;
1544         struct cifs_sb_info *cifs_sb;
1545         struct cifs_io_parms io_parms;
1546         int xid, rc;
1547         __u32 pid;
1548
1549         len = iov_length(iov, nr_segs);
1550         if (!len)
1551                 return 0;
1552
1553         rc = generic_write_checks(file, poffset, &len, 0);
1554         if (rc)
1555                 return rc;
1556
1557         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1558         num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
1559
1560         pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
1561         if (!pages)
1562                 return -ENOMEM;
1563
1564         to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
1565         if (!to_send) {
1566                 kfree(pages);
1567                 return -ENOMEM;
1568         }
1569
1570         rc = cifs_write_allocate_pages(pages, num_pages);
1571         if (rc) {
1572                 kfree(pages);
1573                 kfree(to_send);
1574                 return rc;
1575         }
1576
1577         xid = GetXid();
1578         open_file = file->private_data;
1579
1580         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1581                 pid = open_file->pid;
1582         else
1583                 pid = current->tgid;
1584
1585         pTcon = tlink_tcon(open_file->tlink);
1586         inode = file->f_path.dentry->d_inode;
1587
1588         iov_iter_init(&it, iov, nr_segs, len, 0);
1589         npages = num_pages;
1590
1591         do {
1592                 size_t save_len = cur_len;
1593                 for (i = 0; i < npages; i++) {
1594                         copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
1595                         copied = iov_iter_copy_from_user(pages[i], &it, 0,
1596                                                          copied);
1597                         cur_len -= copied;
1598                         iov_iter_advance(&it, copied);
1599                         to_send[i+1].iov_base = kmap(pages[i]);
1600                         to_send[i+1].iov_len = copied;
1601                 }
1602
1603                 cur_len = save_len - cur_len;
1604
1605                 do {
1606                         if (open_file->invalidHandle) {
1607                                 rc = cifs_reopen_file(open_file, false);
1608                                 if (rc != 0)
1609                                         break;
1610                         }
1611                         io_parms.netfid = open_file->netfid;
1612                         io_parms.pid = pid;
1613                         io_parms.tcon = pTcon;
1614                         io_parms.offset = *poffset;
1615                         io_parms.length = cur_len;
1616                         rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
1617                                            npages, 0);
1618                 } while (rc == -EAGAIN);
1619
1620                 for (i = 0; i < npages; i++)
1621                         kunmap(pages[i]);
1622
1623                 if (written) {
1624                         len -= written;
1625                         total_written += written;
1626                         cifs_update_eof(CIFS_I(inode), *poffset, written);
1627                         *poffset += written;
1628                 } else if (rc < 0) {
1629                         if (!total_written)
1630                                 total_written = rc;
1631                         break;
1632                 }
1633
1634                 /* get length and number of kvecs of the next write */
1635                 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
1636         } while (len > 0);
1637
1638         if (total_written > 0) {
1639                 spin_lock(&inode->i_lock);
1640                 if (*poffset > inode->i_size)
1641                         i_size_write(inode, *poffset);
1642                 spin_unlock(&inode->i_lock);
1643         }
1644
1645         cifs_stats_bytes_written(pTcon, total_written);
1646         mark_inode_dirty_sync(inode);
1647
1648         for (i = 0; i < num_pages; i++)
1649                 put_page(pages[i]);
1650         kfree(to_send);
1651         kfree(pages);
1652         FreeXid(xid);
1653         return total_written;
1654 }
1655
1656 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
1657                                 unsigned long nr_segs, loff_t pos)
1658 {
1659         ssize_t written;
1660         struct inode *inode;
1661
1662         inode = iocb->ki_filp->f_path.dentry->d_inode;
1663
1664         /*
1665          * BB - optimize the way when signing is disabled. We can drop this
1666          * extra memory-to-memory copying and use iovec buffers for constructing
1667          * write request.
1668          */
1669
1670         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
1671         if (written > 0) {
1672                 CIFS_I(inode)->invalid_mapping = true;
1673                 iocb->ki_pos = pos;
1674         }
1675
1676         return written;
1677 }
1678
1679 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
1680                            unsigned long nr_segs, loff_t pos)
1681 {
1682         struct inode *inode;
1683
1684         inode = iocb->ki_filp->f_path.dentry->d_inode;
1685
1686         if (CIFS_I(inode)->clientCanCacheAll)
1687                 return generic_file_aio_write(iocb, iov, nr_segs, pos);
1688
1689         /*
1690          * In strict cache mode we need to write the data to the server exactly
1691          * from the pos to pos+len-1 rather than flush all affected pages
1692          * because it may cause a error with mandatory locks on these pages but
1693          * not on the region from pos to ppos+len-1.
1694          */
1695
1696         return cifs_user_writev(iocb, iov, nr_segs, pos);
1697 }
1698
1699 static ssize_t
1700 cifs_iovec_read(struct file *file, const struct iovec *iov,
1701                  unsigned long nr_segs, loff_t *poffset)
1702 {
1703         int rc;
1704         int xid;
1705         ssize_t total_read;
1706         unsigned int bytes_read = 0;
1707         size_t len, cur_len;
1708         int iov_offset = 0;
1709         struct cifs_sb_info *cifs_sb;
1710         struct cifs_tcon *pTcon;
1711         struct cifsFileInfo *open_file;
1712         struct smb_com_read_rsp *pSMBr;
1713         struct cifs_io_parms io_parms;
1714         char *read_data;
1715         __u32 pid;
1716
1717         if (!nr_segs)
1718                 return 0;
1719
1720         len = iov_length(iov, nr_segs);
1721         if (!len)
1722                 return 0;
1723
1724         xid = GetXid();
1725         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1726
1727         open_file = file->private_data;
1728         pTcon = tlink_tcon(open_file->tlink);
1729
1730         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1731                 pid = open_file->pid;
1732         else
1733                 pid = current->tgid;
1734
1735         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1736                 cFYI(1, "attempting read on write only file instance");
1737
1738         for (total_read = 0; total_read < len; total_read += bytes_read) {
1739                 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
1740                 rc = -EAGAIN;
1741                 read_data = NULL;
1742
1743                 while (rc == -EAGAIN) {
1744                         int buf_type = CIFS_NO_BUFFER;
1745                         if (open_file->invalidHandle) {
1746                                 rc = cifs_reopen_file(open_file, true);
1747                                 if (rc != 0)
1748                                         break;
1749                         }
1750                         io_parms.netfid = open_file->netfid;
1751                         io_parms.pid = pid;
1752                         io_parms.tcon = pTcon;
1753                         io_parms.offset = *poffset;
1754                         io_parms.length = cur_len;
1755                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
1756                                          &read_data, &buf_type);
1757                         pSMBr = (struct smb_com_read_rsp *)read_data;
1758                         if (read_data) {
1759                                 char *data_offset = read_data + 4 +
1760                                                 le16_to_cpu(pSMBr->DataOffset);
1761                                 if (memcpy_toiovecend(iov, data_offset,
1762                                                       iov_offset, bytes_read))
1763                                         rc = -EFAULT;
1764                                 if (buf_type == CIFS_SMALL_BUFFER)
1765                                         cifs_small_buf_release(read_data);
1766                                 else if (buf_type == CIFS_LARGE_BUFFER)
1767                                         cifs_buf_release(read_data);
1768                                 read_data = NULL;
1769                                 iov_offset += bytes_read;
1770                         }
1771                 }
1772
1773                 if (rc || (bytes_read == 0)) {
1774                         if (total_read) {
1775                                 break;
1776                         } else {
1777                                 FreeXid(xid);
1778                                 return rc;
1779                         }
1780                 } else {
1781                         cifs_stats_bytes_read(pTcon, bytes_read);
1782                         *poffset += bytes_read;
1783                 }
1784         }
1785
1786         FreeXid(xid);
1787         return total_read;
1788 }
1789
1790 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
1791                                unsigned long nr_segs, loff_t pos)
1792 {
1793         ssize_t read;
1794
1795         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
1796         if (read > 0)
1797                 iocb->ki_pos = pos;
1798
1799         return read;
1800 }
1801
1802 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
1803                           unsigned long nr_segs, loff_t pos)
1804 {
1805         struct inode *inode;
1806
1807         inode = iocb->ki_filp->f_path.dentry->d_inode;
1808
1809         if (CIFS_I(inode)->clientCanCacheRead)
1810                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
1811
1812         /*
1813          * In strict cache mode we need to read from the server all the time
1814          * if we don't have level II oplock because the server can delay mtime
1815          * change - so we can't make a decision about inode invalidating.
1816          * And we can also fail with pagereading if there are mandatory locks
1817          * on pages affected by this read but not on the region from pos to
1818          * pos+len-1.
1819          */
1820
1821         return cifs_user_readv(iocb, iov, nr_segs, pos);
1822 }
1823
1824 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1825                          loff_t *poffset)
1826 {
1827         int rc = -EACCES;
1828         unsigned int bytes_read = 0;
1829         unsigned int total_read;
1830         unsigned int current_read_size;
1831         struct cifs_sb_info *cifs_sb;
1832         struct cifs_tcon *pTcon;
1833         int xid;
1834         char *current_offset;
1835         struct cifsFileInfo *open_file;
1836         struct cifs_io_parms io_parms;
1837         int buf_type = CIFS_NO_BUFFER;
1838         __u32 pid;
1839
1840         xid = GetXid();
1841         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1842
1843         if (file->private_data == NULL) {
1844                 rc = -EBADF;
1845                 FreeXid(xid);
1846                 return rc;
1847         }
1848         open_file = file->private_data;
1849         pTcon = tlink_tcon(open_file->tlink);
1850
1851         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1852                 pid = open_file->pid;
1853         else
1854                 pid = current->tgid;
1855
1856         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1857                 cFYI(1, "attempting read on write only file instance");
1858
1859         for (total_read = 0, current_offset = read_data;
1860              read_size > total_read;
1861              total_read += bytes_read, current_offset += bytes_read) {
1862                 current_read_size = min_t(const int, read_size - total_read,
1863                                           cifs_sb->rsize);
1864                 /* For windows me and 9x we do not want to request more
1865                 than it negotiated since it will refuse the read then */
1866                 if ((pTcon->ses) &&
1867                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1868                         current_read_size = min_t(const int, current_read_size,
1869                                         pTcon->ses->server->maxBuf - 128);
1870                 }
1871                 rc = -EAGAIN;
1872                 while (rc == -EAGAIN) {
1873                         if (open_file->invalidHandle) {
1874                                 rc = cifs_reopen_file(open_file, true);
1875                                 if (rc != 0)
1876                                         break;
1877                         }
1878                         io_parms.netfid = open_file->netfid;
1879                         io_parms.pid = pid;
1880                         io_parms.tcon = pTcon;
1881                         io_parms.offset = *poffset;
1882                         io_parms.length = current_read_size;
1883                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
1884                                          &current_offset, &buf_type);
1885                 }
1886                 if (rc || (bytes_read == 0)) {
1887                         if (total_read) {
1888                                 break;
1889                         } else {
1890                                 FreeXid(xid);
1891                                 return rc;
1892                         }
1893                 } else {
1894                         cifs_stats_bytes_read(pTcon, total_read);
1895                         *poffset += bytes_read;
1896                 }
1897         }
1898         FreeXid(xid);
1899         return total_read;
1900 }
1901
1902 /*
1903  * If the page is mmap'ed into a process' page tables, then we need to make
1904  * sure that it doesn't change while being written back.
1905  */
1906 static int
1907 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
1908 {
1909         struct page *page = vmf->page;
1910
1911         lock_page(page);
1912         return VM_FAULT_LOCKED;
1913 }
1914
1915 static struct vm_operations_struct cifs_file_vm_ops = {
1916         .fault = filemap_fault,
1917         .page_mkwrite = cifs_page_mkwrite,
1918 };
1919
1920 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
1921 {
1922         int rc, xid;
1923         struct inode *inode = file->f_path.dentry->d_inode;
1924
1925         xid = GetXid();
1926
1927         if (!CIFS_I(inode)->clientCanCacheRead) {
1928                 rc = cifs_invalidate_mapping(inode);
1929                 if (rc)
1930                         return rc;
1931         }
1932
1933         rc = generic_file_mmap(file, vma);
1934         if (rc == 0)
1935                 vma->vm_ops = &cifs_file_vm_ops;
1936         FreeXid(xid);
1937         return rc;
1938 }
1939
1940 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1941 {
1942         int rc, xid;
1943
1944         xid = GetXid();
1945         rc = cifs_revalidate_file(file);
1946         if (rc) {
1947                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1948                 FreeXid(xid);
1949                 return rc;
1950         }
1951         rc = generic_file_mmap(file, vma);
1952         if (rc == 0)
1953                 vma->vm_ops = &cifs_file_vm_ops;
1954         FreeXid(xid);
1955         return rc;
1956 }
1957
1958
1959 static void cifs_copy_cache_pages(struct address_space *mapping,
1960         struct list_head *pages, int bytes_read, char *data)
1961 {
1962         struct page *page;
1963         char *target;
1964
1965         while (bytes_read > 0) {
1966                 if (list_empty(pages))
1967                         break;
1968
1969                 page = list_entry(pages->prev, struct page, lru);
1970                 list_del(&page->lru);
1971
1972                 if (add_to_page_cache_lru(page, mapping, page->index,
1973                                       GFP_KERNEL)) {
1974                         page_cache_release(page);
1975                         cFYI(1, "Add page cache failed");
1976                         data += PAGE_CACHE_SIZE;
1977                         bytes_read -= PAGE_CACHE_SIZE;
1978                         continue;
1979                 }
1980                 page_cache_release(page);
1981
1982                 target = kmap_atomic(page, KM_USER0);
1983
1984                 if (PAGE_CACHE_SIZE > bytes_read) {
1985                         memcpy(target, data, bytes_read);
1986                         /* zero the tail end of this partial page */
1987                         memset(target + bytes_read, 0,
1988                                PAGE_CACHE_SIZE - bytes_read);
1989                         bytes_read = 0;
1990                 } else {
1991                         memcpy(target, data, PAGE_CACHE_SIZE);
1992                         bytes_read -= PAGE_CACHE_SIZE;
1993                 }
1994                 kunmap_atomic(target, KM_USER0);
1995
1996                 flush_dcache_page(page);
1997                 SetPageUptodate(page);
1998                 unlock_page(page);
1999                 data += PAGE_CACHE_SIZE;
2000
2001                 /* add page to FS-Cache */
2002                 cifs_readpage_to_fscache(mapping->host, page);
2003         }
2004         return;
2005 }
2006
2007 static int cifs_readpages(struct file *file, struct address_space *mapping,
2008         struct list_head *page_list, unsigned num_pages)
2009 {
2010         int rc = -EACCES;
2011         int xid;
2012         loff_t offset;
2013         struct page *page;
2014         struct cifs_sb_info *cifs_sb;
2015         struct cifs_tcon *pTcon;
2016         unsigned int bytes_read = 0;
2017         unsigned int read_size, i;
2018         char *smb_read_data = NULL;
2019         struct smb_com_read_rsp *pSMBr;
2020         struct cifsFileInfo *open_file;
2021         struct cifs_io_parms io_parms;
2022         int buf_type = CIFS_NO_BUFFER;
2023         __u32 pid;
2024
2025         xid = GetXid();
2026         if (file->private_data == NULL) {
2027                 rc = -EBADF;
2028                 FreeXid(xid);
2029                 return rc;
2030         }
2031         open_file = file->private_data;
2032         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2033         pTcon = tlink_tcon(open_file->tlink);
2034
2035         /*
2036          * Reads as many pages as possible from fscache. Returns -ENOBUFS
2037          * immediately if the cookie is negative
2038          */
2039         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2040                                          &num_pages);
2041         if (rc == 0)
2042                 goto read_complete;
2043
2044         cFYI(DBG2, "rpages: num pages %d", num_pages);
2045         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2046                 pid = open_file->pid;
2047         else
2048                 pid = current->tgid;
2049
2050         for (i = 0; i < num_pages; ) {
2051                 unsigned contig_pages;
2052                 struct page *tmp_page;
2053                 unsigned long expected_index;
2054
2055                 if (list_empty(page_list))
2056                         break;
2057
2058                 page = list_entry(page_list->prev, struct page, lru);
2059                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2060
2061                 /* count adjacent pages that we will read into */
2062                 contig_pages = 0;
2063                 expected_index =
2064                         list_entry(page_list->prev, struct page, lru)->index;
2065                 list_for_each_entry_reverse(tmp_page, page_list, lru) {
2066                         if (tmp_page->index == expected_index) {
2067                                 contig_pages++;
2068                                 expected_index++;
2069                         } else
2070                                 break;
2071                 }
2072                 if (contig_pages + i >  num_pages)
2073                         contig_pages = num_pages - i;
2074
2075                 /* for reads over a certain size could initiate async
2076                    read ahead */
2077
2078                 read_size = contig_pages * PAGE_CACHE_SIZE;
2079                 /* Read size needs to be in multiples of one page */
2080                 read_size = min_t(const unsigned int, read_size,
2081                                   cifs_sb->rsize & PAGE_CACHE_MASK);
2082                 cFYI(DBG2, "rpages: read size 0x%x  contiguous pages %d",
2083                                 read_size, contig_pages);
2084                 rc = -EAGAIN;
2085                 while (rc == -EAGAIN) {
2086                         if (open_file->invalidHandle) {
2087                                 rc = cifs_reopen_file(open_file, true);
2088                                 if (rc != 0)
2089                                         break;
2090                         }
2091                         io_parms.netfid = open_file->netfid;
2092                         io_parms.pid = pid;
2093                         io_parms.tcon = pTcon;
2094                         io_parms.offset = offset;
2095                         io_parms.length = read_size;
2096                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2097                                          &smb_read_data, &buf_type);
2098                         /* BB more RC checks ? */
2099                         if (rc == -EAGAIN) {
2100                                 if (smb_read_data) {
2101                                         if (buf_type == CIFS_SMALL_BUFFER)
2102                                                 cifs_small_buf_release(smb_read_data);
2103                                         else if (buf_type == CIFS_LARGE_BUFFER)
2104                                                 cifs_buf_release(smb_read_data);
2105                                         smb_read_data = NULL;
2106                                 }
2107                         }
2108                 }
2109                 if ((rc < 0) || (smb_read_data == NULL)) {
2110                         cFYI(1, "Read error in readpages: %d", rc);
2111                         break;
2112                 } else if (bytes_read > 0) {
2113                         task_io_account_read(bytes_read);
2114                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2115                         cifs_copy_cache_pages(mapping, page_list, bytes_read,
2116                                 smb_read_data + 4 /* RFC1001 hdr */ +
2117                                 le16_to_cpu(pSMBr->DataOffset));
2118
2119                         i +=  bytes_read >> PAGE_CACHE_SHIFT;
2120                         cifs_stats_bytes_read(pTcon, bytes_read);
2121                         if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2122                                 i++; /* account for partial page */
2123
2124                                 /* server copy of file can have smaller size
2125                                    than client */
2126                                 /* BB do we need to verify this common case ?
2127                                    this case is ok - if we are at server EOF
2128                                    we will hit it on next read */
2129
2130                                 /* break; */
2131                         }
2132                 } else {
2133                         cFYI(1, "No bytes read (%d) at offset %lld . "
2134                                 "Cleaning remaining pages from readahead list",
2135                                 bytes_read, offset);
2136                         /* BB turn off caching and do new lookup on
2137                            file size at server? */
2138                         break;
2139                 }
2140                 if (smb_read_data) {
2141                         if (buf_type == CIFS_SMALL_BUFFER)
2142                                 cifs_small_buf_release(smb_read_data);
2143                         else if (buf_type == CIFS_LARGE_BUFFER)
2144                                 cifs_buf_release(smb_read_data);
2145                         smb_read_data = NULL;
2146                 }
2147                 bytes_read = 0;
2148         }
2149
2150 /* need to free smb_read_data buf before exit */
2151         if (smb_read_data) {
2152                 if (buf_type == CIFS_SMALL_BUFFER)
2153                         cifs_small_buf_release(smb_read_data);
2154                 else if (buf_type == CIFS_LARGE_BUFFER)
2155                         cifs_buf_release(smb_read_data);
2156                 smb_read_data = NULL;
2157         }
2158
2159 read_complete:
2160         FreeXid(xid);
2161         return rc;
2162 }
2163
2164 static int cifs_readpage_worker(struct file *file, struct page *page,
2165         loff_t *poffset)
2166 {
2167         char *read_data;
2168         int rc;
2169
2170         /* Is the page cached? */
2171         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2172         if (rc == 0)
2173                 goto read_complete;
2174
2175         page_cache_get(page);
2176         read_data = kmap(page);
2177         /* for reads over a certain size could initiate async read ahead */
2178
2179         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2180
2181         if (rc < 0)
2182                 goto io_error;
2183         else
2184                 cFYI(1, "Bytes read %d", rc);
2185
2186         file->f_path.dentry->d_inode->i_atime =
2187                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2188
2189         if (PAGE_CACHE_SIZE > rc)
2190                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2191
2192         flush_dcache_page(page);
2193         SetPageUptodate(page);
2194
2195         /* send this page to the cache */
2196         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2197
2198         rc = 0;
2199
2200 io_error:
2201         kunmap(page);
2202         page_cache_release(page);
2203
2204 read_complete:
2205         return rc;
2206 }
2207
2208 static int cifs_readpage(struct file *file, struct page *page)
2209 {
2210         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2211         int rc = -EACCES;
2212         int xid;
2213
2214         xid = GetXid();
2215
2216         if (file->private_data == NULL) {
2217                 rc = -EBADF;
2218                 FreeXid(xid);
2219                 return rc;
2220         }
2221
2222         cFYI(1, "readpage %p at offset %d 0x%x\n",
2223                  page, (int)offset, (int)offset);
2224
2225         rc = cifs_readpage_worker(file, page, &offset);
2226
2227         unlock_page(page);
2228
2229         FreeXid(xid);
2230         return rc;
2231 }
2232
2233 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2234 {
2235         struct cifsFileInfo *open_file;
2236
2237         spin_lock(&cifs_file_list_lock);
2238         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2239                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2240                         spin_unlock(&cifs_file_list_lock);
2241                         return 1;
2242                 }
2243         }
2244         spin_unlock(&cifs_file_list_lock);
2245         return 0;
2246 }
2247
2248 /* We do not want to update the file size from server for inodes
2249    open for write - to avoid races with writepage extending
2250    the file - in the future we could consider allowing
2251    refreshing the inode only on increases in the file size
2252    but this is tricky to do without racing with writebehind
2253    page caching in the current Linux kernel design */
2254 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2255 {
2256         if (!cifsInode)
2257                 return true;
2258
2259         if (is_inode_writable(cifsInode)) {
2260                 /* This inode is open for write at least once */
2261                 struct cifs_sb_info *cifs_sb;
2262
2263                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2264                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2265                         /* since no page cache to corrupt on directio
2266                         we can change size safely */
2267                         return true;
2268                 }
2269
2270                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2271                         return true;
2272
2273                 return false;
2274         } else
2275                 return true;
2276 }
2277
2278 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2279                         loff_t pos, unsigned len, unsigned flags,
2280                         struct page **pagep, void **fsdata)
2281 {
2282         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2283         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2284         loff_t page_start = pos & PAGE_MASK;
2285         loff_t i_size;
2286         struct page *page;
2287         int rc = 0;
2288
2289         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2290
2291         page = grab_cache_page_write_begin(mapping, index, flags);
2292         if (!page) {
2293                 rc = -ENOMEM;
2294                 goto out;
2295         }
2296
2297         if (PageUptodate(page))
2298                 goto out;
2299
2300         /*
2301          * If we write a full page it will be up to date, no need to read from
2302          * the server. If the write is short, we'll end up doing a sync write
2303          * instead.
2304          */
2305         if (len == PAGE_CACHE_SIZE)
2306                 goto out;
2307
2308         /*
2309          * optimize away the read when we have an oplock, and we're not
2310          * expecting to use any of the data we'd be reading in. That
2311          * is, when the page lies beyond the EOF, or straddles the EOF
2312          * and the write will cover all of the existing data.
2313          */
2314         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2315                 i_size = i_size_read(mapping->host);
2316                 if (page_start >= i_size ||
2317                     (offset == 0 && (pos + len) >= i_size)) {
2318                         zero_user_segments(page, 0, offset,
2319                                            offset + len,
2320                                            PAGE_CACHE_SIZE);
2321                         /*
2322                          * PageChecked means that the parts of the page
2323                          * to which we're not writing are considered up
2324                          * to date. Once the data is copied to the
2325                          * page, it can be set uptodate.
2326                          */
2327                         SetPageChecked(page);
2328                         goto out;
2329                 }
2330         }
2331
2332         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2333                 /*
2334                  * might as well read a page, it is fast enough. If we get
2335                  * an error, we don't need to return it. cifs_write_end will
2336                  * do a sync write instead since PG_uptodate isn't set.
2337                  */
2338                 cifs_readpage_worker(file, page, &page_start);
2339         } else {
2340                 /* we could try using another file handle if there is one -
2341                    but how would we lock it to prevent close of that handle
2342                    racing with this read? In any case
2343                    this will be written out by write_end so is fine */
2344         }
2345 out:
2346         *pagep = page;
2347         return rc;
2348 }
2349
2350 static int cifs_release_page(struct page *page, gfp_t gfp)
2351 {
2352         if (PagePrivate(page))
2353                 return 0;
2354
2355         return cifs_fscache_release_page(page, gfp);
2356 }
2357
2358 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2359 {
2360         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2361
2362         if (offset == 0)
2363                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2364 }
2365
2366 static int cifs_launder_page(struct page *page)
2367 {
2368         int rc = 0;
2369         loff_t range_start = page_offset(page);
2370         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2371         struct writeback_control wbc = {
2372                 .sync_mode = WB_SYNC_ALL,
2373                 .nr_to_write = 0,
2374                 .range_start = range_start,
2375                 .range_end = range_end,
2376         };
2377
2378         cFYI(1, "Launder page: %p", page);
2379
2380         if (clear_page_dirty_for_io(page))
2381                 rc = cifs_writepage_locked(page, &wbc);
2382
2383         cifs_fscache_invalidate_page(page, page->mapping->host);
2384         return rc;
2385 }
2386
2387 void cifs_oplock_break(struct work_struct *work)
2388 {
2389         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2390                                                   oplock_break);
2391         struct inode *inode = cfile->dentry->d_inode;
2392         struct cifsInodeInfo *cinode = CIFS_I(inode);
2393         int rc = 0;
2394
2395         if (inode && S_ISREG(inode->i_mode)) {
2396                 if (cinode->clientCanCacheRead)
2397                         break_lease(inode, O_RDONLY);
2398                 else
2399                         break_lease(inode, O_WRONLY);
2400                 rc = filemap_fdatawrite(inode->i_mapping);
2401                 if (cinode->clientCanCacheRead == 0) {
2402                         rc = filemap_fdatawait(inode->i_mapping);
2403                         mapping_set_error(inode->i_mapping, rc);
2404                         invalidate_remote_inode(inode);
2405                 }
2406                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2407         }
2408
2409         /*
2410          * releasing stale oplock after recent reconnect of smb session using
2411          * a now incorrect file handle is not a data integrity issue but do
2412          * not bother sending an oplock release if session to server still is
2413          * disconnected since oplock already released by the server
2414          */
2415         if (!cfile->oplock_break_cancelled) {
2416                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
2417                                  0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false,
2418                                  cinode->clientCanCacheRead ? 1 : 0);
2419                 cFYI(1, "Oplock release rc = %d", rc);
2420         }
2421
2422         /*
2423          * We might have kicked in before is_valid_oplock_break()
2424          * finished grabbing reference for us.  Make sure it's done by
2425          * waiting for cifs_file_list_lock.
2426          */
2427         spin_lock(&cifs_file_list_lock);
2428         spin_unlock(&cifs_file_list_lock);
2429
2430         cifs_oplock_break_put(cfile);
2431 }
2432
2433 /* must be called while holding cifs_file_list_lock */
2434 void cifs_oplock_break_get(struct cifsFileInfo *cfile)
2435 {
2436         cifs_sb_active(cfile->dentry->d_sb);
2437         cifsFileInfo_get(cfile);
2438 }
2439
2440 void cifs_oplock_break_put(struct cifsFileInfo *cfile)
2441 {
2442         struct super_block *sb = cfile->dentry->d_sb;
2443
2444         cifsFileInfo_put(cfile);
2445         cifs_sb_deactive(sb);
2446 }
2447
2448 const struct address_space_operations cifs_addr_ops = {
2449         .readpage = cifs_readpage,
2450         .readpages = cifs_readpages,
2451         .writepage = cifs_writepage,
2452         .writepages = cifs_writepages,
2453         .write_begin = cifs_write_begin,
2454         .write_end = cifs_write_end,
2455         .set_page_dirty = __set_page_dirty_nobuffers,
2456         .releasepage = cifs_release_page,
2457         .invalidatepage = cifs_invalidate_page,
2458         .launder_page = cifs_launder_page,
2459 };
2460
2461 /*
2462  * cifs_readpages requires the server to support a buffer large enough to
2463  * contain the header plus one complete page of data.  Otherwise, we need
2464  * to leave cifs_readpages out of the address space operations.
2465  */
2466 const struct address_space_operations cifs_addr_ops_smallbuf = {
2467         .readpage = cifs_readpage,
2468         .writepage = cifs_writepage,
2469         .writepages = cifs_writepages,
2470         .write_begin = cifs_write_begin,
2471         .write_end = cifs_write_end,
2472         .set_page_dirty = __set_page_dirty_nobuffers,
2473         .releasepage = cifs_release_page,
2474         .invalidatepage = cifs_invalidate_page,
2475         .launder_page = cifs_launder_page,
2476 };