CIFS: Remove extra mutex_unlock in cifs_lock_add_if
[sfrench/cifs-2.6.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, 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 *poplock,
173              __u16 *pnetfid, int xid)
174 {
175         int rc;
176         int desiredAccess;
177         int disposition;
178         int create_options = CREATE_NOT_DIR;
179         FILE_ALL_INFO *buf;
180
181         desiredAccess = cifs_convert_flags(f_flags);
182
183 /*********************************************************************
184  *  open flag mapping table:
185  *
186  *      POSIX Flag            CIFS Disposition
187  *      ----------            ----------------
188  *      O_CREAT               FILE_OPEN_IF
189  *      O_CREAT | O_EXCL      FILE_CREATE
190  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
191  *      O_TRUNC               FILE_OVERWRITE
192  *      none of the above     FILE_OPEN
193  *
194  *      Note that there is not a direct match between disposition
195  *      FILE_SUPERSEDE (ie create whether or not file exists although
196  *      O_CREAT | O_TRUNC is similar but truncates the existing
197  *      file rather than creating a new file as FILE_SUPERSEDE does
198  *      (which uses the attributes / metadata passed in on open call)
199  *?
200  *?  O_SYNC is a reasonable match to CIFS writethrough flag
201  *?  and the read write flags match reasonably.  O_LARGEFILE
202  *?  is irrelevant because largefile support is always used
203  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
204  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
205  *********************************************************************/
206
207         disposition = cifs_get_disposition(f_flags);
208
209         /* BB pass O_SYNC flag through on file attributes .. BB */
210
211         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
212         if (!buf)
213                 return -ENOMEM;
214
215         if (backup_cred(cifs_sb))
216                 create_options |= CREATE_OPEN_BACKUP_INTENT;
217
218         if (tcon->ses->capabilities & CAP_NT_SMBS)
219                 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
220                          desiredAccess, create_options, pnetfid, poplock, buf,
221                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
222                                  & CIFS_MOUNT_MAP_SPECIAL_CHR);
223         else
224                 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
225                         desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
226                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
227                                 & CIFS_MOUNT_MAP_SPECIAL_CHR);
228
229         if (rc)
230                 goto out;
231
232         if (tcon->unix_ext)
233                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
234                                               xid);
235         else
236                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
237                                          xid, pnetfid);
238
239 out:
240         kfree(buf);
241         return rc;
242 }
243
244 struct cifsFileInfo *
245 cifs_new_fileinfo(__u16 fileHandle, struct file *file,
246                   struct tcon_link *tlink, __u32 oplock)
247 {
248         struct dentry *dentry = file->f_path.dentry;
249         struct inode *inode = dentry->d_inode;
250         struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
251         struct cifsFileInfo *pCifsFile;
252
253         pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
254         if (pCifsFile == NULL)
255                 return pCifsFile;
256
257         pCifsFile->count = 1;
258         pCifsFile->netfid = fileHandle;
259         pCifsFile->pid = current->tgid;
260         pCifsFile->uid = current_fsuid();
261         pCifsFile->dentry = dget(dentry);
262         pCifsFile->f_flags = file->f_flags;
263         pCifsFile->invalidHandle = false;
264         pCifsFile->tlink = cifs_get_tlink(tlink);
265         mutex_init(&pCifsFile->fh_mutex);
266         INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
267
268         spin_lock(&cifs_file_list_lock);
269         list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
270         /* if readable file instance put first in list*/
271         if (file->f_mode & FMODE_READ)
272                 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
273         else
274                 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
275         spin_unlock(&cifs_file_list_lock);
276
277         cifs_set_oplock_level(pCifsInode, oplock);
278         pCifsInode->can_cache_brlcks = pCifsInode->clientCanCacheAll;
279
280         file->private_data = pCifsFile;
281         return pCifsFile;
282 }
283
284 static void cifs_del_lock_waiters(struct cifsLockInfo *lock);
285
286 /*
287  * Release a reference on the file private data. This may involve closing
288  * the filehandle out on the server. Must be called without holding
289  * cifs_file_list_lock.
290  */
291 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
292 {
293         struct inode *inode = cifs_file->dentry->d_inode;
294         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
295         struct cifsInodeInfo *cifsi = CIFS_I(inode);
296         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
297         struct cifsLockInfo *li, *tmp;
298
299         spin_lock(&cifs_file_list_lock);
300         if (--cifs_file->count > 0) {
301                 spin_unlock(&cifs_file_list_lock);
302                 return;
303         }
304
305         /* remove it from the lists */
306         list_del(&cifs_file->flist);
307         list_del(&cifs_file->tlist);
308
309         if (list_empty(&cifsi->openFileList)) {
310                 cFYI(1, "closing last open instance for inode %p",
311                         cifs_file->dentry->d_inode);
312
313                 /* in strict cache mode we need invalidate mapping on the last
314                    close  because it may cause a error when we open this file
315                    again and get at least level II oplock */
316                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
317                         CIFS_I(inode)->invalid_mapping = true;
318
319                 cifs_set_oplock_level(cifsi, 0);
320         }
321         spin_unlock(&cifs_file_list_lock);
322
323         cancel_work_sync(&cifs_file->oplock_break);
324
325         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
326                 int xid, rc;
327
328                 xid = GetXid();
329                 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
330                 FreeXid(xid);
331         }
332
333         /* Delete any outstanding lock records. We'll lose them when the file
334          * is closed anyway.
335          */
336         mutex_lock(&cifsi->lock_mutex);
337         list_for_each_entry_safe(li, tmp, &cifsi->llist, llist) {
338                 if (li->netfid != cifs_file->netfid)
339                         continue;
340                 list_del(&li->llist);
341                 cifs_del_lock_waiters(li);
342                 kfree(li);
343         }
344         mutex_unlock(&cifsi->lock_mutex);
345
346         cifs_put_tlink(cifs_file->tlink);
347         dput(cifs_file->dentry);
348         kfree(cifs_file);
349 }
350
351 int cifs_open(struct inode *inode, struct file *file)
352 {
353         int rc = -EACCES;
354         int xid;
355         __u32 oplock;
356         struct cifs_sb_info *cifs_sb;
357         struct cifs_tcon *tcon;
358         struct tcon_link *tlink;
359         struct cifsFileInfo *pCifsFile = NULL;
360         char *full_path = NULL;
361         bool posix_open_ok = false;
362         __u16 netfid;
363
364         xid = GetXid();
365
366         cifs_sb = CIFS_SB(inode->i_sb);
367         tlink = cifs_sb_tlink(cifs_sb);
368         if (IS_ERR(tlink)) {
369                 FreeXid(xid);
370                 return PTR_ERR(tlink);
371         }
372         tcon = tlink_tcon(tlink);
373
374         full_path = build_path_from_dentry(file->f_path.dentry);
375         if (full_path == NULL) {
376                 rc = -ENOMEM;
377                 goto out;
378         }
379
380         cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
381                  inode, file->f_flags, full_path);
382
383         if (enable_oplocks)
384                 oplock = REQ_OPLOCK;
385         else
386                 oplock = 0;
387
388         if (!tcon->broken_posix_open && tcon->unix_ext &&
389             (tcon->ses->capabilities & CAP_UNIX) &&
390             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
391                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
392                 /* can not refresh inode info since size could be stale */
393                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
394                                 cifs_sb->mnt_file_mode /* ignored */,
395                                 file->f_flags, &oplock, &netfid, xid);
396                 if (rc == 0) {
397                         cFYI(1, "posix open succeeded");
398                         posix_open_ok = true;
399                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
400                         if (tcon->ses->serverNOS)
401                                 cERROR(1, "server %s of type %s returned"
402                                            " unexpected error on SMB posix open"
403                                            ", disabling posix open support."
404                                            " Check if server update available.",
405                                            tcon->ses->serverName,
406                                            tcon->ses->serverNOS);
407                         tcon->broken_posix_open = true;
408                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
409                          (rc != -EOPNOTSUPP)) /* path not found or net err */
410                         goto out;
411                 /* else fallthrough to retry open the old way on network i/o
412                    or DFS errors */
413         }
414
415         if (!posix_open_ok) {
416                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
417                                   file->f_flags, &oplock, &netfid, xid);
418                 if (rc)
419                         goto out;
420         }
421
422         pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
423         if (pCifsFile == NULL) {
424                 CIFSSMBClose(xid, tcon, netfid);
425                 rc = -ENOMEM;
426                 goto out;
427         }
428
429         cifs_fscache_set_inode_cookie(inode, file);
430
431         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
432                 /* time to set mode which we can not set earlier due to
433                    problems creating new read-only files */
434                 struct cifs_unix_set_info_args args = {
435                         .mode   = inode->i_mode,
436                         .uid    = NO_CHANGE_64,
437                         .gid    = NO_CHANGE_64,
438                         .ctime  = NO_CHANGE_64,
439                         .atime  = NO_CHANGE_64,
440                         .mtime  = NO_CHANGE_64,
441                         .device = 0,
442                 };
443                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
444                                         pCifsFile->pid);
445         }
446
447 out:
448         kfree(full_path);
449         FreeXid(xid);
450         cifs_put_tlink(tlink);
451         return rc;
452 }
453
454 /* Try to reacquire byte range locks that were released when session */
455 /* to server was lost */
456 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
457 {
458         int rc = 0;
459
460 /* BB list all locks open on this file and relock */
461
462         return rc;
463 }
464
465 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
466 {
467         int rc = -EACCES;
468         int xid;
469         __u32 oplock;
470         struct cifs_sb_info *cifs_sb;
471         struct cifs_tcon *tcon;
472         struct cifsInodeInfo *pCifsInode;
473         struct inode *inode;
474         char *full_path = NULL;
475         int desiredAccess;
476         int disposition = FILE_OPEN;
477         int create_options = CREATE_NOT_DIR;
478         __u16 netfid;
479
480         xid = GetXid();
481         mutex_lock(&pCifsFile->fh_mutex);
482         if (!pCifsFile->invalidHandle) {
483                 mutex_unlock(&pCifsFile->fh_mutex);
484                 rc = 0;
485                 FreeXid(xid);
486                 return rc;
487         }
488
489         inode = pCifsFile->dentry->d_inode;
490         cifs_sb = CIFS_SB(inode->i_sb);
491         tcon = tlink_tcon(pCifsFile->tlink);
492
493 /* can not grab rename sem here because various ops, including
494    those that already have the rename sem can end up causing writepage
495    to get called and if the server was down that means we end up here,
496    and we can never tell if the caller already has the rename_sem */
497         full_path = build_path_from_dentry(pCifsFile->dentry);
498         if (full_path == NULL) {
499                 rc = -ENOMEM;
500                 mutex_unlock(&pCifsFile->fh_mutex);
501                 FreeXid(xid);
502                 return rc;
503         }
504
505         cFYI(1, "inode = 0x%p file flags 0x%x for %s",
506                  inode, pCifsFile->f_flags, full_path);
507
508         if (enable_oplocks)
509                 oplock = REQ_OPLOCK;
510         else
511                 oplock = 0;
512
513         if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
514             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
515                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
516
517                 /*
518                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
519                  * original open. Must mask them off for a reopen.
520                  */
521                 unsigned int oflags = pCifsFile->f_flags &
522                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
523
524                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
525                                 cifs_sb->mnt_file_mode /* ignored */,
526                                 oflags, &oplock, &netfid, xid);
527                 if (rc == 0) {
528                         cFYI(1, "posix reopen succeeded");
529                         goto reopen_success;
530                 }
531                 /* fallthrough to retry open the old way on errors, especially
532                    in the reconnect path it is important to retry hard */
533         }
534
535         desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
536
537         if (backup_cred(cifs_sb))
538                 create_options |= CREATE_OPEN_BACKUP_INTENT;
539
540         /* Can not refresh inode by passing in file_info buf to be returned
541            by SMBOpen and then calling get_inode_info with returned buf
542            since file might have write behind data that needs to be flushed
543            and server version of file size can be stale. If we knew for sure
544            that inode was not dirty locally we could do this */
545
546         rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
547                          create_options, &netfid, &oplock, NULL,
548                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
549                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
550         if (rc) {
551                 mutex_unlock(&pCifsFile->fh_mutex);
552                 cFYI(1, "cifs_open returned 0x%x", rc);
553                 cFYI(1, "oplock: %d", oplock);
554                 goto reopen_error_exit;
555         }
556
557 reopen_success:
558         pCifsFile->netfid = netfid;
559         pCifsFile->invalidHandle = false;
560         mutex_unlock(&pCifsFile->fh_mutex);
561         pCifsInode = CIFS_I(inode);
562
563         if (can_flush) {
564                 rc = filemap_write_and_wait(inode->i_mapping);
565                 mapping_set_error(inode->i_mapping, rc);
566
567                 if (tcon->unix_ext)
568                         rc = cifs_get_inode_info_unix(&inode,
569                                 full_path, inode->i_sb, xid);
570                 else
571                         rc = cifs_get_inode_info(&inode,
572                                 full_path, NULL, inode->i_sb,
573                                 xid, NULL);
574         } /* else we are writing out data to server already
575              and could deadlock if we tried to flush data, and
576              since we do not know if we have data that would
577              invalidate the current end of file on the server
578              we can not go to the server to get the new inod
579              info */
580
581         cifs_set_oplock_level(pCifsInode, oplock);
582
583         cifs_relock_file(pCifsFile);
584
585 reopen_error_exit:
586         kfree(full_path);
587         FreeXid(xid);
588         return rc;
589 }
590
591 int cifs_close(struct inode *inode, struct file *file)
592 {
593         if (file->private_data != NULL) {
594                 cifsFileInfo_put(file->private_data);
595                 file->private_data = NULL;
596         }
597
598         /* return code from the ->release op is always ignored */
599         return 0;
600 }
601
602 int cifs_closedir(struct inode *inode, struct file *file)
603 {
604         int rc = 0;
605         int xid;
606         struct cifsFileInfo *pCFileStruct = file->private_data;
607         char *ptmp;
608
609         cFYI(1, "Closedir inode = 0x%p", inode);
610
611         xid = GetXid();
612
613         if (pCFileStruct) {
614                 struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
615
616                 cFYI(1, "Freeing private data in close dir");
617                 spin_lock(&cifs_file_list_lock);
618                 if (!pCFileStruct->srch_inf.endOfSearch &&
619                     !pCFileStruct->invalidHandle) {
620                         pCFileStruct->invalidHandle = true;
621                         spin_unlock(&cifs_file_list_lock);
622                         rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
623                         cFYI(1, "Closing uncompleted readdir with rc %d",
624                                  rc);
625                         /* not much we can do if it fails anyway, ignore rc */
626                         rc = 0;
627                 } else
628                         spin_unlock(&cifs_file_list_lock);
629                 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
630                 if (ptmp) {
631                         cFYI(1, "closedir free smb buf in srch struct");
632                         pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
633                         if (pCFileStruct->srch_inf.smallBuf)
634                                 cifs_small_buf_release(ptmp);
635                         else
636                                 cifs_buf_release(ptmp);
637                 }
638                 cifs_put_tlink(pCFileStruct->tlink);
639                 kfree(file->private_data);
640                 file->private_data = NULL;
641         }
642         /* BB can we lock the filestruct while this is going on? */
643         FreeXid(xid);
644         return rc;
645 }
646
647 static struct cifsLockInfo *
648 cifs_lock_init(__u64 len, __u64 offset, __u8 type, __u16 netfid)
649 {
650         struct cifsLockInfo *li =
651                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
652         if (!li)
653                 return li;
654         li->netfid = netfid;
655         li->offset = offset;
656         li->length = len;
657         li->type = type;
658         li->pid = current->tgid;
659         INIT_LIST_HEAD(&li->blist);
660         init_waitqueue_head(&li->block_q);
661         return li;
662 }
663
664 static void
665 cifs_del_lock_waiters(struct cifsLockInfo *lock)
666 {
667         struct cifsLockInfo *li, *tmp;
668         list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
669                 list_del_init(&li->blist);
670                 wake_up(&li->block_q);
671         }
672 }
673
674 static bool
675 cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset,
676                         __u64 length, __u8 type, __u16 netfid,
677                         struct cifsLockInfo **conf_lock)
678 {
679         struct cifsLockInfo *li, *tmp;
680
681         list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
682                 if (offset + length <= li->offset ||
683                     offset >= li->offset + li->length)
684                         continue;
685                 else if ((type & LOCKING_ANDX_SHARED_LOCK) &&
686                          ((netfid == li->netfid && current->tgid == li->pid) ||
687                           type == li->type))
688                         continue;
689                 else {
690                         *conf_lock = li;
691                         return true;
692                 }
693         }
694         return false;
695 }
696
697 static int
698 cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
699                __u8 type, __u16 netfid, struct file_lock *flock)
700 {
701         int rc = 0;
702         struct cifsLockInfo *conf_lock;
703         bool exist;
704
705         mutex_lock(&cinode->lock_mutex);
706
707         exist = cifs_find_lock_conflict(cinode, offset, length, type, netfid,
708                                         &conf_lock);
709         if (exist) {
710                 flock->fl_start = conf_lock->offset;
711                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
712                 flock->fl_pid = conf_lock->pid;
713                 if (conf_lock->type & LOCKING_ANDX_SHARED_LOCK)
714                         flock->fl_type = F_RDLCK;
715                 else
716                         flock->fl_type = F_WRLCK;
717         } else if (!cinode->can_cache_brlcks)
718                 rc = 1;
719         else
720                 flock->fl_type = F_UNLCK;
721
722         mutex_unlock(&cinode->lock_mutex);
723         return rc;
724 }
725
726 static int
727 cifs_lock_add(struct cifsInodeInfo *cinode, __u64 len, __u64 offset,
728               __u8 type, __u16 netfid)
729 {
730         struct cifsLockInfo *li;
731
732         li = cifs_lock_init(len, offset, type, netfid);
733         if (!li)
734                 return -ENOMEM;
735
736         mutex_lock(&cinode->lock_mutex);
737         list_add_tail(&li->llist, &cinode->llist);
738         mutex_unlock(&cinode->lock_mutex);
739         return 0;
740 }
741
742 static int
743 cifs_lock_add_if(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
744                  __u8 type, __u16 netfid, bool wait)
745 {
746         struct cifsLockInfo *lock, *conf_lock;
747         bool exist;
748         int rc = 0;
749
750         lock = cifs_lock_init(length, offset, type, netfid);
751         if (!lock)
752                 return -ENOMEM;
753
754 try_again:
755         exist = false;
756         mutex_lock(&cinode->lock_mutex);
757
758         exist = cifs_find_lock_conflict(cinode, offset, length, type, netfid,
759                                         &conf_lock);
760         if (!exist && cinode->can_cache_brlcks) {
761                 list_add_tail(&lock->llist, &cinode->llist);
762                 mutex_unlock(&cinode->lock_mutex);
763                 return rc;
764         }
765
766         if (!exist)
767                 rc = 1;
768         else if (!wait)
769                 rc = -EACCES;
770         else {
771                 list_add_tail(&lock->blist, &conf_lock->blist);
772                 mutex_unlock(&cinode->lock_mutex);
773                 rc = wait_event_interruptible(lock->block_q,
774                                         (lock->blist.prev == &lock->blist) &&
775                                         (lock->blist.next == &lock->blist));
776                 if (!rc)
777                         goto try_again;
778                 else {
779                         mutex_lock(&cinode->lock_mutex);
780                         list_del_init(&lock->blist);
781                 }
782         }
783
784         kfree(lock);
785         mutex_unlock(&cinode->lock_mutex);
786         return rc;
787 }
788
789 static int
790 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
791 {
792         int rc = 0;
793         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
794         unsigned char saved_type = flock->fl_type;
795
796         mutex_lock(&cinode->lock_mutex);
797         posix_test_lock(file, flock);
798
799         if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
800                 flock->fl_type = saved_type;
801                 rc = 1;
802         }
803
804         mutex_unlock(&cinode->lock_mutex);
805         return rc;
806 }
807
808 static int
809 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
810 {
811         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
812         int rc;
813
814         mutex_lock(&cinode->lock_mutex);
815         if (!cinode->can_cache_brlcks) {
816                 mutex_unlock(&cinode->lock_mutex);
817                 return 1;
818         }
819         rc = posix_lock_file_wait(file, flock);
820         mutex_unlock(&cinode->lock_mutex);
821         return rc;
822 }
823
824 static int
825 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
826 {
827         int xid, rc = 0, stored_rc;
828         struct cifsLockInfo *li, *tmp;
829         struct cifs_tcon *tcon;
830         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
831         unsigned int num, max_num;
832         LOCKING_ANDX_RANGE *buf, *cur;
833         int types[] = {LOCKING_ANDX_LARGE_FILES,
834                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
835         int i;
836
837         xid = GetXid();
838         tcon = tlink_tcon(cfile->tlink);
839
840         mutex_lock(&cinode->lock_mutex);
841         if (!cinode->can_cache_brlcks) {
842                 mutex_unlock(&cinode->lock_mutex);
843                 FreeXid(xid);
844                 return rc;
845         }
846
847         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
848                   sizeof(LOCKING_ANDX_RANGE);
849         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
850         if (!buf) {
851                 mutex_unlock(&cinode->lock_mutex);
852                 FreeXid(xid);
853                 return rc;
854         }
855
856         for (i = 0; i < 2; i++) {
857                 cur = buf;
858                 num = 0;
859                 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
860                         if (li->type != types[i])
861                                 continue;
862                         cur->Pid = cpu_to_le16(li->pid);
863                         cur->LengthLow = cpu_to_le32((u32)li->length);
864                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
865                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
866                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
867                         if (++num == max_num) {
868                                 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
869                                                        li->type, 0, num, buf);
870                                 if (stored_rc)
871                                         rc = stored_rc;
872                                 cur = buf;
873                                 num = 0;
874                         } else
875                                 cur++;
876                 }
877
878                 if (num) {
879                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
880                                                types[i], 0, num, buf);
881                         if (stored_rc)
882                                 rc = stored_rc;
883                 }
884         }
885
886         cinode->can_cache_brlcks = false;
887         mutex_unlock(&cinode->lock_mutex);
888
889         kfree(buf);
890         FreeXid(xid);
891         return rc;
892 }
893
894 /* copied from fs/locks.c with a name change */
895 #define cifs_for_each_lock(inode, lockp) \
896         for (lockp = &inode->i_flock; *lockp != NULL; \
897              lockp = &(*lockp)->fl_next)
898
899 static int
900 cifs_push_posix_locks(struct cifsFileInfo *cfile)
901 {
902         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
903         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
904         struct file_lock *flock, **before;
905         struct cifsLockInfo *lck, *tmp;
906         int rc = 0, xid, type;
907         __u64 length;
908         struct list_head locks_to_send;
909
910         xid = GetXid();
911
912         mutex_lock(&cinode->lock_mutex);
913         if (!cinode->can_cache_brlcks) {
914                 mutex_unlock(&cinode->lock_mutex);
915                 FreeXid(xid);
916                 return rc;
917         }
918
919         INIT_LIST_HEAD(&locks_to_send);
920
921         lock_flocks();
922         cifs_for_each_lock(cfile->dentry->d_inode, before) {
923                 flock = *before;
924                 length = 1 + flock->fl_end - flock->fl_start;
925                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
926                         type = CIFS_RDLCK;
927                 else
928                         type = CIFS_WRLCK;
929
930                 lck = cifs_lock_init(length, flock->fl_start, type,
931                                      cfile->netfid);
932                 if (!lck) {
933                         rc = -ENOMEM;
934                         goto send_locks;
935                 }
936                 lck->pid = flock->fl_pid;
937
938                 list_add_tail(&lck->llist, &locks_to_send);
939         }
940
941 send_locks:
942         unlock_flocks();
943
944         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
945                 struct file_lock tmp_lock;
946                 int stored_rc;
947
948                 tmp_lock.fl_start = lck->offset;
949                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
950                                              0, lck->length, &tmp_lock,
951                                              lck->type, 0);
952                 if (stored_rc)
953                         rc = stored_rc;
954                 list_del(&lck->llist);
955                 kfree(lck);
956         }
957
958         cinode->can_cache_brlcks = false;
959         mutex_unlock(&cinode->lock_mutex);
960
961         FreeXid(xid);
962         return rc;
963 }
964
965 static int
966 cifs_push_locks(struct cifsFileInfo *cfile)
967 {
968         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
969         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
970
971         if ((tcon->ses->capabilities & CAP_UNIX) &&
972             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
973             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
974                 return cifs_push_posix_locks(cfile);
975
976         return cifs_push_mandatory_locks(cfile);
977 }
978
979 static void
980 cifs_read_flock(struct file_lock *flock, __u8 *type, int *lock, int *unlock,
981                 bool *wait_flag)
982 {
983         if (flock->fl_flags & FL_POSIX)
984                 cFYI(1, "Posix");
985         if (flock->fl_flags & FL_FLOCK)
986                 cFYI(1, "Flock");
987         if (flock->fl_flags & FL_SLEEP) {
988                 cFYI(1, "Blocking lock");
989                 *wait_flag = true;
990         }
991         if (flock->fl_flags & FL_ACCESS)
992                 cFYI(1, "Process suspended by mandatory locking - "
993                         "not implemented yet");
994         if (flock->fl_flags & FL_LEASE)
995                 cFYI(1, "Lease on file - not implemented yet");
996         if (flock->fl_flags &
997             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
998                 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
999
1000         *type = LOCKING_ANDX_LARGE_FILES;
1001         if (flock->fl_type == F_WRLCK) {
1002                 cFYI(1, "F_WRLCK ");
1003                 *lock = 1;
1004         } else if (flock->fl_type == F_UNLCK) {
1005                 cFYI(1, "F_UNLCK");
1006                 *unlock = 1;
1007                 /* Check if unlock includes more than one lock range */
1008         } else if (flock->fl_type == F_RDLCK) {
1009                 cFYI(1, "F_RDLCK");
1010                 *type |= LOCKING_ANDX_SHARED_LOCK;
1011                 *lock = 1;
1012         } else if (flock->fl_type == F_EXLCK) {
1013                 cFYI(1, "F_EXLCK");
1014                 *lock = 1;
1015         } else if (flock->fl_type == F_SHLCK) {
1016                 cFYI(1, "F_SHLCK");
1017                 *type |= LOCKING_ANDX_SHARED_LOCK;
1018                 *lock = 1;
1019         } else
1020                 cFYI(1, "Unknown type of lock");
1021 }
1022
1023 static int
1024 cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
1025            bool wait_flag, bool posix_lck, int xid)
1026 {
1027         int rc = 0;
1028         __u64 length = 1 + flock->fl_end - flock->fl_start;
1029         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1030         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1031         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1032         __u16 netfid = cfile->netfid;
1033
1034         if (posix_lck) {
1035                 int posix_lock_type;
1036
1037                 rc = cifs_posix_lock_test(file, flock);
1038                 if (!rc)
1039                         return rc;
1040
1041                 if (type & LOCKING_ANDX_SHARED_LOCK)
1042                         posix_lock_type = CIFS_RDLCK;
1043                 else
1044                         posix_lock_type = CIFS_WRLCK;
1045                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1046                                       1 /* get */, length, flock,
1047                                       posix_lock_type, wait_flag);
1048                 return rc;
1049         }
1050
1051         rc = cifs_lock_test(cinode, flock->fl_start, length, type, netfid,
1052                             flock);
1053         if (!rc)
1054                 return rc;
1055
1056         /* BB we could chain these into one lock request BB */
1057         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1058                          flock->fl_start, 0, 1, type, 0, 0);
1059         if (rc == 0) {
1060                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1061                                  length, flock->fl_start, 1, 0,
1062                                  type, 0, 0);
1063                 flock->fl_type = F_UNLCK;
1064                 if (rc != 0)
1065                         cERROR(1, "Error unlocking previously locked "
1066                                    "range %d during test of lock", rc);
1067                 rc = 0;
1068                 return rc;
1069         }
1070
1071         if (type & LOCKING_ANDX_SHARED_LOCK) {
1072                 flock->fl_type = F_WRLCK;
1073                 rc = 0;
1074                 return rc;
1075         }
1076
1077         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1078                          flock->fl_start, 0, 1,
1079                          type | LOCKING_ANDX_SHARED_LOCK, 0, 0);
1080         if (rc == 0) {
1081                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1082                                  length, flock->fl_start, 1, 0,
1083                                  type | LOCKING_ANDX_SHARED_LOCK,
1084                                  0, 0);
1085                 flock->fl_type = F_RDLCK;
1086                 if (rc != 0)
1087                         cERROR(1, "Error unlocking previously locked "
1088                                   "range %d during test of lock", rc);
1089         } else
1090                 flock->fl_type = F_WRLCK;
1091
1092         rc = 0;
1093         return rc;
1094 }
1095
1096 static void
1097 cifs_move_llist(struct list_head *source, struct list_head *dest)
1098 {
1099         struct list_head *li, *tmp;
1100         list_for_each_safe(li, tmp, source)
1101                 list_move(li, dest);
1102 }
1103
1104 static void
1105 cifs_free_llist(struct list_head *llist)
1106 {
1107         struct cifsLockInfo *li, *tmp;
1108         list_for_each_entry_safe(li, tmp, llist, llist) {
1109                 cifs_del_lock_waiters(li);
1110                 list_del(&li->llist);
1111                 kfree(li);
1112         }
1113 }
1114
1115 static int
1116 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1117 {
1118         int rc = 0, stored_rc;
1119         int types[] = {LOCKING_ANDX_LARGE_FILES,
1120                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1121         unsigned int i;
1122         unsigned int max_num, num;
1123         LOCKING_ANDX_RANGE *buf, *cur;
1124         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1125         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1126         struct cifsLockInfo *li, *tmp;
1127         __u64 length = 1 + flock->fl_end - flock->fl_start;
1128         struct list_head tmp_llist;
1129
1130         INIT_LIST_HEAD(&tmp_llist);
1131
1132         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1133                   sizeof(LOCKING_ANDX_RANGE);
1134         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1135         if (!buf)
1136                 return -ENOMEM;
1137
1138         mutex_lock(&cinode->lock_mutex);
1139         for (i = 0; i < 2; i++) {
1140                 cur = buf;
1141                 num = 0;
1142                 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
1143                         if (flock->fl_start > li->offset ||
1144                             (flock->fl_start + length) <
1145                             (li->offset + li->length))
1146                                 continue;
1147                         if (current->tgid != li->pid)
1148                                 continue;
1149                         if (cfile->netfid != li->netfid)
1150                                 continue;
1151                         if (types[i] != li->type)
1152                                 continue;
1153                         if (!cinode->can_cache_brlcks) {
1154                                 cur->Pid = cpu_to_le16(li->pid);
1155                                 cur->LengthLow = cpu_to_le32((u32)li->length);
1156                                 cur->LengthHigh =
1157                                         cpu_to_le32((u32)(li->length>>32));
1158                                 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1159                                 cur->OffsetHigh =
1160                                         cpu_to_le32((u32)(li->offset>>32));
1161                                 /*
1162                                  * We need to save a lock here to let us add
1163                                  * it again to the inode list if the unlock
1164                                  * range request fails on the server.
1165                                  */
1166                                 list_move(&li->llist, &tmp_llist);
1167                                 if (++num == max_num) {
1168                                         stored_rc = cifs_lockv(xid, tcon,
1169                                                                cfile->netfid,
1170                                                                li->type, num,
1171                                                                0, buf);
1172                                         if (stored_rc) {
1173                                                 /*
1174                                                  * We failed on the unlock range
1175                                                  * request - add all locks from
1176                                                  * the tmp list to the head of
1177                                                  * the inode list.
1178                                                  */
1179                                                 cifs_move_llist(&tmp_llist,
1180                                                                 &cinode->llist);
1181                                                 rc = stored_rc;
1182                                         } else
1183                                                 /*
1184                                                  * The unlock range request
1185                                                  * succeed - free the tmp list.
1186                                                  */
1187                                                 cifs_free_llist(&tmp_llist);
1188                                         cur = buf;
1189                                         num = 0;
1190                                 } else
1191                                         cur++;
1192                         } else {
1193                                 /*
1194                                  * We can cache brlock requests - simply remove
1195                                  * a lock from the inode list.
1196                                  */
1197                                 list_del(&li->llist);
1198                                 cifs_del_lock_waiters(li);
1199                                 kfree(li);
1200                         }
1201                 }
1202                 if (num) {
1203                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1204                                                types[i], num, 0, buf);
1205                         if (stored_rc) {
1206                                 cifs_move_llist(&tmp_llist, &cinode->llist);
1207                                 rc = stored_rc;
1208                         } else
1209                                 cifs_free_llist(&tmp_llist);
1210                 }
1211         }
1212
1213         mutex_unlock(&cinode->lock_mutex);
1214         kfree(buf);
1215         return rc;
1216 }
1217
1218 static int
1219 cifs_setlk(struct file *file,  struct file_lock *flock, __u8 type,
1220            bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1221 {
1222         int rc = 0;
1223         __u64 length = 1 + flock->fl_end - flock->fl_start;
1224         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1225         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1226         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
1227         __u16 netfid = cfile->netfid;
1228
1229         if (posix_lck) {
1230                 int posix_lock_type;
1231
1232                 rc = cifs_posix_lock_set(file, flock);
1233                 if (!rc || rc < 0)
1234                         return rc;
1235
1236                 if (type & LOCKING_ANDX_SHARED_LOCK)
1237                         posix_lock_type = CIFS_RDLCK;
1238                 else
1239                         posix_lock_type = CIFS_WRLCK;
1240
1241                 if (unlock == 1)
1242                         posix_lock_type = CIFS_UNLCK;
1243
1244                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1245                                       0 /* set */, length, flock,
1246                                       posix_lock_type, wait_flag);
1247                 goto out;
1248         }
1249
1250         if (lock) {
1251                 rc = cifs_lock_add_if(cinode, flock->fl_start, length,
1252                                       type, netfid, wait_flag);
1253                 if (rc < 0)
1254                         return rc;
1255                 else if (!rc)
1256                         goto out;
1257
1258                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1259                                  flock->fl_start, 0, 1, type, wait_flag, 0);
1260                 if (rc == 0) {
1261                         /* For Windows locks we must store them. */
1262                         rc = cifs_lock_add(cinode, length, flock->fl_start,
1263                                            type, netfid);
1264                 }
1265         } else if (unlock)
1266                 rc = cifs_unlock_range(cfile, flock, xid);
1267
1268 out:
1269         if (flock->fl_flags & FL_POSIX)
1270                 posix_lock_file_wait(file, flock);
1271         return rc;
1272 }
1273
1274 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1275 {
1276         int rc, xid;
1277         int lock = 0, unlock = 0;
1278         bool wait_flag = false;
1279         bool posix_lck = false;
1280         struct cifs_sb_info *cifs_sb;
1281         struct cifs_tcon *tcon;
1282         struct cifsInodeInfo *cinode;
1283         struct cifsFileInfo *cfile;
1284         __u16 netfid;
1285         __u8 type;
1286
1287         rc = -EACCES;
1288         xid = GetXid();
1289
1290         cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1291                 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1292                 flock->fl_start, flock->fl_end);
1293
1294         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag);
1295
1296         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1297         cfile = (struct cifsFileInfo *)file->private_data;
1298         tcon = tlink_tcon(cfile->tlink);
1299         netfid = cfile->netfid;
1300         cinode = CIFS_I(file->f_path.dentry->d_inode);
1301
1302         if ((tcon->ses->capabilities & CAP_UNIX) &&
1303             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1304             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1305                 posix_lck = true;
1306         /*
1307          * BB add code here to normalize offset and length to account for
1308          * negative length which we can not accept over the wire.
1309          */
1310         if (IS_GETLK(cmd)) {
1311                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1312                 FreeXid(xid);
1313                 return rc;
1314         }
1315
1316         if (!lock && !unlock) {
1317                 /*
1318                  * if no lock or unlock then nothing to do since we do not
1319                  * know what it is
1320                  */
1321                 FreeXid(xid);
1322                 return -EOPNOTSUPP;
1323         }
1324
1325         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1326                         xid);
1327         FreeXid(xid);
1328         return rc;
1329 }
1330
1331 /* update the file size (if needed) after a write */
1332 void
1333 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1334                       unsigned int bytes_written)
1335 {
1336         loff_t end_of_write = offset + bytes_written;
1337
1338         if (end_of_write > cifsi->server_eof)
1339                 cifsi->server_eof = end_of_write;
1340 }
1341
1342 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
1343                           const char *write_data, size_t write_size,
1344                           loff_t *poffset)
1345 {
1346         int rc = 0;
1347         unsigned int bytes_written = 0;
1348         unsigned int total_written;
1349         struct cifs_sb_info *cifs_sb;
1350         struct cifs_tcon *pTcon;
1351         int xid;
1352         struct dentry *dentry = open_file->dentry;
1353         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1354         struct cifs_io_parms io_parms;
1355
1356         cifs_sb = CIFS_SB(dentry->d_sb);
1357
1358         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1359            *poffset, dentry->d_name.name);
1360
1361         pTcon = tlink_tcon(open_file->tlink);
1362
1363         xid = GetXid();
1364
1365         for (total_written = 0; write_size > total_written;
1366              total_written += bytes_written) {
1367                 rc = -EAGAIN;
1368                 while (rc == -EAGAIN) {
1369                         struct kvec iov[2];
1370                         unsigned int len;
1371
1372                         if (open_file->invalidHandle) {
1373                                 /* we could deadlock if we called
1374                                    filemap_fdatawait from here so tell
1375                                    reopen_file not to flush data to
1376                                    server now */
1377                                 rc = cifs_reopen_file(open_file, false);
1378                                 if (rc != 0)
1379                                         break;
1380                         }
1381
1382                         len = min((size_t)cifs_sb->wsize,
1383                                   write_size - total_written);
1384                         /* iov[0] is reserved for smb header */
1385                         iov[1].iov_base = (char *)write_data + total_written;
1386                         iov[1].iov_len = len;
1387                         io_parms.netfid = open_file->netfid;
1388                         io_parms.pid = pid;
1389                         io_parms.tcon = pTcon;
1390                         io_parms.offset = *poffset;
1391                         io_parms.length = len;
1392                         rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1393                                            1, 0);
1394                 }
1395                 if (rc || (bytes_written == 0)) {
1396                         if (total_written)
1397                                 break;
1398                         else {
1399                                 FreeXid(xid);
1400                                 return rc;
1401                         }
1402                 } else {
1403                         cifs_update_eof(cifsi, *poffset, bytes_written);
1404                         *poffset += bytes_written;
1405                 }
1406         }
1407
1408         cifs_stats_bytes_written(pTcon, total_written);
1409
1410         if (total_written > 0) {
1411                 spin_lock(&dentry->d_inode->i_lock);
1412                 if (*poffset > dentry->d_inode->i_size)
1413                         i_size_write(dentry->d_inode, *poffset);
1414                 spin_unlock(&dentry->d_inode->i_lock);
1415         }
1416         mark_inode_dirty_sync(dentry->d_inode);
1417         FreeXid(xid);
1418         return total_written;
1419 }
1420
1421 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1422                                         bool fsuid_only)
1423 {
1424         struct cifsFileInfo *open_file = NULL;
1425         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1426
1427         /* only filter by fsuid on multiuser mounts */
1428         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1429                 fsuid_only = false;
1430
1431         spin_lock(&cifs_file_list_lock);
1432         /* we could simply get the first_list_entry since write-only entries
1433            are always at the end of the list but since the first entry might
1434            have a close pending, we go through the whole list */
1435         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1436                 if (fsuid_only && open_file->uid != current_fsuid())
1437                         continue;
1438                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1439                         if (!open_file->invalidHandle) {
1440                                 /* found a good file */
1441                                 /* lock it so it will not be closed on us */
1442                                 cifsFileInfo_get(open_file);
1443                                 spin_unlock(&cifs_file_list_lock);
1444                                 return open_file;
1445                         } /* else might as well continue, and look for
1446                              another, or simply have the caller reopen it
1447                              again rather than trying to fix this handle */
1448                 } else /* write only file */
1449                         break; /* write only files are last so must be done */
1450         }
1451         spin_unlock(&cifs_file_list_lock);
1452         return NULL;
1453 }
1454
1455 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1456                                         bool fsuid_only)
1457 {
1458         struct cifsFileInfo *open_file;
1459         struct cifs_sb_info *cifs_sb;
1460         bool any_available = false;
1461         int rc;
1462
1463         /* Having a null inode here (because mapping->host was set to zero by
1464         the VFS or MM) should not happen but we had reports of on oops (due to
1465         it being zero) during stress testcases so we need to check for it */
1466
1467         if (cifs_inode == NULL) {
1468                 cERROR(1, "Null inode passed to cifs_writeable_file");
1469                 dump_stack();
1470                 return NULL;
1471         }
1472
1473         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1474
1475         /* only filter by fsuid on multiuser mounts */
1476         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1477                 fsuid_only = false;
1478
1479         spin_lock(&cifs_file_list_lock);
1480 refind_writable:
1481         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1482                 if (!any_available && open_file->pid != current->tgid)
1483                         continue;
1484                 if (fsuid_only && open_file->uid != current_fsuid())
1485                         continue;
1486                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1487                         cifsFileInfo_get(open_file);
1488
1489                         if (!open_file->invalidHandle) {
1490                                 /* found a good writable file */
1491                                 spin_unlock(&cifs_file_list_lock);
1492                                 return open_file;
1493                         }
1494
1495                         spin_unlock(&cifs_file_list_lock);
1496
1497                         /* Had to unlock since following call can block */
1498                         rc = cifs_reopen_file(open_file, false);
1499                         if (!rc)
1500                                 return open_file;
1501
1502                         /* if it fails, try another handle if possible */
1503                         cFYI(1, "wp failed on reopen file");
1504                         cifsFileInfo_put(open_file);
1505
1506                         spin_lock(&cifs_file_list_lock);
1507
1508                         /* else we simply continue to the next entry. Thus
1509                            we do not loop on reopen errors.  If we
1510                            can not reopen the file, for example if we
1511                            reconnected to a server with another client
1512                            racing to delete or lock the file we would not
1513                            make progress if we restarted before the beginning
1514                            of the loop here. */
1515                 }
1516         }
1517         /* couldn't find useable FH with same pid, try any available */
1518         if (!any_available) {
1519                 any_available = true;
1520                 goto refind_writable;
1521         }
1522         spin_unlock(&cifs_file_list_lock);
1523         return NULL;
1524 }
1525
1526 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1527 {
1528         struct address_space *mapping = page->mapping;
1529         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1530         char *write_data;
1531         int rc = -EFAULT;
1532         int bytes_written = 0;
1533         struct inode *inode;
1534         struct cifsFileInfo *open_file;
1535
1536         if (!mapping || !mapping->host)
1537                 return -EFAULT;
1538
1539         inode = page->mapping->host;
1540
1541         offset += (loff_t)from;
1542         write_data = kmap(page);
1543         write_data += from;
1544
1545         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1546                 kunmap(page);
1547                 return -EIO;
1548         }
1549
1550         /* racing with truncate? */
1551         if (offset > mapping->host->i_size) {
1552                 kunmap(page);
1553                 return 0; /* don't care */
1554         }
1555
1556         /* check to make sure that we are not extending the file */
1557         if (mapping->host->i_size - offset < (loff_t)to)
1558                 to = (unsigned)(mapping->host->i_size - offset);
1559
1560         open_file = find_writable_file(CIFS_I(mapping->host), false);
1561         if (open_file) {
1562                 bytes_written = cifs_write(open_file, open_file->pid,
1563                                            write_data, to - from, &offset);
1564                 cifsFileInfo_put(open_file);
1565                 /* Does mm or vfs already set times? */
1566                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1567                 if ((bytes_written > 0) && (offset))
1568                         rc = 0;
1569                 else if (bytes_written < 0)
1570                         rc = bytes_written;
1571         } else {
1572                 cFYI(1, "No writeable filehandles for inode");
1573                 rc = -EIO;
1574         }
1575
1576         kunmap(page);
1577         return rc;
1578 }
1579
1580 static int cifs_writepages(struct address_space *mapping,
1581                            struct writeback_control *wbc)
1582 {
1583         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1584         bool done = false, scanned = false, range_whole = false;
1585         pgoff_t end, index;
1586         struct cifs_writedata *wdata;
1587         struct page *page;
1588         int rc = 0;
1589
1590         /*
1591          * If wsize is smaller than the page cache size, default to writing
1592          * one page at a time via cifs_writepage
1593          */
1594         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1595                 return generic_writepages(mapping, wbc);
1596
1597         if (wbc->range_cyclic) {
1598                 index = mapping->writeback_index; /* Start from prev offset */
1599                 end = -1;
1600         } else {
1601                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1602                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1603                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1604                         range_whole = true;
1605                 scanned = true;
1606         }
1607 retry:
1608         while (!done && index <= end) {
1609                 unsigned int i, nr_pages, found_pages;
1610                 pgoff_t next = 0, tofind;
1611                 struct page **pages;
1612
1613                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1614                                 end - index) + 1;
1615
1616                 wdata = cifs_writedata_alloc((unsigned int)tofind);
1617                 if (!wdata) {
1618                         rc = -ENOMEM;
1619                         break;
1620                 }
1621
1622                 /*
1623                  * find_get_pages_tag seems to return a max of 256 on each
1624                  * iteration, so we must call it several times in order to
1625                  * fill the array or the wsize is effectively limited to
1626                  * 256 * PAGE_CACHE_SIZE.
1627                  */
1628                 found_pages = 0;
1629                 pages = wdata->pages;
1630                 do {
1631                         nr_pages = find_get_pages_tag(mapping, &index,
1632                                                         PAGECACHE_TAG_DIRTY,
1633                                                         tofind, pages);
1634                         found_pages += nr_pages;
1635                         tofind -= nr_pages;
1636                         pages += nr_pages;
1637                 } while (nr_pages && tofind && index <= end);
1638
1639                 if (found_pages == 0) {
1640                         kref_put(&wdata->refcount, cifs_writedata_release);
1641                         break;
1642                 }
1643
1644                 nr_pages = 0;
1645                 for (i = 0; i < found_pages; i++) {
1646                         page = wdata->pages[i];
1647                         /*
1648                          * At this point we hold neither mapping->tree_lock nor
1649                          * lock on the page itself: the page may be truncated or
1650                          * invalidated (changing page->mapping to NULL), or even
1651                          * swizzled back from swapper_space to tmpfs file
1652                          * mapping
1653                          */
1654
1655                         if (nr_pages == 0)
1656                                 lock_page(page);
1657                         else if (!trylock_page(page))
1658                                 break;
1659
1660                         if (unlikely(page->mapping != mapping)) {
1661                                 unlock_page(page);
1662                                 break;
1663                         }
1664
1665                         if (!wbc->range_cyclic && page->index > end) {
1666                                 done = true;
1667                                 unlock_page(page);
1668                                 break;
1669                         }
1670
1671                         if (next && (page->index != next)) {
1672                                 /* Not next consecutive page */
1673                                 unlock_page(page);
1674                                 break;
1675                         }
1676
1677                         if (wbc->sync_mode != WB_SYNC_NONE)
1678                                 wait_on_page_writeback(page);
1679
1680                         if (PageWriteback(page) ||
1681                                         !clear_page_dirty_for_io(page)) {
1682                                 unlock_page(page);
1683                                 break;
1684                         }
1685
1686                         /*
1687                          * This actually clears the dirty bit in the radix tree.
1688                          * See cifs_writepage() for more commentary.
1689                          */
1690                         set_page_writeback(page);
1691
1692                         if (page_offset(page) >= mapping->host->i_size) {
1693                                 done = true;
1694                                 unlock_page(page);
1695                                 end_page_writeback(page);
1696                                 break;
1697                         }
1698
1699                         wdata->pages[i] = page;
1700                         next = page->index + 1;
1701                         ++nr_pages;
1702                 }
1703
1704                 /* reset index to refind any pages skipped */
1705                 if (nr_pages == 0)
1706                         index = wdata->pages[0]->index + 1;
1707
1708                 /* put any pages we aren't going to use */
1709                 for (i = nr_pages; i < found_pages; i++) {
1710                         page_cache_release(wdata->pages[i]);
1711                         wdata->pages[i] = NULL;
1712                 }
1713
1714                 /* nothing to write? */
1715                 if (nr_pages == 0) {
1716                         kref_put(&wdata->refcount, cifs_writedata_release);
1717                         continue;
1718                 }
1719
1720                 wdata->sync_mode = wbc->sync_mode;
1721                 wdata->nr_pages = nr_pages;
1722                 wdata->offset = page_offset(wdata->pages[0]);
1723
1724                 do {
1725                         if (wdata->cfile != NULL)
1726                                 cifsFileInfo_put(wdata->cfile);
1727                         wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1728                                                           false);
1729                         if (!wdata->cfile) {
1730                                 cERROR(1, "No writable handles for inode");
1731                                 rc = -EBADF;
1732                                 break;
1733                         }
1734                         rc = cifs_async_writev(wdata);
1735                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1736
1737                 for (i = 0; i < nr_pages; ++i)
1738                         unlock_page(wdata->pages[i]);
1739
1740                 /* send failure -- clean up the mess */
1741                 if (rc != 0) {
1742                         for (i = 0; i < nr_pages; ++i) {
1743                                 if (rc == -EAGAIN)
1744                                         redirty_page_for_writepage(wbc,
1745                                                            wdata->pages[i]);
1746                                 else
1747                                         SetPageError(wdata->pages[i]);
1748                                 end_page_writeback(wdata->pages[i]);
1749                                 page_cache_release(wdata->pages[i]);
1750                         }
1751                         if (rc != -EAGAIN)
1752                                 mapping_set_error(mapping, rc);
1753                 }
1754                 kref_put(&wdata->refcount, cifs_writedata_release);
1755
1756                 wbc->nr_to_write -= nr_pages;
1757                 if (wbc->nr_to_write <= 0)
1758                         done = true;
1759
1760                 index = next;
1761         }
1762
1763         if (!scanned && !done) {
1764                 /*
1765                  * We hit the last page and there is more work to be done: wrap
1766                  * back to the start of the file
1767                  */
1768                 scanned = true;
1769                 index = 0;
1770                 goto retry;
1771         }
1772
1773         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1774                 mapping->writeback_index = index;
1775
1776         return rc;
1777 }
1778
1779 static int
1780 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1781 {
1782         int rc;
1783         int xid;
1784
1785         xid = GetXid();
1786 /* BB add check for wbc flags */
1787         page_cache_get(page);
1788         if (!PageUptodate(page))
1789                 cFYI(1, "ppw - page not up to date");
1790
1791         /*
1792          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1793          *
1794          * A writepage() implementation always needs to do either this,
1795          * or re-dirty the page with "redirty_page_for_writepage()" in
1796          * the case of a failure.
1797          *
1798          * Just unlocking the page will cause the radix tree tag-bits
1799          * to fail to update with the state of the page correctly.
1800          */
1801         set_page_writeback(page);
1802 retry_write:
1803         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1804         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1805                 goto retry_write;
1806         else if (rc == -EAGAIN)
1807                 redirty_page_for_writepage(wbc, page);
1808         else if (rc != 0)
1809                 SetPageError(page);
1810         else
1811                 SetPageUptodate(page);
1812         end_page_writeback(page);
1813         page_cache_release(page);
1814         FreeXid(xid);
1815         return rc;
1816 }
1817
1818 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1819 {
1820         int rc = cifs_writepage_locked(page, wbc);
1821         unlock_page(page);
1822         return rc;
1823 }
1824
1825 static int cifs_write_end(struct file *file, struct address_space *mapping,
1826                         loff_t pos, unsigned len, unsigned copied,
1827                         struct page *page, void *fsdata)
1828 {
1829         int rc;
1830         struct inode *inode = mapping->host;
1831         struct cifsFileInfo *cfile = file->private_data;
1832         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1833         __u32 pid;
1834
1835         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1836                 pid = cfile->pid;
1837         else
1838                 pid = current->tgid;
1839
1840         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1841                  page, pos, copied);
1842
1843         if (PageChecked(page)) {
1844                 if (copied == len)
1845                         SetPageUptodate(page);
1846                 ClearPageChecked(page);
1847         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1848                 SetPageUptodate(page);
1849
1850         if (!PageUptodate(page)) {
1851                 char *page_data;
1852                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1853                 int xid;
1854
1855                 xid = GetXid();
1856                 /* this is probably better than directly calling
1857                    partialpage_write since in this function the file handle is
1858                    known which we might as well leverage */
1859                 /* BB check if anything else missing out of ppw
1860                    such as updating last write time */
1861                 page_data = kmap(page);
1862                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1863                 /* if (rc < 0) should we set writebehind rc? */
1864                 kunmap(page);
1865
1866                 FreeXid(xid);
1867         } else {
1868                 rc = copied;
1869                 pos += copied;
1870                 set_page_dirty(page);
1871         }
1872
1873         if (rc > 0) {
1874                 spin_lock(&inode->i_lock);
1875                 if (pos > inode->i_size)
1876                         i_size_write(inode, pos);
1877                 spin_unlock(&inode->i_lock);
1878         }
1879
1880         unlock_page(page);
1881         page_cache_release(page);
1882
1883         return rc;
1884 }
1885
1886 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1887                       int datasync)
1888 {
1889         int xid;
1890         int rc = 0;
1891         struct cifs_tcon *tcon;
1892         struct cifsFileInfo *smbfile = file->private_data;
1893         struct inode *inode = file->f_path.dentry->d_inode;
1894         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1895
1896         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1897         if (rc)
1898                 return rc;
1899         mutex_lock(&inode->i_mutex);
1900
1901         xid = GetXid();
1902
1903         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1904                 file->f_path.dentry->d_name.name, datasync);
1905
1906         if (!CIFS_I(inode)->clientCanCacheRead) {
1907                 rc = cifs_invalidate_mapping(inode);
1908                 if (rc) {
1909                         cFYI(1, "rc: %d during invalidate phase", rc);
1910                         rc = 0; /* don't care about it in fsync */
1911                 }
1912         }
1913
1914         tcon = tlink_tcon(smbfile->tlink);
1915         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1916                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1917
1918         FreeXid(xid);
1919         mutex_unlock(&inode->i_mutex);
1920         return rc;
1921 }
1922
1923 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1924 {
1925         int xid;
1926         int rc = 0;
1927         struct cifs_tcon *tcon;
1928         struct cifsFileInfo *smbfile = file->private_data;
1929         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1930         struct inode *inode = file->f_mapping->host;
1931
1932         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1933         if (rc)
1934                 return rc;
1935         mutex_lock(&inode->i_mutex);
1936
1937         xid = GetXid();
1938
1939         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1940                 file->f_path.dentry->d_name.name, datasync);
1941
1942         tcon = tlink_tcon(smbfile->tlink);
1943         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1944                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1945
1946         FreeXid(xid);
1947         mutex_unlock(&inode->i_mutex);
1948         return rc;
1949 }
1950
1951 /*
1952  * As file closes, flush all cached write data for this inode checking
1953  * for write behind errors.
1954  */
1955 int cifs_flush(struct file *file, fl_owner_t id)
1956 {
1957         struct inode *inode = file->f_path.dentry->d_inode;
1958         int rc = 0;
1959
1960         if (file->f_mode & FMODE_WRITE)
1961                 rc = filemap_write_and_wait(inode->i_mapping);
1962
1963         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1964
1965         return rc;
1966 }
1967
1968 static int
1969 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
1970 {
1971         int rc = 0;
1972         unsigned long i;
1973
1974         for (i = 0; i < num_pages; i++) {
1975                 pages[i] = alloc_page(__GFP_HIGHMEM);
1976                 if (!pages[i]) {
1977                         /*
1978                          * save number of pages we have already allocated and
1979                          * return with ENOMEM error
1980                          */
1981                         num_pages = i;
1982                         rc = -ENOMEM;
1983                         goto error;
1984                 }
1985         }
1986
1987         return rc;
1988
1989 error:
1990         for (i = 0; i < num_pages; i++)
1991                 put_page(pages[i]);
1992         return rc;
1993 }
1994
1995 static inline
1996 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
1997 {
1998         size_t num_pages;
1999         size_t clen;
2000
2001         clen = min_t(const size_t, len, wsize);
2002         num_pages = clen / PAGE_CACHE_SIZE;
2003         if (clen % PAGE_CACHE_SIZE)
2004                 num_pages++;
2005
2006         if (cur_len)
2007                 *cur_len = clen;
2008
2009         return num_pages;
2010 }
2011
2012 static ssize_t
2013 cifs_iovec_write(struct file *file, const struct iovec *iov,
2014                  unsigned long nr_segs, loff_t *poffset)
2015 {
2016         unsigned int written;
2017         unsigned long num_pages, npages, i;
2018         size_t copied, len, cur_len;
2019         ssize_t total_written = 0;
2020         struct kvec *to_send;
2021         struct page **pages;
2022         struct iov_iter it;
2023         struct inode *inode;
2024         struct cifsFileInfo *open_file;
2025         struct cifs_tcon *pTcon;
2026         struct cifs_sb_info *cifs_sb;
2027         struct cifs_io_parms io_parms;
2028         int xid, rc;
2029         __u32 pid;
2030
2031         len = iov_length(iov, nr_segs);
2032         if (!len)
2033                 return 0;
2034
2035         rc = generic_write_checks(file, poffset, &len, 0);
2036         if (rc)
2037                 return rc;
2038
2039         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2040         num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2041
2042         pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2043         if (!pages)
2044                 return -ENOMEM;
2045
2046         to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2047         if (!to_send) {
2048                 kfree(pages);
2049                 return -ENOMEM;
2050         }
2051
2052         rc = cifs_write_allocate_pages(pages, num_pages);
2053         if (rc) {
2054                 kfree(pages);
2055                 kfree(to_send);
2056                 return rc;
2057         }
2058
2059         xid = GetXid();
2060         open_file = file->private_data;
2061
2062         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2063                 pid = open_file->pid;
2064         else
2065                 pid = current->tgid;
2066
2067         pTcon = tlink_tcon(open_file->tlink);
2068         inode = file->f_path.dentry->d_inode;
2069
2070         iov_iter_init(&it, iov, nr_segs, len, 0);
2071         npages = num_pages;
2072
2073         do {
2074                 size_t save_len = cur_len;
2075                 for (i = 0; i < npages; i++) {
2076                         copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2077                         copied = iov_iter_copy_from_user(pages[i], &it, 0,
2078                                                          copied);
2079                         cur_len -= copied;
2080                         iov_iter_advance(&it, copied);
2081                         to_send[i+1].iov_base = kmap(pages[i]);
2082                         to_send[i+1].iov_len = copied;
2083                 }
2084
2085                 cur_len = save_len - cur_len;
2086
2087                 do {
2088                         if (open_file->invalidHandle) {
2089                                 rc = cifs_reopen_file(open_file, false);
2090                                 if (rc != 0)
2091                                         break;
2092                         }
2093                         io_parms.netfid = open_file->netfid;
2094                         io_parms.pid = pid;
2095                         io_parms.tcon = pTcon;
2096                         io_parms.offset = *poffset;
2097                         io_parms.length = cur_len;
2098                         rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2099                                            npages, 0);
2100                 } while (rc == -EAGAIN);
2101
2102                 for (i = 0; i < npages; i++)
2103                         kunmap(pages[i]);
2104
2105                 if (written) {
2106                         len -= written;
2107                         total_written += written;
2108                         cifs_update_eof(CIFS_I(inode), *poffset, written);
2109                         *poffset += written;
2110                 } else if (rc < 0) {
2111                         if (!total_written)
2112                                 total_written = rc;
2113                         break;
2114                 }
2115
2116                 /* get length and number of kvecs of the next write */
2117                 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2118         } while (len > 0);
2119
2120         if (total_written > 0) {
2121                 spin_lock(&inode->i_lock);
2122                 if (*poffset > inode->i_size)
2123                         i_size_write(inode, *poffset);
2124                 spin_unlock(&inode->i_lock);
2125         }
2126
2127         cifs_stats_bytes_written(pTcon, total_written);
2128         mark_inode_dirty_sync(inode);
2129
2130         for (i = 0; i < num_pages; i++)
2131                 put_page(pages[i]);
2132         kfree(to_send);
2133         kfree(pages);
2134         FreeXid(xid);
2135         return total_written;
2136 }
2137
2138 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2139                                 unsigned long nr_segs, loff_t pos)
2140 {
2141         ssize_t written;
2142         struct inode *inode;
2143
2144         inode = iocb->ki_filp->f_path.dentry->d_inode;
2145
2146         /*
2147          * BB - optimize the way when signing is disabled. We can drop this
2148          * extra memory-to-memory copying and use iovec buffers for constructing
2149          * write request.
2150          */
2151
2152         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2153         if (written > 0) {
2154                 CIFS_I(inode)->invalid_mapping = true;
2155                 iocb->ki_pos = pos;
2156         }
2157
2158         return written;
2159 }
2160
2161 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2162                            unsigned long nr_segs, loff_t pos)
2163 {
2164         struct inode *inode;
2165
2166         inode = iocb->ki_filp->f_path.dentry->d_inode;
2167
2168         if (CIFS_I(inode)->clientCanCacheAll)
2169                 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2170
2171         /*
2172          * In strict cache mode we need to write the data to the server exactly
2173          * from the pos to pos+len-1 rather than flush all affected pages
2174          * because it may cause a error with mandatory locks on these pages but
2175          * not on the region from pos to ppos+len-1.
2176          */
2177
2178         return cifs_user_writev(iocb, iov, nr_segs, pos);
2179 }
2180
2181 static ssize_t
2182 cifs_iovec_read(struct file *file, const struct iovec *iov,
2183                  unsigned long nr_segs, loff_t *poffset)
2184 {
2185         int rc;
2186         int xid;
2187         ssize_t total_read;
2188         unsigned int bytes_read = 0;
2189         size_t len, cur_len;
2190         int iov_offset = 0;
2191         struct cifs_sb_info *cifs_sb;
2192         struct cifs_tcon *pTcon;
2193         struct cifsFileInfo *open_file;
2194         struct smb_com_read_rsp *pSMBr;
2195         struct cifs_io_parms io_parms;
2196         char *read_data;
2197         unsigned int rsize;
2198         __u32 pid;
2199
2200         if (!nr_segs)
2201                 return 0;
2202
2203         len = iov_length(iov, nr_segs);
2204         if (!len)
2205                 return 0;
2206
2207         xid = GetXid();
2208         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2209
2210         /* FIXME: set up handlers for larger reads and/or convert to async */
2211         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2212
2213         open_file = file->private_data;
2214         pTcon = tlink_tcon(open_file->tlink);
2215
2216         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2217                 pid = open_file->pid;
2218         else
2219                 pid = current->tgid;
2220
2221         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2222                 cFYI(1, "attempting read on write only file instance");
2223
2224         for (total_read = 0; total_read < len; total_read += bytes_read) {
2225                 cur_len = min_t(const size_t, len - total_read, rsize);
2226                 rc = -EAGAIN;
2227                 read_data = NULL;
2228
2229                 while (rc == -EAGAIN) {
2230                         int buf_type = CIFS_NO_BUFFER;
2231                         if (open_file->invalidHandle) {
2232                                 rc = cifs_reopen_file(open_file, true);
2233                                 if (rc != 0)
2234                                         break;
2235                         }
2236                         io_parms.netfid = open_file->netfid;
2237                         io_parms.pid = pid;
2238                         io_parms.tcon = pTcon;
2239                         io_parms.offset = *poffset;
2240                         io_parms.length = cur_len;
2241                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2242                                          &read_data, &buf_type);
2243                         pSMBr = (struct smb_com_read_rsp *)read_data;
2244                         if (read_data) {
2245                                 char *data_offset = read_data + 4 +
2246                                                 le16_to_cpu(pSMBr->DataOffset);
2247                                 if (memcpy_toiovecend(iov, data_offset,
2248                                                       iov_offset, bytes_read))
2249                                         rc = -EFAULT;
2250                                 if (buf_type == CIFS_SMALL_BUFFER)
2251                                         cifs_small_buf_release(read_data);
2252                                 else if (buf_type == CIFS_LARGE_BUFFER)
2253                                         cifs_buf_release(read_data);
2254                                 read_data = NULL;
2255                                 iov_offset += bytes_read;
2256                         }
2257                 }
2258
2259                 if (rc || (bytes_read == 0)) {
2260                         if (total_read) {
2261                                 break;
2262                         } else {
2263                                 FreeXid(xid);
2264                                 return rc;
2265                         }
2266                 } else {
2267                         cifs_stats_bytes_read(pTcon, bytes_read);
2268                         *poffset += bytes_read;
2269                 }
2270         }
2271
2272         FreeXid(xid);
2273         return total_read;
2274 }
2275
2276 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2277                                unsigned long nr_segs, loff_t pos)
2278 {
2279         ssize_t read;
2280
2281         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2282         if (read > 0)
2283                 iocb->ki_pos = pos;
2284
2285         return read;
2286 }
2287
2288 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2289                           unsigned long nr_segs, loff_t pos)
2290 {
2291         struct inode *inode;
2292
2293         inode = iocb->ki_filp->f_path.dentry->d_inode;
2294
2295         if (CIFS_I(inode)->clientCanCacheRead)
2296                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2297
2298         /*
2299          * In strict cache mode we need to read from the server all the time
2300          * if we don't have level II oplock because the server can delay mtime
2301          * change - so we can't make a decision about inode invalidating.
2302          * And we can also fail with pagereading if there are mandatory locks
2303          * on pages affected by this read but not on the region from pos to
2304          * pos+len-1.
2305          */
2306
2307         return cifs_user_readv(iocb, iov, nr_segs, pos);
2308 }
2309
2310 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2311                          loff_t *poffset)
2312 {
2313         int rc = -EACCES;
2314         unsigned int bytes_read = 0;
2315         unsigned int total_read;
2316         unsigned int current_read_size;
2317         unsigned int rsize;
2318         struct cifs_sb_info *cifs_sb;
2319         struct cifs_tcon *pTcon;
2320         int xid;
2321         char *current_offset;
2322         struct cifsFileInfo *open_file;
2323         struct cifs_io_parms io_parms;
2324         int buf_type = CIFS_NO_BUFFER;
2325         __u32 pid;
2326
2327         xid = GetXid();
2328         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2329
2330         /* FIXME: set up handlers for larger reads and/or convert to async */
2331         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2332
2333         if (file->private_data == NULL) {
2334                 rc = -EBADF;
2335                 FreeXid(xid);
2336                 return rc;
2337         }
2338         open_file = file->private_data;
2339         pTcon = tlink_tcon(open_file->tlink);
2340
2341         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2342                 pid = open_file->pid;
2343         else
2344                 pid = current->tgid;
2345
2346         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2347                 cFYI(1, "attempting read on write only file instance");
2348
2349         for (total_read = 0, current_offset = read_data;
2350              read_size > total_read;
2351              total_read += bytes_read, current_offset += bytes_read) {
2352                 current_read_size = min_t(uint, read_size - total_read, rsize);
2353
2354                 /* For windows me and 9x we do not want to request more
2355                 than it negotiated since it will refuse the read then */
2356                 if ((pTcon->ses) &&
2357                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2358                         current_read_size = min_t(uint, current_read_size,
2359                                         CIFSMaxBufSize);
2360                 }
2361                 rc = -EAGAIN;
2362                 while (rc == -EAGAIN) {
2363                         if (open_file->invalidHandle) {
2364                                 rc = cifs_reopen_file(open_file, true);
2365                                 if (rc != 0)
2366                                         break;
2367                         }
2368                         io_parms.netfid = open_file->netfid;
2369                         io_parms.pid = pid;
2370                         io_parms.tcon = pTcon;
2371                         io_parms.offset = *poffset;
2372                         io_parms.length = current_read_size;
2373                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2374                                          &current_offset, &buf_type);
2375                 }
2376                 if (rc || (bytes_read == 0)) {
2377                         if (total_read) {
2378                                 break;
2379                         } else {
2380                                 FreeXid(xid);
2381                                 return rc;
2382                         }
2383                 } else {
2384                         cifs_stats_bytes_read(pTcon, total_read);
2385                         *poffset += bytes_read;
2386                 }
2387         }
2388         FreeXid(xid);
2389         return total_read;
2390 }
2391
2392 /*
2393  * If the page is mmap'ed into a process' page tables, then we need to make
2394  * sure that it doesn't change while being written back.
2395  */
2396 static int
2397 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2398 {
2399         struct page *page = vmf->page;
2400
2401         lock_page(page);
2402         return VM_FAULT_LOCKED;
2403 }
2404
2405 static struct vm_operations_struct cifs_file_vm_ops = {
2406         .fault = filemap_fault,
2407         .page_mkwrite = cifs_page_mkwrite,
2408 };
2409
2410 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2411 {
2412         int rc, xid;
2413         struct inode *inode = file->f_path.dentry->d_inode;
2414
2415         xid = GetXid();
2416
2417         if (!CIFS_I(inode)->clientCanCacheRead) {
2418                 rc = cifs_invalidate_mapping(inode);
2419                 if (rc)
2420                         return rc;
2421         }
2422
2423         rc = generic_file_mmap(file, vma);
2424         if (rc == 0)
2425                 vma->vm_ops = &cifs_file_vm_ops;
2426         FreeXid(xid);
2427         return rc;
2428 }
2429
2430 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2431 {
2432         int rc, xid;
2433
2434         xid = GetXid();
2435         rc = cifs_revalidate_file(file);
2436         if (rc) {
2437                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2438                 FreeXid(xid);
2439                 return rc;
2440         }
2441         rc = generic_file_mmap(file, vma);
2442         if (rc == 0)
2443                 vma->vm_ops = &cifs_file_vm_ops;
2444         FreeXid(xid);
2445         return rc;
2446 }
2447
2448 static int cifs_readpages(struct file *file, struct address_space *mapping,
2449         struct list_head *page_list, unsigned num_pages)
2450 {
2451         int rc;
2452         struct list_head tmplist;
2453         struct cifsFileInfo *open_file = file->private_data;
2454         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2455         unsigned int rsize = cifs_sb->rsize;
2456         pid_t pid;
2457
2458         /*
2459          * Give up immediately if rsize is too small to read an entire page.
2460          * The VFS will fall back to readpage. We should never reach this
2461          * point however since we set ra_pages to 0 when the rsize is smaller
2462          * than a cache page.
2463          */
2464         if (unlikely(rsize < PAGE_CACHE_SIZE))
2465                 return 0;
2466
2467         /*
2468          * Reads as many pages as possible from fscache. Returns -ENOBUFS
2469          * immediately if the cookie is negative
2470          */
2471         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2472                                          &num_pages);
2473         if (rc == 0)
2474                 return rc;
2475
2476         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2477                 pid = open_file->pid;
2478         else
2479                 pid = current->tgid;
2480
2481         rc = 0;
2482         INIT_LIST_HEAD(&tmplist);
2483
2484         cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2485                 mapping, num_pages);
2486
2487         /*
2488          * Start with the page at end of list and move it to private
2489          * list. Do the same with any following pages until we hit
2490          * the rsize limit, hit an index discontinuity, or run out of
2491          * pages. Issue the async read and then start the loop again
2492          * until the list is empty.
2493          *
2494          * Note that list order is important. The page_list is in
2495          * the order of declining indexes. When we put the pages in
2496          * the rdata->pages, then we want them in increasing order.
2497          */
2498         while (!list_empty(page_list)) {
2499                 unsigned int bytes = PAGE_CACHE_SIZE;
2500                 unsigned int expected_index;
2501                 unsigned int nr_pages = 1;
2502                 loff_t offset;
2503                 struct page *page, *tpage;
2504                 struct cifs_readdata *rdata;
2505
2506                 page = list_entry(page_list->prev, struct page, lru);
2507
2508                 /*
2509                  * Lock the page and put it in the cache. Since no one else
2510                  * should have access to this page, we're safe to simply set
2511                  * PG_locked without checking it first.
2512                  */
2513                 __set_page_locked(page);
2514                 rc = add_to_page_cache_locked(page, mapping,
2515                                               page->index, GFP_KERNEL);
2516
2517                 /* give up if we can't stick it in the cache */
2518                 if (rc) {
2519                         __clear_page_locked(page);
2520                         break;
2521                 }
2522
2523                 /* move first page to the tmplist */
2524                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2525                 list_move_tail(&page->lru, &tmplist);
2526
2527                 /* now try and add more pages onto the request */
2528                 expected_index = page->index + 1;
2529                 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2530                         /* discontinuity ? */
2531                         if (page->index != expected_index)
2532                                 break;
2533
2534                         /* would this page push the read over the rsize? */
2535                         if (bytes + PAGE_CACHE_SIZE > rsize)
2536                                 break;
2537
2538                         __set_page_locked(page);
2539                         if (add_to_page_cache_locked(page, mapping,
2540                                                 page->index, GFP_KERNEL)) {
2541                                 __clear_page_locked(page);
2542                                 break;
2543                         }
2544                         list_move_tail(&page->lru, &tmplist);
2545                         bytes += PAGE_CACHE_SIZE;
2546                         expected_index++;
2547                         nr_pages++;
2548                 }
2549
2550                 rdata = cifs_readdata_alloc(nr_pages);
2551                 if (!rdata) {
2552                         /* best to give up if we're out of mem */
2553                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2554                                 list_del(&page->lru);
2555                                 lru_cache_add_file(page);
2556                                 unlock_page(page);
2557                                 page_cache_release(page);
2558                         }
2559                         rc = -ENOMEM;
2560                         break;
2561                 }
2562
2563                 spin_lock(&cifs_file_list_lock);
2564                 cifsFileInfo_get(open_file);
2565                 spin_unlock(&cifs_file_list_lock);
2566                 rdata->cfile = open_file;
2567                 rdata->mapping = mapping;
2568                 rdata->offset = offset;
2569                 rdata->bytes = bytes;
2570                 rdata->pid = pid;
2571                 list_splice_init(&tmplist, &rdata->pages);
2572
2573                 do {
2574                         if (open_file->invalidHandle) {
2575                                 rc = cifs_reopen_file(open_file, true);
2576                                 if (rc != 0)
2577                                         continue;
2578                         }
2579                         rc = cifs_async_readv(rdata);
2580                 } while (rc == -EAGAIN);
2581
2582                 if (rc != 0) {
2583                         list_for_each_entry_safe(page, tpage, &rdata->pages,
2584                                                  lru) {
2585                                 list_del(&page->lru);
2586                                 lru_cache_add_file(page);
2587                                 unlock_page(page);
2588                                 page_cache_release(page);
2589                         }
2590                         cifs_readdata_free(rdata);
2591                         break;
2592                 }
2593         }
2594
2595         return rc;
2596 }
2597
2598 static int cifs_readpage_worker(struct file *file, struct page *page,
2599         loff_t *poffset)
2600 {
2601         char *read_data;
2602         int rc;
2603
2604         /* Is the page cached? */
2605         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2606         if (rc == 0)
2607                 goto read_complete;
2608
2609         page_cache_get(page);
2610         read_data = kmap(page);
2611         /* for reads over a certain size could initiate async read ahead */
2612
2613         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2614
2615         if (rc < 0)
2616                 goto io_error;
2617         else
2618                 cFYI(1, "Bytes read %d", rc);
2619
2620         file->f_path.dentry->d_inode->i_atime =
2621                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2622
2623         if (PAGE_CACHE_SIZE > rc)
2624                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2625
2626         flush_dcache_page(page);
2627         SetPageUptodate(page);
2628
2629         /* send this page to the cache */
2630         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2631
2632         rc = 0;
2633
2634 io_error:
2635         kunmap(page);
2636         page_cache_release(page);
2637
2638 read_complete:
2639         return rc;
2640 }
2641
2642 static int cifs_readpage(struct file *file, struct page *page)
2643 {
2644         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2645         int rc = -EACCES;
2646         int xid;
2647
2648         xid = GetXid();
2649
2650         if (file->private_data == NULL) {
2651                 rc = -EBADF;
2652                 FreeXid(xid);
2653                 return rc;
2654         }
2655
2656         cFYI(1, "readpage %p at offset %d 0x%x\n",
2657                  page, (int)offset, (int)offset);
2658
2659         rc = cifs_readpage_worker(file, page, &offset);
2660
2661         unlock_page(page);
2662
2663         FreeXid(xid);
2664         return rc;
2665 }
2666
2667 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2668 {
2669         struct cifsFileInfo *open_file;
2670
2671         spin_lock(&cifs_file_list_lock);
2672         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2673                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2674                         spin_unlock(&cifs_file_list_lock);
2675                         return 1;
2676                 }
2677         }
2678         spin_unlock(&cifs_file_list_lock);
2679         return 0;
2680 }
2681
2682 /* We do not want to update the file size from server for inodes
2683    open for write - to avoid races with writepage extending
2684    the file - in the future we could consider allowing
2685    refreshing the inode only on increases in the file size
2686    but this is tricky to do without racing with writebehind
2687    page caching in the current Linux kernel design */
2688 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2689 {
2690         if (!cifsInode)
2691                 return true;
2692
2693         if (is_inode_writable(cifsInode)) {
2694                 /* This inode is open for write at least once */
2695                 struct cifs_sb_info *cifs_sb;
2696
2697                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2698                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2699                         /* since no page cache to corrupt on directio
2700                         we can change size safely */
2701                         return true;
2702                 }
2703
2704                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2705                         return true;
2706
2707                 return false;
2708         } else
2709                 return true;
2710 }
2711
2712 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2713                         loff_t pos, unsigned len, unsigned flags,
2714                         struct page **pagep, void **fsdata)
2715 {
2716         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2717         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2718         loff_t page_start = pos & PAGE_MASK;
2719         loff_t i_size;
2720         struct page *page;
2721         int rc = 0;
2722
2723         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2724
2725         page = grab_cache_page_write_begin(mapping, index, flags);
2726         if (!page) {
2727                 rc = -ENOMEM;
2728                 goto out;
2729         }
2730
2731         if (PageUptodate(page))
2732                 goto out;
2733
2734         /*
2735          * If we write a full page it will be up to date, no need to read from
2736          * the server. If the write is short, we'll end up doing a sync write
2737          * instead.
2738          */
2739         if (len == PAGE_CACHE_SIZE)
2740                 goto out;
2741
2742         /*
2743          * optimize away the read when we have an oplock, and we're not
2744          * expecting to use any of the data we'd be reading in. That
2745          * is, when the page lies beyond the EOF, or straddles the EOF
2746          * and the write will cover all of the existing data.
2747          */
2748         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2749                 i_size = i_size_read(mapping->host);
2750                 if (page_start >= i_size ||
2751                     (offset == 0 && (pos + len) >= i_size)) {
2752                         zero_user_segments(page, 0, offset,
2753                                            offset + len,
2754                                            PAGE_CACHE_SIZE);
2755                         /*
2756                          * PageChecked means that the parts of the page
2757                          * to which we're not writing are considered up
2758                          * to date. Once the data is copied to the
2759                          * page, it can be set uptodate.
2760                          */
2761                         SetPageChecked(page);
2762                         goto out;
2763                 }
2764         }
2765
2766         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2767                 /*
2768                  * might as well read a page, it is fast enough. If we get
2769                  * an error, we don't need to return it. cifs_write_end will
2770                  * do a sync write instead since PG_uptodate isn't set.
2771                  */
2772                 cifs_readpage_worker(file, page, &page_start);
2773         } else {
2774                 /* we could try using another file handle if there is one -
2775                    but how would we lock it to prevent close of that handle
2776                    racing with this read? In any case
2777                    this will be written out by write_end so is fine */
2778         }
2779 out:
2780         *pagep = page;
2781         return rc;
2782 }
2783
2784 static int cifs_release_page(struct page *page, gfp_t gfp)
2785 {
2786         if (PagePrivate(page))
2787                 return 0;
2788
2789         return cifs_fscache_release_page(page, gfp);
2790 }
2791
2792 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2793 {
2794         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2795
2796         if (offset == 0)
2797                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2798 }
2799
2800 static int cifs_launder_page(struct page *page)
2801 {
2802         int rc = 0;
2803         loff_t range_start = page_offset(page);
2804         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2805         struct writeback_control wbc = {
2806                 .sync_mode = WB_SYNC_ALL,
2807                 .nr_to_write = 0,
2808                 .range_start = range_start,
2809                 .range_end = range_end,
2810         };
2811
2812         cFYI(1, "Launder page: %p", page);
2813
2814         if (clear_page_dirty_for_io(page))
2815                 rc = cifs_writepage_locked(page, &wbc);
2816
2817         cifs_fscache_invalidate_page(page, page->mapping->host);
2818         return rc;
2819 }
2820
2821 void cifs_oplock_break(struct work_struct *work)
2822 {
2823         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2824                                                   oplock_break);
2825         struct inode *inode = cfile->dentry->d_inode;
2826         struct cifsInodeInfo *cinode = CIFS_I(inode);
2827         int rc = 0;
2828
2829         if (inode && S_ISREG(inode->i_mode)) {
2830                 if (cinode->clientCanCacheRead)
2831                         break_lease(inode, O_RDONLY);
2832                 else
2833                         break_lease(inode, O_WRONLY);
2834                 rc = filemap_fdatawrite(inode->i_mapping);
2835                 if (cinode->clientCanCacheRead == 0) {
2836                         rc = filemap_fdatawait(inode->i_mapping);
2837                         mapping_set_error(inode->i_mapping, rc);
2838                         invalidate_remote_inode(inode);
2839                 }
2840                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2841         }
2842
2843         rc = cifs_push_locks(cfile);
2844         if (rc)
2845                 cERROR(1, "Push locks rc = %d", rc);
2846
2847         /*
2848          * releasing stale oplock after recent reconnect of smb session using
2849          * a now incorrect file handle is not a data integrity issue but do
2850          * not bother sending an oplock release if session to server still is
2851          * disconnected since oplock already released by the server
2852          */
2853         if (!cfile->oplock_break_cancelled) {
2854                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2855                                  current->tgid, 0, 0, 0, 0,
2856                                  LOCKING_ANDX_OPLOCK_RELEASE, false,
2857                                  cinode->clientCanCacheRead ? 1 : 0);
2858                 cFYI(1, "Oplock release rc = %d", rc);
2859         }
2860 }
2861
2862 const struct address_space_operations cifs_addr_ops = {
2863         .readpage = cifs_readpage,
2864         .readpages = cifs_readpages,
2865         .writepage = cifs_writepage,
2866         .writepages = cifs_writepages,
2867         .write_begin = cifs_write_begin,
2868         .write_end = cifs_write_end,
2869         .set_page_dirty = __set_page_dirty_nobuffers,
2870         .releasepage = cifs_release_page,
2871         .invalidatepage = cifs_invalidate_page,
2872         .launder_page = cifs_launder_page,
2873 };
2874
2875 /*
2876  * cifs_readpages requires the server to support a buffer large enough to
2877  * contain the header plus one complete page of data.  Otherwise, we need
2878  * to leave cifs_readpages out of the address space operations.
2879  */
2880 const struct address_space_operations cifs_addr_ops_smallbuf = {
2881         .readpage = cifs_readpage,
2882         .writepage = cifs_writepage,
2883         .writepages = cifs_writepages,
2884         .write_begin = cifs_write_begin,
2885         .write_end = cifs_write_end,
2886         .set_page_dirty = __set_page_dirty_nobuffers,
2887         .releasepage = cifs_release_page,
2888         .invalidatepage = cifs_invalidate_page,
2889         .launder_page = cifs_launder_page,
2890 };