cifs: convert async read code to use pages array without kmapping
[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 <linux/swap.h>
36 #include <asm/div64.h>
37 #include "cifsfs.h"
38 #include "cifspdu.h"
39 #include "cifsglob.h"
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
44 #include "fscache.h"
45
46 static inline int cifs_convert_flags(unsigned int flags)
47 {
48         if ((flags & O_ACCMODE) == O_RDONLY)
49                 return GENERIC_READ;
50         else if ((flags & O_ACCMODE) == O_WRONLY)
51                 return GENERIC_WRITE;
52         else if ((flags & O_ACCMODE) == O_RDWR) {
53                 /* GENERIC_ALL is too much permission to request
54                    can cause unnecessary access denied on create */
55                 /* return GENERIC_ALL; */
56                 return (GENERIC_READ | GENERIC_WRITE);
57         }
58
59         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
60                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
61                 FILE_READ_DATA);
62 }
63
64 static u32 cifs_posix_convert_flags(unsigned int flags)
65 {
66         u32 posix_flags = 0;
67
68         if ((flags & O_ACCMODE) == O_RDONLY)
69                 posix_flags = SMB_O_RDONLY;
70         else if ((flags & O_ACCMODE) == O_WRONLY)
71                 posix_flags = SMB_O_WRONLY;
72         else if ((flags & O_ACCMODE) == O_RDWR)
73                 posix_flags = SMB_O_RDWR;
74
75         if (flags & O_CREAT)
76                 posix_flags |= SMB_O_CREAT;
77         if (flags & O_EXCL)
78                 posix_flags |= SMB_O_EXCL;
79         if (flags & O_TRUNC)
80                 posix_flags |= SMB_O_TRUNC;
81         /* be safe and imply O_SYNC for O_DSYNC */
82         if (flags & O_DSYNC)
83                 posix_flags |= SMB_O_SYNC;
84         if (flags & O_DIRECTORY)
85                 posix_flags |= SMB_O_DIRECTORY;
86         if (flags & O_NOFOLLOW)
87                 posix_flags |= SMB_O_NOFOLLOW;
88         if (flags & O_DIRECT)
89                 posix_flags |= SMB_O_DIRECT;
90
91         return posix_flags;
92 }
93
94 static inline int cifs_get_disposition(unsigned int flags)
95 {
96         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
97                 return FILE_CREATE;
98         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
99                 return FILE_OVERWRITE_IF;
100         else if ((flags & O_CREAT) == O_CREAT)
101                 return FILE_OPEN_IF;
102         else if ((flags & O_TRUNC) == O_TRUNC)
103                 return FILE_OVERWRITE;
104         else
105                 return FILE_OPEN;
106 }
107
108 int cifs_posix_open(char *full_path, struct inode **pinode,
109                         struct super_block *sb, int mode, unsigned int f_flags,
110                         __u32 *poplock, __u16 *pnetfid, unsigned int xid)
111 {
112         int rc;
113         FILE_UNIX_BASIC_INFO *presp_data;
114         __u32 posix_flags = 0;
115         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
116         struct cifs_fattr fattr;
117         struct tcon_link *tlink;
118         struct cifs_tcon *tcon;
119
120         cFYI(1, "posix open %s", full_path);
121
122         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
123         if (presp_data == NULL)
124                 return -ENOMEM;
125
126         tlink = cifs_sb_tlink(cifs_sb);
127         if (IS_ERR(tlink)) {
128                 rc = PTR_ERR(tlink);
129                 goto posix_open_ret;
130         }
131
132         tcon = tlink_tcon(tlink);
133         mode &= ~current_umask();
134
135         posix_flags = cifs_posix_convert_flags(f_flags);
136         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
137                              poplock, full_path, cifs_sb->local_nls,
138                              cifs_sb->mnt_cifs_flags &
139                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
140         cifs_put_tlink(tlink);
141
142         if (rc)
143                 goto posix_open_ret;
144
145         if (presp_data->Type == cpu_to_le32(-1))
146                 goto posix_open_ret; /* open ok, caller does qpathinfo */
147
148         if (!pinode)
149                 goto posix_open_ret; /* caller does not need info */
150
151         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
152
153         /* get new inode and set it up */
154         if (*pinode == NULL) {
155                 cifs_fill_uniqueid(sb, &fattr);
156                 *pinode = cifs_iget(sb, &fattr);
157                 if (!*pinode) {
158                         rc = -ENOMEM;
159                         goto posix_open_ret;
160                 }
161         } else {
162                 cifs_fattr_to_inode(*pinode, &fattr);
163         }
164
165 posix_open_ret:
166         kfree(presp_data);
167         return rc;
168 }
169
170 static int
171 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
172              struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
173              struct cifs_fid *fid, unsigned int xid)
174 {
175         int rc;
176         int desired_access;
177         int disposition;
178         int create_options = CREATE_NOT_DIR;
179         FILE_ALL_INFO *buf;
180
181         if (!tcon->ses->server->ops->open)
182                 return -ENOSYS;
183
184         desired_access = cifs_convert_flags(f_flags);
185
186 /*********************************************************************
187  *  open flag mapping table:
188  *
189  *      POSIX Flag            CIFS Disposition
190  *      ----------            ----------------
191  *      O_CREAT               FILE_OPEN_IF
192  *      O_CREAT | O_EXCL      FILE_CREATE
193  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
194  *      O_TRUNC               FILE_OVERWRITE
195  *      none of the above     FILE_OPEN
196  *
197  *      Note that there is not a direct match between disposition
198  *      FILE_SUPERSEDE (ie create whether or not file exists although
199  *      O_CREAT | O_TRUNC is similar but truncates the existing
200  *      file rather than creating a new file as FILE_SUPERSEDE does
201  *      (which uses the attributes / metadata passed in on open call)
202  *?
203  *?  O_SYNC is a reasonable match to CIFS writethrough flag
204  *?  and the read write flags match reasonably.  O_LARGEFILE
205  *?  is irrelevant because largefile support is always used
206  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
207  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
208  *********************************************************************/
209
210         disposition = cifs_get_disposition(f_flags);
211
212         /* BB pass O_SYNC flag through on file attributes .. BB */
213
214         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
215         if (!buf)
216                 return -ENOMEM;
217
218         if (backup_cred(cifs_sb))
219                 create_options |= CREATE_OPEN_BACKUP_INTENT;
220
221         rc = tcon->ses->server->ops->open(xid, tcon, full_path, disposition,
222                                           desired_access, create_options, fid,
223                                           oplock, buf, cifs_sb);
224
225         if (rc)
226                 goto out;
227
228         if (tcon->unix_ext)
229                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
230                                               xid);
231         else
232                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
233                                          xid, &fid->netfid);
234
235 out:
236         kfree(buf);
237         return rc;
238 }
239
240 struct cifsFileInfo *
241 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
242                   struct tcon_link *tlink, __u32 oplock)
243 {
244         struct dentry *dentry = file->f_path.dentry;
245         struct inode *inode = dentry->d_inode;
246         struct cifsInodeInfo *cinode = CIFS_I(inode);
247         struct cifsFileInfo *cfile;
248
249         cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
250         if (cfile == NULL)
251                 return cfile;
252
253         cfile->count = 1;
254         cfile->pid = current->tgid;
255         cfile->uid = current_fsuid();
256         cfile->dentry = dget(dentry);
257         cfile->f_flags = file->f_flags;
258         cfile->invalidHandle = false;
259         cfile->tlink = cifs_get_tlink(tlink);
260         mutex_init(&cfile->fh_mutex);
261         INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
262         INIT_LIST_HEAD(&cfile->llist);
263         tlink_tcon(tlink)->ses->server->ops->set_fid(cfile, fid, oplock);
264
265         spin_lock(&cifs_file_list_lock);
266         list_add(&cfile->tlist, &(tlink_tcon(tlink)->openFileList));
267         /* if readable file instance put first in list*/
268         if (file->f_mode & FMODE_READ)
269                 list_add(&cfile->flist, &cinode->openFileList);
270         else
271                 list_add_tail(&cfile->flist, &cinode->openFileList);
272         spin_unlock(&cifs_file_list_lock);
273
274         file->private_data = cfile;
275         return cfile;
276 }
277
278 static void cifs_del_lock_waiters(struct cifsLockInfo *lock);
279
280 struct cifsFileInfo *
281 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
282 {
283         spin_lock(&cifs_file_list_lock);
284         cifsFileInfo_get_locked(cifs_file);
285         spin_unlock(&cifs_file_list_lock);
286         return cifs_file;
287 }
288
289 /*
290  * Release a reference on the file private data. This may involve closing
291  * the filehandle out on the server. Must be called without holding
292  * cifs_file_list_lock.
293  */
294 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
295 {
296         struct inode *inode = cifs_file->dentry->d_inode;
297         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
298         struct cifsInodeInfo *cifsi = CIFS_I(inode);
299         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
300         struct cifsLockInfo *li, *tmp;
301
302         spin_lock(&cifs_file_list_lock);
303         if (--cifs_file->count > 0) {
304                 spin_unlock(&cifs_file_list_lock);
305                 return;
306         }
307
308         /* remove it from the lists */
309         list_del(&cifs_file->flist);
310         list_del(&cifs_file->tlist);
311
312         if (list_empty(&cifsi->openFileList)) {
313                 cFYI(1, "closing last open instance for inode %p",
314                         cifs_file->dentry->d_inode);
315                 /*
316                  * In strict cache mode we need invalidate mapping on the last
317                  * close  because it may cause a error when we open this file
318                  * again and get at least level II oplock.
319                  */
320                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
321                         CIFS_I(inode)->invalid_mapping = true;
322                 cifs_set_oplock_level(cifsi, 0);
323         }
324         spin_unlock(&cifs_file_list_lock);
325
326         cancel_work_sync(&cifs_file->oplock_break);
327
328         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
329                 struct TCP_Server_Info *server = tcon->ses->server;
330                 unsigned int xid;
331                 int rc = -ENOSYS;
332
333                 xid = get_xid();
334                 if (server->ops->close)
335                         rc = server->ops->close(xid, tcon, &cifs_file->fid);
336                 free_xid(xid);
337         }
338
339         /* Delete any outstanding lock records. We'll lose them when the file
340          * is closed anyway.
341          */
342         mutex_lock(&cifsi->lock_mutex);
343         list_for_each_entry_safe(li, tmp, &cifs_file->llist, llist) {
344                 list_del(&li->llist);
345                 cifs_del_lock_waiters(li);
346                 kfree(li);
347         }
348         mutex_unlock(&cifsi->lock_mutex);
349
350         cifs_put_tlink(cifs_file->tlink);
351         dput(cifs_file->dentry);
352         kfree(cifs_file);
353 }
354
355 int cifs_open(struct inode *inode, struct file *file)
356 {
357         int rc = -EACCES;
358         unsigned int xid;
359         __u32 oplock;
360         struct cifs_sb_info *cifs_sb;
361         struct cifs_tcon *tcon;
362         struct tcon_link *tlink;
363         struct cifsFileInfo *cfile = NULL;
364         char *full_path = NULL;
365         bool posix_open_ok = false;
366         struct cifs_fid fid;
367
368         xid = get_xid();
369
370         cifs_sb = CIFS_SB(inode->i_sb);
371         tlink = cifs_sb_tlink(cifs_sb);
372         if (IS_ERR(tlink)) {
373                 free_xid(xid);
374                 return PTR_ERR(tlink);
375         }
376         tcon = tlink_tcon(tlink);
377
378         full_path = build_path_from_dentry(file->f_path.dentry);
379         if (full_path == NULL) {
380                 rc = -ENOMEM;
381                 goto out;
382         }
383
384         cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
385                  inode, file->f_flags, full_path);
386
387         if (tcon->ses->server->oplocks)
388                 oplock = REQ_OPLOCK;
389         else
390                 oplock = 0;
391
392         if (!tcon->broken_posix_open && tcon->unix_ext &&
393             cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
394                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
395                 /* can not refresh inode info since size could be stale */
396                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
397                                 cifs_sb->mnt_file_mode /* ignored */,
398                                 file->f_flags, &oplock, &fid.netfid, xid);
399                 if (rc == 0) {
400                         cFYI(1, "posix open succeeded");
401                         posix_open_ok = true;
402                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
403                         if (tcon->ses->serverNOS)
404                                 cERROR(1, "server %s of type %s returned"
405                                            " unexpected error on SMB posix open"
406                                            ", disabling posix open support."
407                                            " Check if server update available.",
408                                            tcon->ses->serverName,
409                                            tcon->ses->serverNOS);
410                         tcon->broken_posix_open = true;
411                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
412                          (rc != -EOPNOTSUPP)) /* path not found or net err */
413                         goto out;
414                 /*
415                  * Else fallthrough to retry open the old way on network i/o
416                  * or DFS errors.
417                  */
418         }
419
420         if (!posix_open_ok) {
421                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
422                                   file->f_flags, &oplock, &fid, xid);
423                 if (rc)
424                         goto out;
425         }
426
427         cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
428         if (cfile == NULL) {
429                 if (tcon->ses->server->ops->close)
430                         tcon->ses->server->ops->close(xid, tcon, &fid);
431                 rc = -ENOMEM;
432                 goto out;
433         }
434
435         cifs_fscache_set_inode_cookie(inode, file);
436
437         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
438                 /*
439                  * Time to set mode which we can not set earlier due to
440                  * problems creating new read-only files.
441                  */
442                 struct cifs_unix_set_info_args args = {
443                         .mode   = inode->i_mode,
444                         .uid    = NO_CHANGE_64,
445                         .gid    = NO_CHANGE_64,
446                         .ctime  = NO_CHANGE_64,
447                         .atime  = NO_CHANGE_64,
448                         .mtime  = NO_CHANGE_64,
449                         .device = 0,
450                 };
451                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
452                                        cfile->pid);
453         }
454
455 out:
456         kfree(full_path);
457         free_xid(xid);
458         cifs_put_tlink(tlink);
459         return rc;
460 }
461
462 /*
463  * Try to reacquire byte range locks that were released when session
464  * to server was lost
465  */
466 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
467 {
468         int rc = 0;
469
470         /* BB list all locks open on this file and relock */
471
472         return rc;
473 }
474
475 static int
476 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
477 {
478         int rc = -EACCES;
479         unsigned int xid;
480         __u32 oplock;
481         struct cifs_sb_info *cifs_sb;
482         struct cifs_tcon *tcon;
483         struct TCP_Server_Info *server;
484         struct cifsInodeInfo *cinode;
485         struct inode *inode;
486         char *full_path = NULL;
487         int desired_access;
488         int disposition = FILE_OPEN;
489         int create_options = CREATE_NOT_DIR;
490         struct cifs_fid fid;
491
492         xid = get_xid();
493         mutex_lock(&cfile->fh_mutex);
494         if (!cfile->invalidHandle) {
495                 mutex_unlock(&cfile->fh_mutex);
496                 rc = 0;
497                 free_xid(xid);
498                 return rc;
499         }
500
501         inode = cfile->dentry->d_inode;
502         cifs_sb = CIFS_SB(inode->i_sb);
503         tcon = tlink_tcon(cfile->tlink);
504         server = tcon->ses->server;
505
506         /*
507          * Can not grab rename sem here because various ops, including those
508          * that already have the rename sem can end up causing writepage to get
509          * called and if the server was down that means we end up here, and we
510          * can never tell if the caller already has the rename_sem.
511          */
512         full_path = build_path_from_dentry(cfile->dentry);
513         if (full_path == NULL) {
514                 rc = -ENOMEM;
515                 mutex_unlock(&cfile->fh_mutex);
516                 free_xid(xid);
517                 return rc;
518         }
519
520         cFYI(1, "inode = 0x%p file flags 0x%x for %s", inode, cfile->f_flags,
521              full_path);
522
523         if (tcon->ses->server->oplocks)
524                 oplock = REQ_OPLOCK;
525         else
526                 oplock = 0;
527
528         if (tcon->unix_ext && cap_unix(tcon->ses) &&
529             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
530                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
531                 /*
532                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
533                  * original open. Must mask them off for a reopen.
534                  */
535                 unsigned int oflags = cfile->f_flags &
536                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
537
538                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
539                                      cifs_sb->mnt_file_mode /* ignored */,
540                                      oflags, &oplock, &fid.netfid, xid);
541                 if (rc == 0) {
542                         cFYI(1, "posix reopen succeeded");
543                         goto reopen_success;
544                 }
545                 /*
546                  * fallthrough to retry open the old way on errors, especially
547                  * in the reconnect path it is important to retry hard
548                  */
549         }
550
551         desired_access = cifs_convert_flags(cfile->f_flags);
552
553         if (backup_cred(cifs_sb))
554                 create_options |= CREATE_OPEN_BACKUP_INTENT;
555
556         /*
557          * Can not refresh inode by passing in file_info buf to be returned by
558          * CIFSSMBOpen and then calling get_inode_info with returned buf since
559          * file might have write behind data that needs to be flushed and server
560          * version of file size can be stale. If we knew for sure that inode was
561          * not dirty locally we could do this.
562          */
563         rc = server->ops->open(xid, tcon, full_path, disposition,
564                                desired_access, create_options, &fid, &oplock,
565                                NULL, cifs_sb);
566         if (rc) {
567                 mutex_unlock(&cfile->fh_mutex);
568                 cFYI(1, "cifs_reopen returned 0x%x", rc);
569                 cFYI(1, "oplock: %d", oplock);
570                 goto reopen_error_exit;
571         }
572
573 reopen_success:
574         cfile->invalidHandle = false;
575         mutex_unlock(&cfile->fh_mutex);
576         cinode = CIFS_I(inode);
577
578         if (can_flush) {
579                 rc = filemap_write_and_wait(inode->i_mapping);
580                 mapping_set_error(inode->i_mapping, rc);
581
582                 if (tcon->unix_ext)
583                         rc = cifs_get_inode_info_unix(&inode, full_path,
584                                                       inode->i_sb, xid);
585                 else
586                         rc = cifs_get_inode_info(&inode, full_path, NULL,
587                                                  inode->i_sb, xid, NULL);
588         }
589         /*
590          * Else we are writing out data to server already and could deadlock if
591          * we tried to flush data, and since we do not know if we have data that
592          * would invalidate the current end of file on the server we can not go
593          * to the server to get the new inode info.
594          */
595
596         server->ops->set_fid(cfile, &fid, oplock);
597         cifs_relock_file(cfile);
598
599 reopen_error_exit:
600         kfree(full_path);
601         free_xid(xid);
602         return rc;
603 }
604
605 int cifs_close(struct inode *inode, struct file *file)
606 {
607         if (file->private_data != NULL) {
608                 cifsFileInfo_put(file->private_data);
609                 file->private_data = NULL;
610         }
611
612         /* return code from the ->release op is always ignored */
613         return 0;
614 }
615
616 int cifs_closedir(struct inode *inode, struct file *file)
617 {
618         int rc = 0;
619         unsigned int xid;
620         struct cifsFileInfo *cfile = file->private_data;
621         struct cifs_tcon *tcon;
622         struct TCP_Server_Info *server;
623         char *buf;
624
625         cFYI(1, "Closedir inode = 0x%p", inode);
626
627         if (cfile == NULL)
628                 return rc;
629
630         xid = get_xid();
631         tcon = tlink_tcon(cfile->tlink);
632         server = tcon->ses->server;
633
634         cFYI(1, "Freeing private data in close dir");
635         spin_lock(&cifs_file_list_lock);
636         if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
637                 cfile->invalidHandle = true;
638                 spin_unlock(&cifs_file_list_lock);
639                 if (server->ops->close_dir)
640                         rc = server->ops->close_dir(xid, tcon, &cfile->fid);
641                 else
642                         rc = -ENOSYS;
643                 cFYI(1, "Closing uncompleted readdir with rc %d", rc);
644                 /* not much we can do if it fails anyway, ignore rc */
645                 rc = 0;
646         } else
647                 spin_unlock(&cifs_file_list_lock);
648
649         buf = cfile->srch_inf.ntwrk_buf_start;
650         if (buf) {
651                 cFYI(1, "closedir free smb buf in srch struct");
652                 cfile->srch_inf.ntwrk_buf_start = NULL;
653                 if (cfile->srch_inf.smallBuf)
654                         cifs_small_buf_release(buf);
655                 else
656                         cifs_buf_release(buf);
657         }
658
659         cifs_put_tlink(cfile->tlink);
660         kfree(file->private_data);
661         file->private_data = NULL;
662         /* BB can we lock the filestruct while this is going on? */
663         free_xid(xid);
664         return rc;
665 }
666
667 static struct cifsLockInfo *
668 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
669 {
670         struct cifsLockInfo *lock =
671                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
672         if (!lock)
673                 return lock;
674         lock->offset = offset;
675         lock->length = length;
676         lock->type = type;
677         lock->pid = current->tgid;
678         INIT_LIST_HEAD(&lock->blist);
679         init_waitqueue_head(&lock->block_q);
680         return lock;
681 }
682
683 static void
684 cifs_del_lock_waiters(struct cifsLockInfo *lock)
685 {
686         struct cifsLockInfo *li, *tmp;
687         list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
688                 list_del_init(&li->blist);
689                 wake_up(&li->block_q);
690         }
691 }
692
693 static bool
694 cifs_find_fid_lock_conflict(struct cifsFileInfo *cfile, __u64 offset,
695                             __u64 length, __u8 type, struct cifsFileInfo *cur,
696                             struct cifsLockInfo **conf_lock)
697 {
698         struct cifsLockInfo *li;
699         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
700
701         list_for_each_entry(li, &cfile->llist, llist) {
702                 if (offset + length <= li->offset ||
703                     offset >= li->offset + li->length)
704                         continue;
705                 else if ((type & server->vals->shared_lock_type) &&
706                          ((server->ops->compare_fids(cur, cfile) &&
707                            current->tgid == li->pid) || type == li->type))
708                         continue;
709                 else {
710                         *conf_lock = li;
711                         return true;
712                 }
713         }
714         return false;
715 }
716
717 static bool
718 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
719                         __u8 type, struct cifsLockInfo **conf_lock)
720 {
721         bool rc = false;
722         struct cifsFileInfo *fid, *tmp;
723         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
724
725         spin_lock(&cifs_file_list_lock);
726         list_for_each_entry_safe(fid, tmp, &cinode->openFileList, flist) {
727                 rc = cifs_find_fid_lock_conflict(fid, offset, length, type,
728                                                  cfile, conf_lock);
729                 if (rc)
730                         break;
731         }
732         spin_unlock(&cifs_file_list_lock);
733
734         return rc;
735 }
736
737 /*
738  * Check if there is another lock that prevents us to set the lock (mandatory
739  * style). If such a lock exists, update the flock structure with its
740  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
741  * or leave it the same if we can't. Returns 0 if we don't need to request to
742  * the server or 1 otherwise.
743  */
744 static int
745 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
746                __u8 type, struct file_lock *flock)
747 {
748         int rc = 0;
749         struct cifsLockInfo *conf_lock;
750         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
751         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
752         bool exist;
753
754         mutex_lock(&cinode->lock_mutex);
755
756         exist = cifs_find_lock_conflict(cfile, offset, length, type,
757                                         &conf_lock);
758         if (exist) {
759                 flock->fl_start = conf_lock->offset;
760                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
761                 flock->fl_pid = conf_lock->pid;
762                 if (conf_lock->type & server->vals->shared_lock_type)
763                         flock->fl_type = F_RDLCK;
764                 else
765                         flock->fl_type = F_WRLCK;
766         } else if (!cinode->can_cache_brlcks)
767                 rc = 1;
768         else
769                 flock->fl_type = F_UNLCK;
770
771         mutex_unlock(&cinode->lock_mutex);
772         return rc;
773 }
774
775 static void
776 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
777 {
778         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
779         mutex_lock(&cinode->lock_mutex);
780         list_add_tail(&lock->llist, &cfile->llist);
781         mutex_unlock(&cinode->lock_mutex);
782 }
783
784 /*
785  * Set the byte-range lock (mandatory style). Returns:
786  * 1) 0, if we set the lock and don't need to request to the server;
787  * 2) 1, if no locks prevent us but we need to request to the server;
788  * 3) -EACCESS, if there is a lock that prevents us and wait is false.
789  */
790 static int
791 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
792                  bool wait)
793 {
794         struct cifsLockInfo *conf_lock;
795         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
796         bool exist;
797         int rc = 0;
798
799 try_again:
800         exist = false;
801         mutex_lock(&cinode->lock_mutex);
802
803         exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
804                                         lock->type, &conf_lock);
805         if (!exist && cinode->can_cache_brlcks) {
806                 list_add_tail(&lock->llist, &cfile->llist);
807                 mutex_unlock(&cinode->lock_mutex);
808                 return rc;
809         }
810
811         if (!exist)
812                 rc = 1;
813         else if (!wait)
814                 rc = -EACCES;
815         else {
816                 list_add_tail(&lock->blist, &conf_lock->blist);
817                 mutex_unlock(&cinode->lock_mutex);
818                 rc = wait_event_interruptible(lock->block_q,
819                                         (lock->blist.prev == &lock->blist) &&
820                                         (lock->blist.next == &lock->blist));
821                 if (!rc)
822                         goto try_again;
823                 mutex_lock(&cinode->lock_mutex);
824                 list_del_init(&lock->blist);
825         }
826
827         mutex_unlock(&cinode->lock_mutex);
828         return rc;
829 }
830
831 /*
832  * Check if there is another lock that prevents us to set the lock (posix
833  * style). If such a lock exists, update the flock structure with its
834  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
835  * or leave it the same if we can't. Returns 0 if we don't need to request to
836  * the server or 1 otherwise.
837  */
838 static int
839 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
840 {
841         int rc = 0;
842         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
843         unsigned char saved_type = flock->fl_type;
844
845         if ((flock->fl_flags & FL_POSIX) == 0)
846                 return 1;
847
848         mutex_lock(&cinode->lock_mutex);
849         posix_test_lock(file, flock);
850
851         if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
852                 flock->fl_type = saved_type;
853                 rc = 1;
854         }
855
856         mutex_unlock(&cinode->lock_mutex);
857         return rc;
858 }
859
860 /*
861  * Set the byte-range lock (posix style). Returns:
862  * 1) 0, if we set the lock and don't need to request to the server;
863  * 2) 1, if we need to request to the server;
864  * 3) <0, if the error occurs while setting the lock.
865  */
866 static int
867 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
868 {
869         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
870         int rc = 1;
871
872         if ((flock->fl_flags & FL_POSIX) == 0)
873                 return rc;
874
875 try_again:
876         mutex_lock(&cinode->lock_mutex);
877         if (!cinode->can_cache_brlcks) {
878                 mutex_unlock(&cinode->lock_mutex);
879                 return rc;
880         }
881
882         rc = posix_lock_file(file, flock, NULL);
883         mutex_unlock(&cinode->lock_mutex);
884         if (rc == FILE_LOCK_DEFERRED) {
885                 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
886                 if (!rc)
887                         goto try_again;
888                 locks_delete_block(flock);
889         }
890         return rc;
891 }
892
893 static int
894 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
895 {
896         unsigned int xid;
897         int rc = 0, stored_rc;
898         struct cifsLockInfo *li, *tmp;
899         struct cifs_tcon *tcon;
900         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
901         unsigned int num, max_num, max_buf;
902         LOCKING_ANDX_RANGE *buf, *cur;
903         int types[] = {LOCKING_ANDX_LARGE_FILES,
904                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
905         int i;
906
907         xid = get_xid();
908         tcon = tlink_tcon(cfile->tlink);
909
910         mutex_lock(&cinode->lock_mutex);
911         if (!cinode->can_cache_brlcks) {
912                 mutex_unlock(&cinode->lock_mutex);
913                 free_xid(xid);
914                 return rc;
915         }
916
917         /*
918          * Accessing maxBuf is racy with cifs_reconnect - need to store value
919          * and check it for zero before using.
920          */
921         max_buf = tcon->ses->server->maxBuf;
922         if (!max_buf) {
923                 mutex_unlock(&cinode->lock_mutex);
924                 free_xid(xid);
925                 return -EINVAL;
926         }
927
928         max_num = (max_buf - sizeof(struct smb_hdr)) /
929                                                 sizeof(LOCKING_ANDX_RANGE);
930         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
931         if (!buf) {
932                 mutex_unlock(&cinode->lock_mutex);
933                 free_xid(xid);
934                 return -ENOMEM;
935         }
936
937         for (i = 0; i < 2; i++) {
938                 cur = buf;
939                 num = 0;
940                 list_for_each_entry_safe(li, tmp, &cfile->llist, llist) {
941                         if (li->type != types[i])
942                                 continue;
943                         cur->Pid = cpu_to_le16(li->pid);
944                         cur->LengthLow = cpu_to_le32((u32)li->length);
945                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
946                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
947                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
948                         if (++num == max_num) {
949                                 stored_rc = cifs_lockv(xid, tcon,
950                                                        cfile->fid.netfid,
951                                                        (__u8)li->type, 0, num,
952                                                        buf);
953                                 if (stored_rc)
954                                         rc = stored_rc;
955                                 cur = buf;
956                                 num = 0;
957                         } else
958                                 cur++;
959                 }
960
961                 if (num) {
962                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
963                                                (__u8)types[i], 0, num, buf);
964                         if (stored_rc)
965                                 rc = stored_rc;
966                 }
967         }
968
969         cinode->can_cache_brlcks = false;
970         mutex_unlock(&cinode->lock_mutex);
971
972         kfree(buf);
973         free_xid(xid);
974         return rc;
975 }
976
977 /* copied from fs/locks.c with a name change */
978 #define cifs_for_each_lock(inode, lockp) \
979         for (lockp = &inode->i_flock; *lockp != NULL; \
980              lockp = &(*lockp)->fl_next)
981
982 struct lock_to_push {
983         struct list_head llist;
984         __u64 offset;
985         __u64 length;
986         __u32 pid;
987         __u16 netfid;
988         __u8 type;
989 };
990
991 static int
992 cifs_push_posix_locks(struct cifsFileInfo *cfile)
993 {
994         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
995         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
996         struct file_lock *flock, **before;
997         unsigned int count = 0, i = 0;
998         int rc = 0, xid, type;
999         struct list_head locks_to_send, *el;
1000         struct lock_to_push *lck, *tmp;
1001         __u64 length;
1002
1003         xid = get_xid();
1004
1005         mutex_lock(&cinode->lock_mutex);
1006         if (!cinode->can_cache_brlcks) {
1007                 mutex_unlock(&cinode->lock_mutex);
1008                 free_xid(xid);
1009                 return rc;
1010         }
1011
1012         lock_flocks();
1013         cifs_for_each_lock(cfile->dentry->d_inode, before) {
1014                 if ((*before)->fl_flags & FL_POSIX)
1015                         count++;
1016         }
1017         unlock_flocks();
1018
1019         INIT_LIST_HEAD(&locks_to_send);
1020
1021         /*
1022          * Allocating count locks is enough because no FL_POSIX locks can be
1023          * added to the list while we are holding cinode->lock_mutex that
1024          * protects locking operations of this inode.
1025          */
1026         for (; i < count; i++) {
1027                 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1028                 if (!lck) {
1029                         rc = -ENOMEM;
1030                         goto err_out;
1031                 }
1032                 list_add_tail(&lck->llist, &locks_to_send);
1033         }
1034
1035         el = locks_to_send.next;
1036         lock_flocks();
1037         cifs_for_each_lock(cfile->dentry->d_inode, before) {
1038                 flock = *before;
1039                 if ((flock->fl_flags & FL_POSIX) == 0)
1040                         continue;
1041                 if (el == &locks_to_send) {
1042                         /*
1043                          * The list ended. We don't have enough allocated
1044                          * structures - something is really wrong.
1045                          */
1046                         cERROR(1, "Can't push all brlocks!");
1047                         break;
1048                 }
1049                 length = 1 + flock->fl_end - flock->fl_start;
1050                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1051                         type = CIFS_RDLCK;
1052                 else
1053                         type = CIFS_WRLCK;
1054                 lck = list_entry(el, struct lock_to_push, llist);
1055                 lck->pid = flock->fl_pid;
1056                 lck->netfid = cfile->fid.netfid;
1057                 lck->length = length;
1058                 lck->type = type;
1059                 lck->offset = flock->fl_start;
1060                 el = el->next;
1061         }
1062         unlock_flocks();
1063
1064         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1065                 int stored_rc;
1066
1067                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1068                                              lck->offset, lck->length, NULL,
1069                                              lck->type, 0);
1070                 if (stored_rc)
1071                         rc = stored_rc;
1072                 list_del(&lck->llist);
1073                 kfree(lck);
1074         }
1075
1076 out:
1077         cinode->can_cache_brlcks = false;
1078         mutex_unlock(&cinode->lock_mutex);
1079
1080         free_xid(xid);
1081         return rc;
1082 err_out:
1083         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1084                 list_del(&lck->llist);
1085                 kfree(lck);
1086         }
1087         goto out;
1088 }
1089
1090 static int
1091 cifs_push_locks(struct cifsFileInfo *cfile)
1092 {
1093         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1094         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1095
1096         if (cap_unix(tcon->ses) &&
1097             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1098             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1099                 return cifs_push_posix_locks(cfile);
1100
1101         return cifs_push_mandatory_locks(cfile);
1102 }
1103
1104 static void
1105 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1106                 bool *wait_flag, struct TCP_Server_Info *server)
1107 {
1108         if (flock->fl_flags & FL_POSIX)
1109                 cFYI(1, "Posix");
1110         if (flock->fl_flags & FL_FLOCK)
1111                 cFYI(1, "Flock");
1112         if (flock->fl_flags & FL_SLEEP) {
1113                 cFYI(1, "Blocking lock");
1114                 *wait_flag = true;
1115         }
1116         if (flock->fl_flags & FL_ACCESS)
1117                 cFYI(1, "Process suspended by mandatory locking - "
1118                         "not implemented yet");
1119         if (flock->fl_flags & FL_LEASE)
1120                 cFYI(1, "Lease on file - not implemented yet");
1121         if (flock->fl_flags &
1122             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
1123                 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1124
1125         *type = server->vals->large_lock_type;
1126         if (flock->fl_type == F_WRLCK) {
1127                 cFYI(1, "F_WRLCK ");
1128                 *type |= server->vals->exclusive_lock_type;
1129                 *lock = 1;
1130         } else if (flock->fl_type == F_UNLCK) {
1131                 cFYI(1, "F_UNLCK");
1132                 *type |= server->vals->unlock_lock_type;
1133                 *unlock = 1;
1134                 /* Check if unlock includes more than one lock range */
1135         } else if (flock->fl_type == F_RDLCK) {
1136                 cFYI(1, "F_RDLCK");
1137                 *type |= server->vals->shared_lock_type;
1138                 *lock = 1;
1139         } else if (flock->fl_type == F_EXLCK) {
1140                 cFYI(1, "F_EXLCK");
1141                 *type |= server->vals->exclusive_lock_type;
1142                 *lock = 1;
1143         } else if (flock->fl_type == F_SHLCK) {
1144                 cFYI(1, "F_SHLCK");
1145                 *type |= server->vals->shared_lock_type;
1146                 *lock = 1;
1147         } else
1148                 cFYI(1, "Unknown type of lock");
1149 }
1150
1151 static int
1152 cifs_mandatory_lock(unsigned int xid, struct cifsFileInfo *cfile, __u64 offset,
1153                     __u64 length, __u32 type, int lock, int unlock, bool wait)
1154 {
1155         return CIFSSMBLock(xid, tlink_tcon(cfile->tlink), cfile->fid.netfid,
1156                            current->tgid, length, offset, unlock, lock,
1157                            (__u8)type, wait, 0);
1158 }
1159
1160 static int
1161 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1162            bool wait_flag, bool posix_lck, unsigned int xid)
1163 {
1164         int rc = 0;
1165         __u64 length = 1 + flock->fl_end - flock->fl_start;
1166         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1167         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1168         struct TCP_Server_Info *server = tcon->ses->server;
1169         __u16 netfid = cfile->fid.netfid;
1170
1171         if (posix_lck) {
1172                 int posix_lock_type;
1173
1174                 rc = cifs_posix_lock_test(file, flock);
1175                 if (!rc)
1176                         return rc;
1177
1178                 if (type & server->vals->shared_lock_type)
1179                         posix_lock_type = CIFS_RDLCK;
1180                 else
1181                         posix_lock_type = CIFS_WRLCK;
1182                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1183                                       flock->fl_start, length, flock,
1184                                       posix_lock_type, wait_flag);
1185                 return rc;
1186         }
1187
1188         rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1189         if (!rc)
1190                 return rc;
1191
1192         /* BB we could chain these into one lock request BB */
1193         rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length, type,
1194                                  1, 0, false);
1195         if (rc == 0) {
1196                 rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length,
1197                                          type, 0, 1, false);
1198                 flock->fl_type = F_UNLCK;
1199                 if (rc != 0)
1200                         cERROR(1, "Error unlocking previously locked "
1201                                   "range %d during test of lock", rc);
1202                 return 0;
1203         }
1204
1205         if (type & server->vals->shared_lock_type) {
1206                 flock->fl_type = F_WRLCK;
1207                 return 0;
1208         }
1209
1210         rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length,
1211                                  type | server->vals->shared_lock_type, 1, 0,
1212                                  false);
1213         if (rc == 0) {
1214                 rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length,
1215                                          type | server->vals->shared_lock_type,
1216                                          0, 1, false);
1217                 flock->fl_type = F_RDLCK;
1218                 if (rc != 0)
1219                         cERROR(1, "Error unlocking previously locked "
1220                                   "range %d during test of lock", rc);
1221         } else
1222                 flock->fl_type = F_WRLCK;
1223
1224         return 0;
1225 }
1226
1227 static void
1228 cifs_move_llist(struct list_head *source, struct list_head *dest)
1229 {
1230         struct list_head *li, *tmp;
1231         list_for_each_safe(li, tmp, source)
1232                 list_move(li, dest);
1233 }
1234
1235 static void
1236 cifs_free_llist(struct list_head *llist)
1237 {
1238         struct cifsLockInfo *li, *tmp;
1239         list_for_each_entry_safe(li, tmp, llist, llist) {
1240                 cifs_del_lock_waiters(li);
1241                 list_del(&li->llist);
1242                 kfree(li);
1243         }
1244 }
1245
1246 static int
1247 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1248                   unsigned int xid)
1249 {
1250         int rc = 0, stored_rc;
1251         int types[] = {LOCKING_ANDX_LARGE_FILES,
1252                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1253         unsigned int i;
1254         unsigned int max_num, num, max_buf;
1255         LOCKING_ANDX_RANGE *buf, *cur;
1256         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1257         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1258         struct cifsLockInfo *li, *tmp;
1259         __u64 length = 1 + flock->fl_end - flock->fl_start;
1260         struct list_head tmp_llist;
1261
1262         INIT_LIST_HEAD(&tmp_llist);
1263
1264         /*
1265          * Accessing maxBuf is racy with cifs_reconnect - need to store value
1266          * and check it for zero before using.
1267          */
1268         max_buf = tcon->ses->server->maxBuf;
1269         if (!max_buf)
1270                 return -EINVAL;
1271
1272         max_num = (max_buf - sizeof(struct smb_hdr)) /
1273                                                 sizeof(LOCKING_ANDX_RANGE);
1274         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1275         if (!buf)
1276                 return -ENOMEM;
1277
1278         mutex_lock(&cinode->lock_mutex);
1279         for (i = 0; i < 2; i++) {
1280                 cur = buf;
1281                 num = 0;
1282                 list_for_each_entry_safe(li, tmp, &cfile->llist, llist) {
1283                         if (flock->fl_start > li->offset ||
1284                             (flock->fl_start + length) <
1285                             (li->offset + li->length))
1286                                 continue;
1287                         if (current->tgid != li->pid)
1288                                 continue;
1289                         if (types[i] != li->type)
1290                                 continue;
1291                         if (cinode->can_cache_brlcks) {
1292                                 /*
1293                                  * We can cache brlock requests - simply remove
1294                                  * a lock from the file's list.
1295                                  */
1296                                 list_del(&li->llist);
1297                                 cifs_del_lock_waiters(li);
1298                                 kfree(li);
1299                                 continue;
1300                         }
1301                         cur->Pid = cpu_to_le16(li->pid);
1302                         cur->LengthLow = cpu_to_le32((u32)li->length);
1303                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1304                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
1305                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1306                         /*
1307                          * We need to save a lock here to let us add it again to
1308                          * the file's list if the unlock range request fails on
1309                          * the server.
1310                          */
1311                         list_move(&li->llist, &tmp_llist);
1312                         if (++num == max_num) {
1313                                 stored_rc = cifs_lockv(xid, tcon,
1314                                                        cfile->fid.netfid,
1315                                                        li->type, num, 0, buf);
1316                                 if (stored_rc) {
1317                                         /*
1318                                          * We failed on the unlock range
1319                                          * request - add all locks from the tmp
1320                                          * list to the head of the file's list.
1321                                          */
1322                                         cifs_move_llist(&tmp_llist,
1323                                                         &cfile->llist);
1324                                         rc = stored_rc;
1325                                 } else
1326                                         /*
1327                                          * The unlock range request succeed -
1328                                          * free the tmp list.
1329                                          */
1330                                         cifs_free_llist(&tmp_llist);
1331                                 cur = buf;
1332                                 num = 0;
1333                         } else
1334                                 cur++;
1335                 }
1336                 if (num) {
1337                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1338                                                types[i], num, 0, buf);
1339                         if (stored_rc) {
1340                                 cifs_move_llist(&tmp_llist, &cfile->llist);
1341                                 rc = stored_rc;
1342                         } else
1343                                 cifs_free_llist(&tmp_llist);
1344                 }
1345         }
1346
1347         mutex_unlock(&cinode->lock_mutex);
1348         kfree(buf);
1349         return rc;
1350 }
1351
1352 static int
1353 cifs_setlk(struct file *file,  struct file_lock *flock, __u32 type,
1354            bool wait_flag, bool posix_lck, int lock, int unlock,
1355            unsigned int xid)
1356 {
1357         int rc = 0;
1358         __u64 length = 1 + flock->fl_end - flock->fl_start;
1359         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1360         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1361         struct TCP_Server_Info *server = tcon->ses->server;
1362         __u16 netfid = cfile->fid.netfid;
1363
1364         if (posix_lck) {
1365                 int posix_lock_type;
1366
1367                 rc = cifs_posix_lock_set(file, flock);
1368                 if (!rc || rc < 0)
1369                         return rc;
1370
1371                 if (type & server->vals->shared_lock_type)
1372                         posix_lock_type = CIFS_RDLCK;
1373                 else
1374                         posix_lock_type = CIFS_WRLCK;
1375
1376                 if (unlock == 1)
1377                         posix_lock_type = CIFS_UNLCK;
1378
1379                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1380                                       flock->fl_start, length, NULL,
1381                                       posix_lock_type, wait_flag);
1382                 goto out;
1383         }
1384
1385         if (lock) {
1386                 struct cifsLockInfo *lock;
1387
1388                 lock = cifs_lock_init(flock->fl_start, length, type);
1389                 if (!lock)
1390                         return -ENOMEM;
1391
1392                 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1393                 if (rc < 0)
1394                         kfree(lock);
1395                 if (rc <= 0)
1396                         goto out;
1397
1398                 rc = cifs_mandatory_lock(xid, cfile, flock->fl_start, length,
1399                                          type, 1, 0, wait_flag);
1400                 if (rc) {
1401                         kfree(lock);
1402                         goto out;
1403                 }
1404
1405                 cifs_lock_add(cfile, lock);
1406         } else if (unlock)
1407                 rc = cifs_unlock_range(cfile, flock, xid);
1408
1409 out:
1410         if (flock->fl_flags & FL_POSIX)
1411                 posix_lock_file_wait(file, flock);
1412         return rc;
1413 }
1414
1415 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1416 {
1417         int rc, xid;
1418         int lock = 0, unlock = 0;
1419         bool wait_flag = false;
1420         bool posix_lck = false;
1421         struct cifs_sb_info *cifs_sb;
1422         struct cifs_tcon *tcon;
1423         struct cifsInodeInfo *cinode;
1424         struct cifsFileInfo *cfile;
1425         __u16 netfid;
1426         __u32 type;
1427
1428         rc = -EACCES;
1429         xid = get_xid();
1430
1431         cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1432                 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1433                 flock->fl_start, flock->fl_end);
1434
1435         cfile = (struct cifsFileInfo *)file->private_data;
1436         tcon = tlink_tcon(cfile->tlink);
1437
1438         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1439                         tcon->ses->server);
1440
1441         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1442         netfid = cfile->fid.netfid;
1443         cinode = CIFS_I(file->f_path.dentry->d_inode);
1444
1445         if (cap_unix(tcon->ses) &&
1446             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1447             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1448                 posix_lck = true;
1449         /*
1450          * BB add code here to normalize offset and length to account for
1451          * negative length which we can not accept over the wire.
1452          */
1453         if (IS_GETLK(cmd)) {
1454                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1455                 free_xid(xid);
1456                 return rc;
1457         }
1458
1459         if (!lock && !unlock) {
1460                 /*
1461                  * if no lock or unlock then nothing to do since we do not
1462                  * know what it is
1463                  */
1464                 free_xid(xid);
1465                 return -EOPNOTSUPP;
1466         }
1467
1468         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1469                         xid);
1470         free_xid(xid);
1471         return rc;
1472 }
1473
1474 /*
1475  * update the file size (if needed) after a write. Should be called with
1476  * the inode->i_lock held
1477  */
1478 void
1479 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1480                       unsigned int bytes_written)
1481 {
1482         loff_t end_of_write = offset + bytes_written;
1483
1484         if (end_of_write > cifsi->server_eof)
1485                 cifsi->server_eof = end_of_write;
1486 }
1487
1488 static ssize_t
1489 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1490            size_t write_size, loff_t *offset)
1491 {
1492         int rc = 0;
1493         unsigned int bytes_written = 0;
1494         unsigned int total_written;
1495         struct cifs_sb_info *cifs_sb;
1496         struct cifs_tcon *tcon;
1497         struct TCP_Server_Info *server;
1498         unsigned int xid;
1499         struct dentry *dentry = open_file->dentry;
1500         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1501         struct cifs_io_parms io_parms;
1502
1503         cifs_sb = CIFS_SB(dentry->d_sb);
1504
1505         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1506              *offset, dentry->d_name.name);
1507
1508         tcon = tlink_tcon(open_file->tlink);
1509         server = tcon->ses->server;
1510
1511         if (!server->ops->sync_write)
1512                 return -ENOSYS;
1513
1514         xid = get_xid();
1515
1516         for (total_written = 0; write_size > total_written;
1517              total_written += bytes_written) {
1518                 rc = -EAGAIN;
1519                 while (rc == -EAGAIN) {
1520                         struct kvec iov[2];
1521                         unsigned int len;
1522
1523                         if (open_file->invalidHandle) {
1524                                 /* we could deadlock if we called
1525                                    filemap_fdatawait from here so tell
1526                                    reopen_file not to flush data to
1527                                    server now */
1528                                 rc = cifs_reopen_file(open_file, false);
1529                                 if (rc != 0)
1530                                         break;
1531                         }
1532
1533                         len = min((size_t)cifs_sb->wsize,
1534                                   write_size - total_written);
1535                         /* iov[0] is reserved for smb header */
1536                         iov[1].iov_base = (char *)write_data + total_written;
1537                         iov[1].iov_len = len;
1538                         io_parms.pid = pid;
1539                         io_parms.tcon = tcon;
1540                         io_parms.offset = *offset;
1541                         io_parms.length = len;
1542                         rc = server->ops->sync_write(xid, open_file, &io_parms,
1543                                                      &bytes_written, iov, 1);
1544                 }
1545                 if (rc || (bytes_written == 0)) {
1546                         if (total_written)
1547                                 break;
1548                         else {
1549                                 free_xid(xid);
1550                                 return rc;
1551                         }
1552                 } else {
1553                         spin_lock(&dentry->d_inode->i_lock);
1554                         cifs_update_eof(cifsi, *offset, bytes_written);
1555                         spin_unlock(&dentry->d_inode->i_lock);
1556                         *offset += bytes_written;
1557                 }
1558         }
1559
1560         cifs_stats_bytes_written(tcon, total_written);
1561
1562         if (total_written > 0) {
1563                 spin_lock(&dentry->d_inode->i_lock);
1564                 if (*offset > dentry->d_inode->i_size)
1565                         i_size_write(dentry->d_inode, *offset);
1566                 spin_unlock(&dentry->d_inode->i_lock);
1567         }
1568         mark_inode_dirty_sync(dentry->d_inode);
1569         free_xid(xid);
1570         return total_written;
1571 }
1572
1573 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1574                                         bool fsuid_only)
1575 {
1576         struct cifsFileInfo *open_file = NULL;
1577         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1578
1579         /* only filter by fsuid on multiuser mounts */
1580         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1581                 fsuid_only = false;
1582
1583         spin_lock(&cifs_file_list_lock);
1584         /* we could simply get the first_list_entry since write-only entries
1585            are always at the end of the list but since the first entry might
1586            have a close pending, we go through the whole list */
1587         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1588                 if (fsuid_only && open_file->uid != current_fsuid())
1589                         continue;
1590                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1591                         if (!open_file->invalidHandle) {
1592                                 /* found a good file */
1593                                 /* lock it so it will not be closed on us */
1594                                 cifsFileInfo_get_locked(open_file);
1595                                 spin_unlock(&cifs_file_list_lock);
1596                                 return open_file;
1597                         } /* else might as well continue, and look for
1598                              another, or simply have the caller reopen it
1599                              again rather than trying to fix this handle */
1600                 } else /* write only file */
1601                         break; /* write only files are last so must be done */
1602         }
1603         spin_unlock(&cifs_file_list_lock);
1604         return NULL;
1605 }
1606
1607 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1608                                         bool fsuid_only)
1609 {
1610         struct cifsFileInfo *open_file, *inv_file = NULL;
1611         struct cifs_sb_info *cifs_sb;
1612         bool any_available = false;
1613         int rc;
1614         unsigned int refind = 0;
1615
1616         /* Having a null inode here (because mapping->host was set to zero by
1617         the VFS or MM) should not happen but we had reports of on oops (due to
1618         it being zero) during stress testcases so we need to check for it */
1619
1620         if (cifs_inode == NULL) {
1621                 cERROR(1, "Null inode passed to cifs_writeable_file");
1622                 dump_stack();
1623                 return NULL;
1624         }
1625
1626         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1627
1628         /* only filter by fsuid on multiuser mounts */
1629         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1630                 fsuid_only = false;
1631
1632         spin_lock(&cifs_file_list_lock);
1633 refind_writable:
1634         if (refind > MAX_REOPEN_ATT) {
1635                 spin_unlock(&cifs_file_list_lock);
1636                 return NULL;
1637         }
1638         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1639                 if (!any_available && open_file->pid != current->tgid)
1640                         continue;
1641                 if (fsuid_only && open_file->uid != current_fsuid())
1642                         continue;
1643                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1644                         if (!open_file->invalidHandle) {
1645                                 /* found a good writable file */
1646                                 cifsFileInfo_get_locked(open_file);
1647                                 spin_unlock(&cifs_file_list_lock);
1648                                 return open_file;
1649                         } else {
1650                                 if (!inv_file)
1651                                         inv_file = open_file;
1652                         }
1653                 }
1654         }
1655         /* couldn't find useable FH with same pid, try any available */
1656         if (!any_available) {
1657                 any_available = true;
1658                 goto refind_writable;
1659         }
1660
1661         if (inv_file) {
1662                 any_available = false;
1663                 cifsFileInfo_get_locked(inv_file);
1664         }
1665
1666         spin_unlock(&cifs_file_list_lock);
1667
1668         if (inv_file) {
1669                 rc = cifs_reopen_file(inv_file, false);
1670                 if (!rc)
1671                         return inv_file;
1672                 else {
1673                         spin_lock(&cifs_file_list_lock);
1674                         list_move_tail(&inv_file->flist,
1675                                         &cifs_inode->openFileList);
1676                         spin_unlock(&cifs_file_list_lock);
1677                         cifsFileInfo_put(inv_file);
1678                         spin_lock(&cifs_file_list_lock);
1679                         ++refind;
1680                         goto refind_writable;
1681                 }
1682         }
1683
1684         return NULL;
1685 }
1686
1687 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1688 {
1689         struct address_space *mapping = page->mapping;
1690         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1691         char *write_data;
1692         int rc = -EFAULT;
1693         int bytes_written = 0;
1694         struct inode *inode;
1695         struct cifsFileInfo *open_file;
1696
1697         if (!mapping || !mapping->host)
1698                 return -EFAULT;
1699
1700         inode = page->mapping->host;
1701
1702         offset += (loff_t)from;
1703         write_data = kmap(page);
1704         write_data += from;
1705
1706         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1707                 kunmap(page);
1708                 return -EIO;
1709         }
1710
1711         /* racing with truncate? */
1712         if (offset > mapping->host->i_size) {
1713                 kunmap(page);
1714                 return 0; /* don't care */
1715         }
1716
1717         /* check to make sure that we are not extending the file */
1718         if (mapping->host->i_size - offset < (loff_t)to)
1719                 to = (unsigned)(mapping->host->i_size - offset);
1720
1721         open_file = find_writable_file(CIFS_I(mapping->host), false);
1722         if (open_file) {
1723                 bytes_written = cifs_write(open_file, open_file->pid,
1724                                            write_data, to - from, &offset);
1725                 cifsFileInfo_put(open_file);
1726                 /* Does mm or vfs already set times? */
1727                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1728                 if ((bytes_written > 0) && (offset))
1729                         rc = 0;
1730                 else if (bytes_written < 0)
1731                         rc = bytes_written;
1732         } else {
1733                 cFYI(1, "No writeable filehandles for inode");
1734                 rc = -EIO;
1735         }
1736
1737         kunmap(page);
1738         return rc;
1739 }
1740
1741 static int cifs_writepages(struct address_space *mapping,
1742                            struct writeback_control *wbc)
1743 {
1744         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1745         bool done = false, scanned = false, range_whole = false;
1746         pgoff_t end, index;
1747         struct cifs_writedata *wdata;
1748         struct TCP_Server_Info *server;
1749         struct page *page;
1750         int rc = 0;
1751         loff_t isize = i_size_read(mapping->host);
1752
1753         /*
1754          * If wsize is smaller than the page cache size, default to writing
1755          * one page at a time via cifs_writepage
1756          */
1757         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1758                 return generic_writepages(mapping, wbc);
1759
1760         if (wbc->range_cyclic) {
1761                 index = mapping->writeback_index; /* Start from prev offset */
1762                 end = -1;
1763         } else {
1764                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1765                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1766                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1767                         range_whole = true;
1768                 scanned = true;
1769         }
1770 retry:
1771         while (!done && index <= end) {
1772                 unsigned int i, nr_pages, found_pages;
1773                 pgoff_t next = 0, tofind;
1774                 struct page **pages;
1775
1776                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1777                                 end - index) + 1;
1778
1779                 wdata = cifs_writedata_alloc((unsigned int)tofind,
1780                                              cifs_writev_complete);
1781                 if (!wdata) {
1782                         rc = -ENOMEM;
1783                         break;
1784                 }
1785
1786                 /*
1787                  * find_get_pages_tag seems to return a max of 256 on each
1788                  * iteration, so we must call it several times in order to
1789                  * fill the array or the wsize is effectively limited to
1790                  * 256 * PAGE_CACHE_SIZE.
1791                  */
1792                 found_pages = 0;
1793                 pages = wdata->pages;
1794                 do {
1795                         nr_pages = find_get_pages_tag(mapping, &index,
1796                                                         PAGECACHE_TAG_DIRTY,
1797                                                         tofind, pages);
1798                         found_pages += nr_pages;
1799                         tofind -= nr_pages;
1800                         pages += nr_pages;
1801                 } while (nr_pages && tofind && index <= end);
1802
1803                 if (found_pages == 0) {
1804                         kref_put(&wdata->refcount, cifs_writedata_release);
1805                         break;
1806                 }
1807
1808                 nr_pages = 0;
1809                 for (i = 0; i < found_pages; i++) {
1810                         page = wdata->pages[i];
1811                         /*
1812                          * At this point we hold neither mapping->tree_lock nor
1813                          * lock on the page itself: the page may be truncated or
1814                          * invalidated (changing page->mapping to NULL), or even
1815                          * swizzled back from swapper_space to tmpfs file
1816                          * mapping
1817                          */
1818
1819                         if (nr_pages == 0)
1820                                 lock_page(page);
1821                         else if (!trylock_page(page))
1822                                 break;
1823
1824                         if (unlikely(page->mapping != mapping)) {
1825                                 unlock_page(page);
1826                                 break;
1827                         }
1828
1829                         if (!wbc->range_cyclic && page->index > end) {
1830                                 done = true;
1831                                 unlock_page(page);
1832                                 break;
1833                         }
1834
1835                         if (next && (page->index != next)) {
1836                                 /* Not next consecutive page */
1837                                 unlock_page(page);
1838                                 break;
1839                         }
1840
1841                         if (wbc->sync_mode != WB_SYNC_NONE)
1842                                 wait_on_page_writeback(page);
1843
1844                         if (PageWriteback(page) ||
1845                                         !clear_page_dirty_for_io(page)) {
1846                                 unlock_page(page);
1847                                 break;
1848                         }
1849
1850                         /*
1851                          * This actually clears the dirty bit in the radix tree.
1852                          * See cifs_writepage() for more commentary.
1853                          */
1854                         set_page_writeback(page);
1855
1856                         if (page_offset(page) >= isize) {
1857                                 done = true;
1858                                 unlock_page(page);
1859                                 end_page_writeback(page);
1860                                 break;
1861                         }
1862
1863                         wdata->pages[i] = page;
1864                         next = page->index + 1;
1865                         ++nr_pages;
1866                 }
1867
1868                 /* reset index to refind any pages skipped */
1869                 if (nr_pages == 0)
1870                         index = wdata->pages[0]->index + 1;
1871
1872                 /* put any pages we aren't going to use */
1873                 for (i = nr_pages; i < found_pages; i++) {
1874                         page_cache_release(wdata->pages[i]);
1875                         wdata->pages[i] = NULL;
1876                 }
1877
1878                 /* nothing to write? */
1879                 if (nr_pages == 0) {
1880                         kref_put(&wdata->refcount, cifs_writedata_release);
1881                         continue;
1882                 }
1883
1884                 wdata->sync_mode = wbc->sync_mode;
1885                 wdata->nr_pages = nr_pages;
1886                 wdata->offset = page_offset(wdata->pages[0]);
1887                 wdata->pagesz = PAGE_CACHE_SIZE;
1888                 wdata->tailsz =
1889                         min(isize - page_offset(wdata->pages[nr_pages - 1]),
1890                             (loff_t)PAGE_CACHE_SIZE);
1891                 wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) +
1892                                         wdata->tailsz;
1893
1894                 do {
1895                         if (wdata->cfile != NULL)
1896                                 cifsFileInfo_put(wdata->cfile);
1897                         wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1898                                                           false);
1899                         if (!wdata->cfile) {
1900                                 cERROR(1, "No writable handles for inode");
1901                                 rc = -EBADF;
1902                                 break;
1903                         }
1904                         wdata->pid = wdata->cfile->pid;
1905                         server = tlink_tcon(wdata->cfile->tlink)->ses->server;
1906                         rc = server->ops->async_writev(wdata);
1907                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1908
1909                 for (i = 0; i < nr_pages; ++i)
1910                         unlock_page(wdata->pages[i]);
1911
1912                 /* send failure -- clean up the mess */
1913                 if (rc != 0) {
1914                         for (i = 0; i < nr_pages; ++i) {
1915                                 if (rc == -EAGAIN)
1916                                         redirty_page_for_writepage(wbc,
1917                                                            wdata->pages[i]);
1918                                 else
1919                                         SetPageError(wdata->pages[i]);
1920                                 end_page_writeback(wdata->pages[i]);
1921                                 page_cache_release(wdata->pages[i]);
1922                         }
1923                         if (rc != -EAGAIN)
1924                                 mapping_set_error(mapping, rc);
1925                 }
1926                 kref_put(&wdata->refcount, cifs_writedata_release);
1927
1928                 wbc->nr_to_write -= nr_pages;
1929                 if (wbc->nr_to_write <= 0)
1930                         done = true;
1931
1932                 index = next;
1933         }
1934
1935         if (!scanned && !done) {
1936                 /*
1937                  * We hit the last page and there is more work to be done: wrap
1938                  * back to the start of the file
1939                  */
1940                 scanned = true;
1941                 index = 0;
1942                 goto retry;
1943         }
1944
1945         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1946                 mapping->writeback_index = index;
1947
1948         return rc;
1949 }
1950
1951 static int
1952 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1953 {
1954         int rc;
1955         unsigned int xid;
1956
1957         xid = get_xid();
1958 /* BB add check for wbc flags */
1959         page_cache_get(page);
1960         if (!PageUptodate(page))
1961                 cFYI(1, "ppw - page not up to date");
1962
1963         /*
1964          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1965          *
1966          * A writepage() implementation always needs to do either this,
1967          * or re-dirty the page with "redirty_page_for_writepage()" in
1968          * the case of a failure.
1969          *
1970          * Just unlocking the page will cause the radix tree tag-bits
1971          * to fail to update with the state of the page correctly.
1972          */
1973         set_page_writeback(page);
1974 retry_write:
1975         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1976         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1977                 goto retry_write;
1978         else if (rc == -EAGAIN)
1979                 redirty_page_for_writepage(wbc, page);
1980         else if (rc != 0)
1981                 SetPageError(page);
1982         else
1983                 SetPageUptodate(page);
1984         end_page_writeback(page);
1985         page_cache_release(page);
1986         free_xid(xid);
1987         return rc;
1988 }
1989
1990 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1991 {
1992         int rc = cifs_writepage_locked(page, wbc);
1993         unlock_page(page);
1994         return rc;
1995 }
1996
1997 static int cifs_write_end(struct file *file, struct address_space *mapping,
1998                         loff_t pos, unsigned len, unsigned copied,
1999                         struct page *page, void *fsdata)
2000 {
2001         int rc;
2002         struct inode *inode = mapping->host;
2003         struct cifsFileInfo *cfile = file->private_data;
2004         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2005         __u32 pid;
2006
2007         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2008                 pid = cfile->pid;
2009         else
2010                 pid = current->tgid;
2011
2012         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
2013                  page, pos, copied);
2014
2015         if (PageChecked(page)) {
2016                 if (copied == len)
2017                         SetPageUptodate(page);
2018                 ClearPageChecked(page);
2019         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
2020                 SetPageUptodate(page);
2021
2022         if (!PageUptodate(page)) {
2023                 char *page_data;
2024                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
2025                 unsigned int xid;
2026
2027                 xid = get_xid();
2028                 /* this is probably better than directly calling
2029                    partialpage_write since in this function the file handle is
2030                    known which we might as well leverage */
2031                 /* BB check if anything else missing out of ppw
2032                    such as updating last write time */
2033                 page_data = kmap(page);
2034                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2035                 /* if (rc < 0) should we set writebehind rc? */
2036                 kunmap(page);
2037
2038                 free_xid(xid);
2039         } else {
2040                 rc = copied;
2041                 pos += copied;
2042                 set_page_dirty(page);
2043         }
2044
2045         if (rc > 0) {
2046                 spin_lock(&inode->i_lock);
2047                 if (pos > inode->i_size)
2048                         i_size_write(inode, pos);
2049                 spin_unlock(&inode->i_lock);
2050         }
2051
2052         unlock_page(page);
2053         page_cache_release(page);
2054
2055         return rc;
2056 }
2057
2058 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2059                       int datasync)
2060 {
2061         unsigned int xid;
2062         int rc = 0;
2063         struct cifs_tcon *tcon;
2064         struct TCP_Server_Info *server;
2065         struct cifsFileInfo *smbfile = file->private_data;
2066         struct inode *inode = file->f_path.dentry->d_inode;
2067         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2068
2069         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2070         if (rc)
2071                 return rc;
2072         mutex_lock(&inode->i_mutex);
2073
2074         xid = get_xid();
2075
2076         cFYI(1, "Sync file - name: %s datasync: 0x%x",
2077                 file->f_path.dentry->d_name.name, datasync);
2078
2079         if (!CIFS_I(inode)->clientCanCacheRead) {
2080                 rc = cifs_invalidate_mapping(inode);
2081                 if (rc) {
2082                         cFYI(1, "rc: %d during invalidate phase", rc);
2083                         rc = 0; /* don't care about it in fsync */
2084                 }
2085         }
2086
2087         tcon = tlink_tcon(smbfile->tlink);
2088         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2089                 server = tcon->ses->server;
2090                 if (server->ops->flush)
2091                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2092                 else
2093                         rc = -ENOSYS;
2094         }
2095
2096         free_xid(xid);
2097         mutex_unlock(&inode->i_mutex);
2098         return rc;
2099 }
2100
2101 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2102 {
2103         unsigned int xid;
2104         int rc = 0;
2105         struct cifs_tcon *tcon;
2106         struct TCP_Server_Info *server;
2107         struct cifsFileInfo *smbfile = file->private_data;
2108         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2109         struct inode *inode = file->f_mapping->host;
2110
2111         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2112         if (rc)
2113                 return rc;
2114         mutex_lock(&inode->i_mutex);
2115
2116         xid = get_xid();
2117
2118         cFYI(1, "Sync file - name: %s datasync: 0x%x",
2119                 file->f_path.dentry->d_name.name, datasync);
2120
2121         tcon = tlink_tcon(smbfile->tlink);
2122         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2123                 server = tcon->ses->server;
2124                 if (server->ops->flush)
2125                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2126                 else
2127                         rc = -ENOSYS;
2128         }
2129
2130         free_xid(xid);
2131         mutex_unlock(&inode->i_mutex);
2132         return rc;
2133 }
2134
2135 /*
2136  * As file closes, flush all cached write data for this inode checking
2137  * for write behind errors.
2138  */
2139 int cifs_flush(struct file *file, fl_owner_t id)
2140 {
2141         struct inode *inode = file->f_path.dentry->d_inode;
2142         int rc = 0;
2143
2144         if (file->f_mode & FMODE_WRITE)
2145                 rc = filemap_write_and_wait(inode->i_mapping);
2146
2147         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2148
2149         return rc;
2150 }
2151
2152 static int
2153 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2154 {
2155         int rc = 0;
2156         unsigned long i;
2157
2158         for (i = 0; i < num_pages; i++) {
2159                 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2160                 if (!pages[i]) {
2161                         /*
2162                          * save number of pages we have already allocated and
2163                          * return with ENOMEM error
2164                          */
2165                         num_pages = i;
2166                         rc = -ENOMEM;
2167                         break;
2168                 }
2169         }
2170
2171         if (rc) {
2172                 for (i = 0; i < num_pages; i++)
2173                         put_page(pages[i]);
2174         }
2175         return rc;
2176 }
2177
2178 static inline
2179 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2180 {
2181         size_t num_pages;
2182         size_t clen;
2183
2184         clen = min_t(const size_t, len, wsize);
2185         num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2186
2187         if (cur_len)
2188                 *cur_len = clen;
2189
2190         return num_pages;
2191 }
2192
2193 static void
2194 cifs_uncached_writev_complete(struct work_struct *work)
2195 {
2196         int i;
2197         struct cifs_writedata *wdata = container_of(work,
2198                                         struct cifs_writedata, work);
2199         struct inode *inode = wdata->cfile->dentry->d_inode;
2200         struct cifsInodeInfo *cifsi = CIFS_I(inode);
2201
2202         spin_lock(&inode->i_lock);
2203         cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2204         if (cifsi->server_eof > inode->i_size)
2205                 i_size_write(inode, cifsi->server_eof);
2206         spin_unlock(&inode->i_lock);
2207
2208         complete(&wdata->done);
2209
2210         if (wdata->result != -EAGAIN) {
2211                 for (i = 0; i < wdata->nr_pages; i++)
2212                         put_page(wdata->pages[i]);
2213         }
2214
2215         kref_put(&wdata->refcount, cifs_writedata_release);
2216 }
2217
2218 /* attempt to send write to server, retry on any -EAGAIN errors */
2219 static int
2220 cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2221 {
2222         int rc;
2223         struct TCP_Server_Info *server;
2224
2225         server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2226
2227         do {
2228                 if (wdata->cfile->invalidHandle) {
2229                         rc = cifs_reopen_file(wdata->cfile, false);
2230                         if (rc != 0)
2231                                 continue;
2232                 }
2233                 rc = server->ops->async_writev(wdata);
2234         } while (rc == -EAGAIN);
2235
2236         return rc;
2237 }
2238
2239 static ssize_t
2240 cifs_iovec_write(struct file *file, const struct iovec *iov,
2241                  unsigned long nr_segs, loff_t *poffset)
2242 {
2243         unsigned long nr_pages, i;
2244         size_t copied, len, cur_len;
2245         ssize_t total_written = 0;
2246         loff_t offset;
2247         struct iov_iter it;
2248         struct cifsFileInfo *open_file;
2249         struct cifs_tcon *tcon;
2250         struct cifs_sb_info *cifs_sb;
2251         struct cifs_writedata *wdata, *tmp;
2252         struct list_head wdata_list;
2253         int rc;
2254         pid_t pid;
2255
2256         len = iov_length(iov, nr_segs);
2257         if (!len)
2258                 return 0;
2259
2260         rc = generic_write_checks(file, poffset, &len, 0);
2261         if (rc)
2262                 return rc;
2263
2264         INIT_LIST_HEAD(&wdata_list);
2265         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2266         open_file = file->private_data;
2267         tcon = tlink_tcon(open_file->tlink);
2268
2269         if (!tcon->ses->server->ops->async_writev)
2270                 return -ENOSYS;
2271
2272         offset = *poffset;
2273
2274         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2275                 pid = open_file->pid;
2276         else
2277                 pid = current->tgid;
2278
2279         iov_iter_init(&it, iov, nr_segs, len, 0);
2280         do {
2281                 size_t save_len;
2282
2283                 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2284                 wdata = cifs_writedata_alloc(nr_pages,
2285                                              cifs_uncached_writev_complete);
2286                 if (!wdata) {
2287                         rc = -ENOMEM;
2288                         break;
2289                 }
2290
2291                 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2292                 if (rc) {
2293                         kfree(wdata);
2294                         break;
2295                 }
2296
2297                 save_len = cur_len;
2298                 for (i = 0; i < nr_pages; i++) {
2299                         copied = min_t(const size_t, cur_len, PAGE_SIZE);
2300                         copied = iov_iter_copy_from_user(wdata->pages[i], &it,
2301                                                          0, copied);
2302                         cur_len -= copied;
2303                         iov_iter_advance(&it, copied);
2304                 }
2305                 cur_len = save_len - cur_len;
2306
2307                 wdata->sync_mode = WB_SYNC_ALL;
2308                 wdata->nr_pages = nr_pages;
2309                 wdata->offset = (__u64)offset;
2310                 wdata->cfile = cifsFileInfo_get(open_file);
2311                 wdata->pid = pid;
2312                 wdata->bytes = cur_len;
2313                 wdata->pagesz = PAGE_SIZE;
2314                 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2315                 rc = cifs_uncached_retry_writev(wdata);
2316                 if (rc) {
2317                         kref_put(&wdata->refcount, cifs_writedata_release);
2318                         break;
2319                 }
2320
2321                 list_add_tail(&wdata->list, &wdata_list);
2322                 offset += cur_len;
2323                 len -= cur_len;
2324         } while (len > 0);
2325
2326         /*
2327          * If at least one write was successfully sent, then discard any rc
2328          * value from the later writes. If the other write succeeds, then
2329          * we'll end up returning whatever was written. If it fails, then
2330          * we'll get a new rc value from that.
2331          */
2332         if (!list_empty(&wdata_list))
2333                 rc = 0;
2334
2335         /*
2336          * Wait for and collect replies for any successful sends in order of
2337          * increasing offset. Once an error is hit or we get a fatal signal
2338          * while waiting, then return without waiting for any more replies.
2339          */
2340 restart_loop:
2341         list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2342                 if (!rc) {
2343                         /* FIXME: freezable too? */
2344                         rc = wait_for_completion_killable(&wdata->done);
2345                         if (rc)
2346                                 rc = -EINTR;
2347                         else if (wdata->result)
2348                                 rc = wdata->result;
2349                         else
2350                                 total_written += wdata->bytes;
2351
2352                         /* resend call if it's a retryable error */
2353                         if (rc == -EAGAIN) {
2354                                 rc = cifs_uncached_retry_writev(wdata);
2355                                 goto restart_loop;
2356                         }
2357                 }
2358                 list_del_init(&wdata->list);
2359                 kref_put(&wdata->refcount, cifs_writedata_release);
2360         }
2361
2362         if (total_written > 0)
2363                 *poffset += total_written;
2364
2365         cifs_stats_bytes_written(tcon, total_written);
2366         return total_written ? total_written : (ssize_t)rc;
2367 }
2368
2369 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2370                                 unsigned long nr_segs, loff_t pos)
2371 {
2372         ssize_t written;
2373         struct inode *inode;
2374
2375         inode = iocb->ki_filp->f_path.dentry->d_inode;
2376
2377         /*
2378          * BB - optimize the way when signing is disabled. We can drop this
2379          * extra memory-to-memory copying and use iovec buffers for constructing
2380          * write request.
2381          */
2382
2383         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2384         if (written > 0) {
2385                 CIFS_I(inode)->invalid_mapping = true;
2386                 iocb->ki_pos = pos;
2387         }
2388
2389         return written;
2390 }
2391
2392 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2393                            unsigned long nr_segs, loff_t pos)
2394 {
2395         struct inode *inode;
2396
2397         inode = iocb->ki_filp->f_path.dentry->d_inode;
2398
2399         if (CIFS_I(inode)->clientCanCacheAll)
2400                 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2401
2402         /*
2403          * In strict cache mode we need to write the data to the server exactly
2404          * from the pos to pos+len-1 rather than flush all affected pages
2405          * because it may cause a error with mandatory locks on these pages but
2406          * not on the region from pos to ppos+len-1.
2407          */
2408
2409         return cifs_user_writev(iocb, iov, nr_segs, pos);
2410 }
2411
2412 static struct cifs_readdata *
2413 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2414 {
2415         struct cifs_readdata *rdata;
2416         struct kvec *iov;
2417
2418         iov = kzalloc(sizeof(*iov) * (nr_pages + 1), GFP_KERNEL);
2419         if (!iov)
2420                 return (struct cifs_readdata *)iov;
2421
2422         rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2423                         GFP_KERNEL);
2424         if (rdata != NULL) {
2425                 kref_init(&rdata->refcount);
2426                 INIT_LIST_HEAD(&rdata->list);
2427                 init_completion(&rdata->done);
2428                 INIT_WORK(&rdata->work, complete);
2429                 rdata->iov = iov;
2430         } else {
2431                 kfree(iov);
2432         }
2433
2434         return rdata;
2435 }
2436
2437 void
2438 cifs_readdata_release(struct kref *refcount)
2439 {
2440         struct cifs_readdata *rdata = container_of(refcount,
2441                                         struct cifs_readdata, refcount);
2442
2443         if (rdata->cfile)
2444                 cifsFileInfo_put(rdata->cfile);
2445
2446         kfree(rdata->iov);
2447         kfree(rdata);
2448 }
2449
2450 static int
2451 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2452 {
2453         int rc = 0;
2454         struct page *page;
2455         unsigned int i;
2456
2457         for (i = 0; i < nr_pages; i++) {
2458                 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2459                 if (!page) {
2460                         rc = -ENOMEM;
2461                         break;
2462                 }
2463                 rdata->pages[i] = page;
2464         }
2465
2466         if (rc) {
2467                 for (i = 0; i < nr_pages; i++) {
2468                         put_page(rdata->pages[i]);
2469                         rdata->pages[i] = NULL;
2470                 }
2471         }
2472         return rc;
2473 }
2474
2475 static void
2476 cifs_uncached_readdata_release(struct kref *refcount)
2477 {
2478         struct cifs_readdata *rdata = container_of(refcount,
2479                                         struct cifs_readdata, refcount);
2480         unsigned int i;
2481
2482         for (i = 0; i < rdata->nr_pages; i++) {
2483                 put_page(rdata->pages[i]);
2484                 rdata->pages[i] = NULL;
2485         }
2486         cifs_readdata_release(refcount);
2487 }
2488
2489 static int
2490 cifs_retry_async_readv(struct cifs_readdata *rdata)
2491 {
2492         int rc;
2493         struct TCP_Server_Info *server;
2494
2495         server = tlink_tcon(rdata->cfile->tlink)->ses->server;
2496
2497         do {
2498                 if (rdata->cfile->invalidHandle) {
2499                         rc = cifs_reopen_file(rdata->cfile, true);
2500                         if (rc != 0)
2501                                 continue;
2502                 }
2503                 rc = server->ops->async_readv(rdata);
2504         } while (rc == -EAGAIN);
2505
2506         return rc;
2507 }
2508
2509 /**
2510  * cifs_readdata_to_iov - copy data from pages in response to an iovec
2511  * @rdata:      the readdata response with list of pages holding data
2512  * @iov:        vector in which we should copy the data
2513  * @nr_segs:    number of segments in vector
2514  * @offset:     offset into file of the first iovec
2515  * @copied:     used to return the amount of data copied to the iov
2516  *
2517  * This function copies data from a list of pages in a readdata response into
2518  * an array of iovecs. It will first calculate where the data should go
2519  * based on the info in the readdata and then copy the data into that spot.
2520  */
2521 static ssize_t
2522 cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
2523                         unsigned long nr_segs, loff_t offset, ssize_t *copied)
2524 {
2525         int rc = 0;
2526         struct iov_iter ii;
2527         size_t pos = rdata->offset - offset;
2528         ssize_t remaining = rdata->bytes;
2529         unsigned char *pdata;
2530         unsigned int i;
2531
2532         /* set up iov_iter and advance to the correct offset */
2533         iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2534         iov_iter_advance(&ii, pos);
2535
2536         *copied = 0;
2537         for (i = 0; i < rdata->nr_pages; i++) {
2538                 ssize_t copy;
2539                 struct page *page = rdata->pages[i];
2540
2541                 /* copy a whole page or whatever's left */
2542                 copy = min_t(ssize_t, remaining, PAGE_SIZE);
2543
2544                 /* ...but limit it to whatever space is left in the iov */
2545                 copy = min_t(ssize_t, copy, iov_iter_count(&ii));
2546
2547                 /* go while there's data to be copied and no errors */
2548                 if (copy && !rc) {
2549                         pdata = kmap(page);
2550                         rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
2551                                                 (int)copy);
2552                         kunmap(page);
2553                         if (!rc) {
2554                                 *copied += copy;
2555                                 remaining -= copy;
2556                                 iov_iter_advance(&ii, copy);
2557                         }
2558                 }
2559         }
2560
2561         return rc;
2562 }
2563
2564 static void
2565 cifs_uncached_readv_complete(struct work_struct *work)
2566 {
2567         struct cifs_readdata *rdata = container_of(work,
2568                                                 struct cifs_readdata, work);
2569
2570         complete(&rdata->done);
2571         kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2572 }
2573
2574 static int
2575 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2576                         struct cifs_readdata *rdata, unsigned int len)
2577 {
2578         int total_read = 0, result = 0;
2579         unsigned int i;
2580         unsigned int nr_pages = rdata->nr_pages;
2581         struct kvec iov;
2582
2583         rdata->tailsz = PAGE_SIZE;
2584         for (i = 0; i < nr_pages; i++) {
2585                 struct page *page = rdata->pages[i];
2586
2587                 if (len >= PAGE_SIZE) {
2588                         /* enough data to fill the page */
2589                         iov.iov_base = kmap(page);
2590                         iov.iov_len = PAGE_SIZE;
2591                         cFYI(1, "%u: iov_base=%p iov_len=%zu",
2592                                 i, iov.iov_base, iov.iov_len);
2593                         len -= PAGE_SIZE;
2594                 } else if (len > 0) {
2595                         /* enough for partial page, fill and zero the rest */
2596                         iov.iov_base = kmap(page);
2597                         iov.iov_len = len;
2598                         cFYI(1, "%u: iov_base=%p iov_len=%zu",
2599                                 i, iov.iov_base, iov.iov_len);
2600                         memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2601                         rdata->tailsz = len;
2602                         len = 0;
2603                 } else {
2604                         /* no need to hold page hostage */
2605                         rdata->pages[i] = NULL;
2606                         rdata->nr_pages--;
2607                         put_page(page);
2608                         continue;
2609                 }
2610
2611                 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2612                 kunmap(page);
2613                 if (result < 0)
2614                         break;
2615
2616                 total_read += result;
2617         }
2618
2619         return total_read > 0 ? total_read : result;
2620 }
2621
2622 static ssize_t
2623 cifs_iovec_read(struct file *file, const struct iovec *iov,
2624                  unsigned long nr_segs, loff_t *poffset)
2625 {
2626         ssize_t rc;
2627         size_t len, cur_len;
2628         ssize_t total_read = 0;
2629         loff_t offset = *poffset;
2630         unsigned int npages;
2631         struct cifs_sb_info *cifs_sb;
2632         struct cifs_tcon *tcon;
2633         struct cifsFileInfo *open_file;
2634         struct cifs_readdata *rdata, *tmp;
2635         struct list_head rdata_list;
2636         pid_t pid;
2637
2638         if (!nr_segs)
2639                 return 0;
2640
2641         len = iov_length(iov, nr_segs);
2642         if (!len)
2643                 return 0;
2644
2645         INIT_LIST_HEAD(&rdata_list);
2646         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2647         open_file = file->private_data;
2648         tcon = tlink_tcon(open_file->tlink);
2649
2650         if (!tcon->ses->server->ops->async_readv)
2651                 return -ENOSYS;
2652
2653         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2654                 pid = open_file->pid;
2655         else
2656                 pid = current->tgid;
2657
2658         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2659                 cFYI(1, "attempting read on write only file instance");
2660
2661         do {
2662                 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
2663                 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2664
2665                 /* allocate a readdata struct */
2666                 rdata = cifs_readdata_alloc(npages,
2667                                             cifs_uncached_readv_complete);
2668                 if (!rdata) {
2669                         rc = -ENOMEM;
2670                         goto error;
2671                 }
2672
2673                 rc = cifs_read_allocate_pages(rdata, npages);
2674                 if (rc)
2675                         goto error;
2676
2677                 rdata->cfile = cifsFileInfo_get(open_file);
2678                 rdata->nr_pages = npages;
2679                 rdata->offset = offset;
2680                 rdata->bytes = cur_len;
2681                 rdata->pid = pid;
2682                 rdata->pagesz = PAGE_SIZE;
2683                 rdata->read_into_pages = cifs_uncached_read_into_pages;
2684
2685                 rc = cifs_retry_async_readv(rdata);
2686 error:
2687                 if (rc) {
2688                         kref_put(&rdata->refcount,
2689                                  cifs_uncached_readdata_release);
2690                         break;
2691                 }
2692
2693                 list_add_tail(&rdata->list, &rdata_list);
2694                 offset += cur_len;
2695                 len -= cur_len;
2696         } while (len > 0);
2697
2698         /* if at least one read request send succeeded, then reset rc */
2699         if (!list_empty(&rdata_list))
2700                 rc = 0;
2701
2702         /* the loop below should proceed in the order of increasing offsets */
2703 restart_loop:
2704         list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
2705                 if (!rc) {
2706                         ssize_t copied;
2707
2708                         /* FIXME: freezable sleep too? */
2709                         rc = wait_for_completion_killable(&rdata->done);
2710                         if (rc)
2711                                 rc = -EINTR;
2712                         else if (rdata->result)
2713                                 rc = rdata->result;
2714                         else {
2715                                 rc = cifs_readdata_to_iov(rdata, iov,
2716                                                         nr_segs, *poffset,
2717                                                         &copied);
2718                                 total_read += copied;
2719                         }
2720
2721                         /* resend call if it's a retryable error */
2722                         if (rc == -EAGAIN) {
2723                                 rc = cifs_retry_async_readv(rdata);
2724                                 goto restart_loop;
2725                         }
2726                 }
2727                 list_del_init(&rdata->list);
2728                 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2729         }
2730
2731         cifs_stats_bytes_read(tcon, total_read);
2732         *poffset += total_read;
2733
2734         /* mask nodata case */
2735         if (rc == -ENODATA)
2736                 rc = 0;
2737
2738         return total_read ? total_read : rc;
2739 }
2740
2741 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2742                                unsigned long nr_segs, loff_t pos)
2743 {
2744         ssize_t read;
2745
2746         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2747         if (read > 0)
2748                 iocb->ki_pos = pos;
2749
2750         return read;
2751 }
2752
2753 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2754                           unsigned long nr_segs, loff_t pos)
2755 {
2756         struct inode *inode;
2757
2758         inode = iocb->ki_filp->f_path.dentry->d_inode;
2759
2760         if (CIFS_I(inode)->clientCanCacheRead)
2761                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2762
2763         /*
2764          * In strict cache mode we need to read from the server all the time
2765          * if we don't have level II oplock because the server can delay mtime
2766          * change - so we can't make a decision about inode invalidating.
2767          * And we can also fail with pagereading if there are mandatory locks
2768          * on pages affected by this read but not on the region from pos to
2769          * pos+len-1.
2770          */
2771
2772         return cifs_user_readv(iocb, iov, nr_segs, pos);
2773 }
2774
2775 static ssize_t
2776 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
2777 {
2778         int rc = -EACCES;
2779         unsigned int bytes_read = 0;
2780         unsigned int total_read;
2781         unsigned int current_read_size;
2782         unsigned int rsize;
2783         struct cifs_sb_info *cifs_sb;
2784         struct cifs_tcon *tcon;
2785         struct TCP_Server_Info *server;
2786         unsigned int xid;
2787         char *cur_offset;
2788         struct cifsFileInfo *open_file;
2789         struct cifs_io_parms io_parms;
2790         int buf_type = CIFS_NO_BUFFER;
2791         __u32 pid;
2792
2793         xid = get_xid();
2794         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2795
2796         /* FIXME: set up handlers for larger reads and/or convert to async */
2797         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2798
2799         if (file->private_data == NULL) {
2800                 rc = -EBADF;
2801                 free_xid(xid);
2802                 return rc;
2803         }
2804         open_file = file->private_data;
2805         tcon = tlink_tcon(open_file->tlink);
2806         server = tcon->ses->server;
2807
2808         if (!server->ops->sync_read) {
2809                 free_xid(xid);
2810                 return -ENOSYS;
2811         }
2812
2813         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2814                 pid = open_file->pid;
2815         else
2816                 pid = current->tgid;
2817
2818         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2819                 cFYI(1, "attempting read on write only file instance");
2820
2821         for (total_read = 0, cur_offset = read_data; read_size > total_read;
2822              total_read += bytes_read, cur_offset += bytes_read) {
2823                 current_read_size = min_t(uint, read_size - total_read, rsize);
2824                 /*
2825                  * For windows me and 9x we do not want to request more than it
2826                  * negotiated since it will refuse the read then.
2827                  */
2828                 if ((tcon->ses) && !(tcon->ses->capabilities &
2829                                 tcon->ses->server->vals->cap_large_files)) {
2830                         current_read_size = min_t(uint, current_read_size,
2831                                         CIFSMaxBufSize);
2832                 }
2833                 rc = -EAGAIN;
2834                 while (rc == -EAGAIN) {
2835                         if (open_file->invalidHandle) {
2836                                 rc = cifs_reopen_file(open_file, true);
2837                                 if (rc != 0)
2838                                         break;
2839                         }
2840                         io_parms.pid = pid;
2841                         io_parms.tcon = tcon;
2842                         io_parms.offset = *offset;
2843                         io_parms.length = current_read_size;
2844                         rc = server->ops->sync_read(xid, open_file, &io_parms,
2845                                                     &bytes_read, &cur_offset,
2846                                                     &buf_type);
2847                 }
2848                 if (rc || (bytes_read == 0)) {
2849                         if (total_read) {
2850                                 break;
2851                         } else {
2852                                 free_xid(xid);
2853                                 return rc;
2854                         }
2855                 } else {
2856                         cifs_stats_bytes_read(tcon, total_read);
2857                         *offset += bytes_read;
2858                 }
2859         }
2860         free_xid(xid);
2861         return total_read;
2862 }
2863
2864 /*
2865  * If the page is mmap'ed into a process' page tables, then we need to make
2866  * sure that it doesn't change while being written back.
2867  */
2868 static int
2869 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2870 {
2871         struct page *page = vmf->page;
2872
2873         lock_page(page);
2874         return VM_FAULT_LOCKED;
2875 }
2876
2877 static struct vm_operations_struct cifs_file_vm_ops = {
2878         .fault = filemap_fault,
2879         .page_mkwrite = cifs_page_mkwrite,
2880 };
2881
2882 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2883 {
2884         int rc, xid;
2885         struct inode *inode = file->f_path.dentry->d_inode;
2886
2887         xid = get_xid();
2888
2889         if (!CIFS_I(inode)->clientCanCacheRead) {
2890                 rc = cifs_invalidate_mapping(inode);
2891                 if (rc)
2892                         return rc;
2893         }
2894
2895         rc = generic_file_mmap(file, vma);
2896         if (rc == 0)
2897                 vma->vm_ops = &cifs_file_vm_ops;
2898         free_xid(xid);
2899         return rc;
2900 }
2901
2902 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2903 {
2904         int rc, xid;
2905
2906         xid = get_xid();
2907         rc = cifs_revalidate_file(file);
2908         if (rc) {
2909                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2910                 free_xid(xid);
2911                 return rc;
2912         }
2913         rc = generic_file_mmap(file, vma);
2914         if (rc == 0)
2915                 vma->vm_ops = &cifs_file_vm_ops;
2916         free_xid(xid);
2917         return rc;
2918 }
2919
2920 static void
2921 cifs_readv_complete(struct work_struct *work)
2922 {
2923         unsigned int i;
2924         struct cifs_readdata *rdata = container_of(work,
2925                                                 struct cifs_readdata, work);
2926
2927         for (i = 0; i < rdata->nr_pages; i++) {
2928                 struct page *page = rdata->pages[i];
2929
2930                 lru_cache_add_file(page);
2931
2932                 if (rdata->result == 0) {
2933                         flush_dcache_page(page);
2934                         SetPageUptodate(page);
2935                 }
2936
2937                 unlock_page(page);
2938
2939                 if (rdata->result == 0)
2940                         cifs_readpage_to_fscache(rdata->mapping->host, page);
2941
2942                 page_cache_release(page);
2943                 rdata->pages[i] = NULL;
2944         }
2945         kref_put(&rdata->refcount, cifs_readdata_release);
2946 }
2947
2948 static int
2949 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
2950                         struct cifs_readdata *rdata, unsigned int len)
2951 {
2952         int total_read = 0, result = 0;
2953         unsigned int i;
2954         u64 eof;
2955         pgoff_t eof_index;
2956         unsigned int nr_pages = rdata->nr_pages;
2957         struct kvec iov;
2958
2959         /* determine the eof that the server (probably) has */
2960         eof = CIFS_I(rdata->mapping->host)->server_eof;
2961         eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
2962         cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
2963
2964         rdata->tailsz = PAGE_CACHE_SIZE;
2965         for (i = 0; i < nr_pages; i++) {
2966                 struct page *page = rdata->pages[i];
2967
2968                 if (len >= PAGE_CACHE_SIZE) {
2969                         /* enough data to fill the page */
2970                         iov.iov_base = kmap(page);
2971                         iov.iov_len = PAGE_CACHE_SIZE;
2972                         cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2973                                 i, page->index, iov.iov_base, iov.iov_len);
2974                         len -= PAGE_CACHE_SIZE;
2975                 } else if (len > 0) {
2976                         /* enough for partial page, fill and zero the rest */
2977                         iov.iov_base = kmap(page);
2978                         iov.iov_len = len;
2979                         cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2980                                 i, page->index, iov.iov_base, iov.iov_len);
2981                         memset(iov.iov_base + len,
2982                                 '\0', PAGE_CACHE_SIZE - len);
2983                         rdata->tailsz = len;
2984                         len = 0;
2985                 } else if (page->index > eof_index) {
2986                         /*
2987                          * The VFS will not try to do readahead past the
2988                          * i_size, but it's possible that we have outstanding
2989                          * writes with gaps in the middle and the i_size hasn't
2990                          * caught up yet. Populate those with zeroed out pages
2991                          * to prevent the VFS from repeatedly attempting to
2992                          * fill them until the writes are flushed.
2993                          */
2994                         zero_user(page, 0, PAGE_CACHE_SIZE);
2995                         lru_cache_add_file(page);
2996                         flush_dcache_page(page);
2997                         SetPageUptodate(page);
2998                         unlock_page(page);
2999                         page_cache_release(page);
3000                         rdata->pages[i] = NULL;
3001                         rdata->nr_pages--;
3002                         continue;
3003                 } else {
3004                         /* no need to hold page hostage */
3005                         lru_cache_add_file(page);
3006                         unlock_page(page);
3007                         page_cache_release(page);
3008                         rdata->pages[i] = NULL;
3009                         rdata->nr_pages--;
3010                         continue;
3011                 }
3012
3013                 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
3014                 kunmap(page);
3015                 if (result < 0)
3016                         break;
3017
3018                 total_read += result;
3019         }
3020
3021         return total_read > 0 ? total_read : result;
3022 }
3023
3024 static int cifs_readpages(struct file *file, struct address_space *mapping,
3025         struct list_head *page_list, unsigned num_pages)
3026 {
3027         int rc;
3028         struct list_head tmplist;
3029         struct cifsFileInfo *open_file = file->private_data;
3030         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
3031         unsigned int rsize = cifs_sb->rsize;
3032         pid_t pid;
3033
3034         /*
3035          * Give up immediately if rsize is too small to read an entire page.
3036          * The VFS will fall back to readpage. We should never reach this
3037          * point however since we set ra_pages to 0 when the rsize is smaller
3038          * than a cache page.
3039          */
3040         if (unlikely(rsize < PAGE_CACHE_SIZE))
3041                 return 0;
3042
3043         /*
3044          * Reads as many pages as possible from fscache. Returns -ENOBUFS
3045          * immediately if the cookie is negative
3046          */
3047         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3048                                          &num_pages);
3049         if (rc == 0)
3050                 return rc;
3051
3052         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3053                 pid = open_file->pid;
3054         else
3055                 pid = current->tgid;
3056
3057         rc = 0;
3058         INIT_LIST_HEAD(&tmplist);
3059
3060         cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
3061                 mapping, num_pages);
3062
3063         /*
3064          * Start with the page at end of list and move it to private
3065          * list. Do the same with any following pages until we hit
3066          * the rsize limit, hit an index discontinuity, or run out of
3067          * pages. Issue the async read and then start the loop again
3068          * until the list is empty.
3069          *
3070          * Note that list order is important. The page_list is in
3071          * the order of declining indexes. When we put the pages in
3072          * the rdata->pages, then we want them in increasing order.
3073          */
3074         while (!list_empty(page_list)) {
3075                 unsigned int i;
3076                 unsigned int bytes = PAGE_CACHE_SIZE;
3077                 unsigned int expected_index;
3078                 unsigned int nr_pages = 1;
3079                 loff_t offset;
3080                 struct page *page, *tpage;
3081                 struct cifs_readdata *rdata;
3082
3083                 page = list_entry(page_list->prev, struct page, lru);
3084
3085                 /*
3086                  * Lock the page and put it in the cache. Since no one else
3087                  * should have access to this page, we're safe to simply set
3088                  * PG_locked without checking it first.
3089                  */
3090                 __set_page_locked(page);
3091                 rc = add_to_page_cache_locked(page, mapping,
3092                                               page->index, GFP_KERNEL);
3093
3094                 /* give up if we can't stick it in the cache */
3095                 if (rc) {
3096                         __clear_page_locked(page);
3097                         break;
3098                 }
3099
3100                 /* move first page to the tmplist */
3101                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3102                 list_move_tail(&page->lru, &tmplist);
3103
3104                 /* now try and add more pages onto the request */
3105                 expected_index = page->index + 1;
3106                 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3107                         /* discontinuity ? */
3108                         if (page->index != expected_index)
3109                                 break;
3110
3111                         /* would this page push the read over the rsize? */
3112                         if (bytes + PAGE_CACHE_SIZE > rsize)
3113                                 break;
3114
3115                         __set_page_locked(page);
3116                         if (add_to_page_cache_locked(page, mapping,
3117                                                 page->index, GFP_KERNEL)) {
3118                                 __clear_page_locked(page);
3119                                 break;
3120                         }
3121                         list_move_tail(&page->lru, &tmplist);
3122                         bytes += PAGE_CACHE_SIZE;
3123                         expected_index++;
3124                         nr_pages++;
3125                 }
3126
3127                 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3128                 if (!rdata) {
3129                         /* best to give up if we're out of mem */
3130                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3131                                 list_del(&page->lru);
3132                                 lru_cache_add_file(page);
3133                                 unlock_page(page);
3134                                 page_cache_release(page);
3135                         }
3136                         rc = -ENOMEM;
3137                         break;
3138                 }
3139
3140                 rdata->cfile = cifsFileInfo_get(open_file);
3141                 rdata->mapping = mapping;
3142                 rdata->offset = offset;
3143                 rdata->bytes = bytes;
3144                 rdata->pid = pid;
3145                 rdata->pagesz = PAGE_CACHE_SIZE;
3146                 rdata->read_into_pages = cifs_readpages_read_into_pages;
3147
3148                 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3149                         list_del(&page->lru);
3150                         rdata->pages[rdata->nr_pages++] = page;
3151                 }
3152
3153                 rc = cifs_retry_async_readv(rdata);
3154                 if (rc != 0) {
3155                         for (i = 0; i < rdata->nr_pages; i++) {
3156                                 page = rdata->pages[i];
3157                                 lru_cache_add_file(page);
3158                                 unlock_page(page);
3159                                 page_cache_release(page);
3160                         }
3161                         kref_put(&rdata->refcount, cifs_readdata_release);
3162                         break;
3163                 }
3164
3165                 kref_put(&rdata->refcount, cifs_readdata_release);
3166         }
3167
3168         return rc;
3169 }
3170
3171 static int cifs_readpage_worker(struct file *file, struct page *page,
3172         loff_t *poffset)
3173 {
3174         char *read_data;
3175         int rc;
3176
3177         /* Is the page cached? */
3178         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
3179         if (rc == 0)
3180                 goto read_complete;
3181
3182         page_cache_get(page);
3183         read_data = kmap(page);
3184         /* for reads over a certain size could initiate async read ahead */
3185
3186         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
3187
3188         if (rc < 0)
3189                 goto io_error;
3190         else
3191                 cFYI(1, "Bytes read %d", rc);
3192
3193         file->f_path.dentry->d_inode->i_atime =
3194                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
3195
3196         if (PAGE_CACHE_SIZE > rc)
3197                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3198
3199         flush_dcache_page(page);
3200         SetPageUptodate(page);
3201
3202         /* send this page to the cache */
3203         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
3204
3205         rc = 0;
3206
3207 io_error:
3208         kunmap(page);
3209         page_cache_release(page);
3210
3211 read_complete:
3212         return rc;
3213 }
3214
3215 static int cifs_readpage(struct file *file, struct page *page)
3216 {
3217         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3218         int rc = -EACCES;
3219         unsigned int xid;
3220
3221         xid = get_xid();
3222
3223         if (file->private_data == NULL) {
3224                 rc = -EBADF;
3225                 free_xid(xid);
3226                 return rc;
3227         }
3228
3229         cFYI(1, "readpage %p at offset %d 0x%x",
3230                  page, (int)offset, (int)offset);
3231
3232         rc = cifs_readpage_worker(file, page, &offset);
3233
3234         unlock_page(page);
3235
3236         free_xid(xid);
3237         return rc;
3238 }
3239
3240 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3241 {
3242         struct cifsFileInfo *open_file;
3243
3244         spin_lock(&cifs_file_list_lock);
3245         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3246                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3247                         spin_unlock(&cifs_file_list_lock);
3248                         return 1;
3249                 }
3250         }
3251         spin_unlock(&cifs_file_list_lock);
3252         return 0;
3253 }
3254
3255 /* We do not want to update the file size from server for inodes
3256    open for write - to avoid races with writepage extending
3257    the file - in the future we could consider allowing
3258    refreshing the inode only on increases in the file size
3259    but this is tricky to do without racing with writebehind
3260    page caching in the current Linux kernel design */
3261 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3262 {
3263         if (!cifsInode)
3264                 return true;
3265
3266         if (is_inode_writable(cifsInode)) {
3267                 /* This inode is open for write at least once */
3268                 struct cifs_sb_info *cifs_sb;
3269
3270                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3271                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3272                         /* since no page cache to corrupt on directio
3273                         we can change size safely */
3274                         return true;
3275                 }
3276
3277                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3278                         return true;
3279
3280                 return false;
3281         } else
3282                 return true;
3283 }
3284
3285 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3286                         loff_t pos, unsigned len, unsigned flags,
3287                         struct page **pagep, void **fsdata)
3288 {
3289         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3290         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
3291         loff_t page_start = pos & PAGE_MASK;
3292         loff_t i_size;
3293         struct page *page;
3294         int rc = 0;
3295
3296         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
3297
3298         page = grab_cache_page_write_begin(mapping, index, flags);
3299         if (!page) {
3300                 rc = -ENOMEM;
3301                 goto out;
3302         }
3303
3304         if (PageUptodate(page))
3305                 goto out;
3306
3307         /*
3308          * If we write a full page it will be up to date, no need to read from
3309          * the server. If the write is short, we'll end up doing a sync write
3310          * instead.
3311          */
3312         if (len == PAGE_CACHE_SIZE)
3313                 goto out;
3314
3315         /*
3316          * optimize away the read when we have an oplock, and we're not
3317          * expecting to use any of the data we'd be reading in. That
3318          * is, when the page lies beyond the EOF, or straddles the EOF
3319          * and the write will cover all of the existing data.
3320          */
3321         if (CIFS_I(mapping->host)->clientCanCacheRead) {
3322                 i_size = i_size_read(mapping->host);
3323                 if (page_start >= i_size ||
3324                     (offset == 0 && (pos + len) >= i_size)) {
3325                         zero_user_segments(page, 0, offset,
3326                                            offset + len,
3327                                            PAGE_CACHE_SIZE);
3328                         /*
3329                          * PageChecked means that the parts of the page
3330                          * to which we're not writing are considered up
3331                          * to date. Once the data is copied to the
3332                          * page, it can be set uptodate.
3333                          */
3334                         SetPageChecked(page);
3335                         goto out;
3336                 }
3337         }
3338
3339         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
3340                 /*
3341                  * might as well read a page, it is fast enough. If we get
3342                  * an error, we don't need to return it. cifs_write_end will
3343                  * do a sync write instead since PG_uptodate isn't set.
3344                  */
3345                 cifs_readpage_worker(file, page, &page_start);
3346         } else {
3347                 /* we could try using another file handle if there is one -
3348                    but how would we lock it to prevent close of that handle
3349                    racing with this read? In any case
3350                    this will be written out by write_end so is fine */
3351         }
3352 out:
3353         *pagep = page;
3354         return rc;
3355 }
3356
3357 static int cifs_release_page(struct page *page, gfp_t gfp)
3358 {
3359         if (PagePrivate(page))
3360                 return 0;
3361
3362         return cifs_fscache_release_page(page, gfp);
3363 }
3364
3365 static void cifs_invalidate_page(struct page *page, unsigned long offset)
3366 {
3367         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3368
3369         if (offset == 0)
3370                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3371 }
3372
3373 static int cifs_launder_page(struct page *page)
3374 {
3375         int rc = 0;
3376         loff_t range_start = page_offset(page);
3377         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3378         struct writeback_control wbc = {
3379                 .sync_mode = WB_SYNC_ALL,
3380                 .nr_to_write = 0,
3381                 .range_start = range_start,
3382                 .range_end = range_end,
3383         };
3384
3385         cFYI(1, "Launder page: %p", page);
3386
3387         if (clear_page_dirty_for_io(page))
3388                 rc = cifs_writepage_locked(page, &wbc);
3389
3390         cifs_fscache_invalidate_page(page, page->mapping->host);
3391         return rc;
3392 }
3393
3394 void cifs_oplock_break(struct work_struct *work)
3395 {
3396         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3397                                                   oplock_break);
3398         struct inode *inode = cfile->dentry->d_inode;
3399         struct cifsInodeInfo *cinode = CIFS_I(inode);
3400         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3401         int rc = 0;
3402
3403         if (inode && S_ISREG(inode->i_mode)) {
3404                 if (cinode->clientCanCacheRead)
3405                         break_lease(inode, O_RDONLY);
3406                 else
3407                         break_lease(inode, O_WRONLY);
3408                 rc = filemap_fdatawrite(inode->i_mapping);
3409                 if (cinode->clientCanCacheRead == 0) {
3410                         rc = filemap_fdatawait(inode->i_mapping);
3411                         mapping_set_error(inode->i_mapping, rc);
3412                         invalidate_remote_inode(inode);
3413                 }
3414                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
3415         }
3416
3417         rc = cifs_push_locks(cfile);
3418         if (rc)
3419                 cERROR(1, "Push locks rc = %d", rc);
3420
3421         /*
3422          * releasing stale oplock after recent reconnect of smb session using
3423          * a now incorrect file handle is not a data integrity issue but do
3424          * not bother sending an oplock release if session to server still is
3425          * disconnected since oplock already released by the server
3426          */
3427         if (!cfile->oplock_break_cancelled) {
3428                 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3429                                                              cinode);
3430                 cFYI(1, "Oplock release rc = %d", rc);
3431         }
3432 }
3433
3434 const struct address_space_operations cifs_addr_ops = {
3435         .readpage = cifs_readpage,
3436         .readpages = cifs_readpages,
3437         .writepage = cifs_writepage,
3438         .writepages = cifs_writepages,
3439         .write_begin = cifs_write_begin,
3440         .write_end = cifs_write_end,
3441         .set_page_dirty = __set_page_dirty_nobuffers,
3442         .releasepage = cifs_release_page,
3443         .invalidatepage = cifs_invalidate_page,
3444         .launder_page = cifs_launder_page,
3445 };
3446
3447 /*
3448  * cifs_readpages requires the server to support a buffer large enough to
3449  * contain the header plus one complete page of data.  Otherwise, we need
3450  * to leave cifs_readpages out of the address space operations.
3451  */
3452 const struct address_space_operations cifs_addr_ops_smallbuf = {
3453         .readpage = cifs_readpage,
3454         .writepage = cifs_writepage,
3455         .writepages = cifs_writepages,
3456         .write_begin = cifs_write_begin,
3457         .write_end = cifs_write_end,
3458         .set_page_dirty = __set_page_dirty_nobuffers,
3459         .releasepage = cifs_release_page,
3460         .invalidatepage = cifs_invalidate_page,
3461         .launder_page = cifs_launder_page,
3462 };