8e02dbd88ae1b108494e0e6b6eb093cc1e13a74c
[linux-3.10.git] / fs / cifs / file.c
1 /*
2  *   fs/cifs/file.c
3  *
4  *   vfs operations that deal with files
5  *
6  *   Copyright (C) International Business Machines  Corp., 2002,2010
7  *   Author(s): Steve French (sfrench@us.ibm.com)
8  *              Jeremy Allison (jra@samba.org)
9  *
10  *   This library is free software; you can redistribute it and/or modify
11  *   it under the terms of the GNU Lesser General Public License as published
12  *   by the Free Software Foundation; either version 2.1 of the License, or
13  *   (at your option) any later version.
14  *
15  *   This library is distributed in the hope that it will be useful,
16  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
18  *   the GNU Lesser General Public License for more details.
19  *
20  *   You should have received a copy of the GNU Lesser General Public License
21  *   along with this library; if not, write to the Free Software
22  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23  */
24 #include <linux/fs.h>
25 #include <linux/backing-dev.h>
26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
28 #include <linux/pagemap.h>
29 #include <linux/pagevec.h>
30 #include <linux/writeback.h>
31 #include <linux/task_io_accounting_ops.h>
32 #include <linux/delay.h>
33 #include <linux/mount.h>
34 #include <linux/slab.h>
35 #include <linux/swap.h>
36 #include <asm/div64.h>
37 #include "cifsfs.h"
38 #include "cifspdu.h"
39 #include "cifsglob.h"
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
44 #include "fscache.h"
45
46 static inline int cifs_convert_flags(unsigned int flags)
47 {
48         if ((flags & O_ACCMODE) == O_RDONLY)
49                 return GENERIC_READ;
50         else if ((flags & O_ACCMODE) == O_WRONLY)
51                 return GENERIC_WRITE;
52         else if ((flags & O_ACCMODE) == O_RDWR) {
53                 /* GENERIC_ALL is too much permission to request
54                    can cause unnecessary access denied on create */
55                 /* return GENERIC_ALL; */
56                 return (GENERIC_READ | GENERIC_WRITE);
57         }
58
59         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
60                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
61                 FILE_READ_DATA);
62 }
63
64 static u32 cifs_posix_convert_flags(unsigned int flags)
65 {
66         u32 posix_flags = 0;
67
68         if ((flags & O_ACCMODE) == O_RDONLY)
69                 posix_flags = SMB_O_RDONLY;
70         else if ((flags & O_ACCMODE) == O_WRONLY)
71                 posix_flags = SMB_O_WRONLY;
72         else if ((flags & O_ACCMODE) == O_RDWR)
73                 posix_flags = SMB_O_RDWR;
74
75         if (flags & O_CREAT)
76                 posix_flags |= SMB_O_CREAT;
77         if (flags & O_EXCL)
78                 posix_flags |= SMB_O_EXCL;
79         if (flags & O_TRUNC)
80                 posix_flags |= SMB_O_TRUNC;
81         /* be safe and imply O_SYNC for O_DSYNC */
82         if (flags & O_DSYNC)
83                 posix_flags |= SMB_O_SYNC;
84         if (flags & O_DIRECTORY)
85                 posix_flags |= SMB_O_DIRECTORY;
86         if (flags & O_NOFOLLOW)
87                 posix_flags |= SMB_O_NOFOLLOW;
88         if (flags & O_DIRECT)
89                 posix_flags |= SMB_O_DIRECT;
90
91         return posix_flags;
92 }
93
94 static inline int cifs_get_disposition(unsigned int flags)
95 {
96         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
97                 return FILE_CREATE;
98         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
99                 return FILE_OVERWRITE_IF;
100         else if ((flags & O_CREAT) == O_CREAT)
101                 return FILE_OPEN_IF;
102         else if ((flags & O_TRUNC) == O_TRUNC)
103                 return FILE_OVERWRITE;
104         else
105                 return FILE_OPEN;
106 }
107
108 int cifs_posix_open(char *full_path, struct inode **pinode,
109                         struct super_block *sb, int mode, unsigned int f_flags,
110                         __u32 *poplock, __u16 *pnetfid, 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 offset, __u64 length, __u8 type, __u16 netfid)
649 {
650         struct cifsLockInfo *lock =
651                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
652         if (!lock)
653                 return lock;
654         lock->offset = offset;
655         lock->length = length;
656         lock->type = type;
657         lock->netfid = netfid;
658         lock->pid = current->tgid;
659         INIT_LIST_HEAD(&lock->blist);
660         init_waitqueue_head(&lock->block_q);
661         return lock;
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 bool
698 cifs_find_lock_conflict(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
699                         struct cifsLockInfo **conf_lock)
700 {
701         return __cifs_find_lock_conflict(cinode, lock->offset, lock->length,
702                                          lock->type, lock->netfid, conf_lock);
703 }
704
705 /*
706  * Check if there is another lock that prevents us to set the lock (mandatory
707  * style). If such a lock exists, update the flock structure with its
708  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
709  * or leave it the same if we can't. Returns 0 if we don't need to request to
710  * the server or 1 otherwise.
711  */
712 static int
713 cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
714                __u8 type, __u16 netfid, struct file_lock *flock)
715 {
716         int rc = 0;
717         struct cifsLockInfo *conf_lock;
718         bool exist;
719
720         mutex_lock(&cinode->lock_mutex);
721
722         exist = __cifs_find_lock_conflict(cinode, offset, length, type, netfid,
723                                           &conf_lock);
724         if (exist) {
725                 flock->fl_start = conf_lock->offset;
726                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
727                 flock->fl_pid = conf_lock->pid;
728                 if (conf_lock->type & LOCKING_ANDX_SHARED_LOCK)
729                         flock->fl_type = F_RDLCK;
730                 else
731                         flock->fl_type = F_WRLCK;
732         } else if (!cinode->can_cache_brlcks)
733                 rc = 1;
734         else
735                 flock->fl_type = F_UNLCK;
736
737         mutex_unlock(&cinode->lock_mutex);
738         return rc;
739 }
740
741 static void
742 cifs_lock_add(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock)
743 {
744         mutex_lock(&cinode->lock_mutex);
745         list_add_tail(&lock->llist, &cinode->llist);
746         mutex_unlock(&cinode->lock_mutex);
747 }
748
749 /*
750  * Set the byte-range lock (mandatory style). Returns:
751  * 1) 0, if we set the lock and don't need to request to the server;
752  * 2) 1, if no locks prevent us but we need to request to the server;
753  * 3) -EACCESS, if there is a lock that prevents us and wait is false.
754  */
755 static int
756 cifs_lock_add_if(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
757                  bool wait)
758 {
759         struct cifsLockInfo *conf_lock;
760         bool exist;
761         int rc = 0;
762
763 try_again:
764         exist = false;
765         mutex_lock(&cinode->lock_mutex);
766
767         exist = cifs_find_lock_conflict(cinode, lock, &conf_lock);
768         if (!exist && cinode->can_cache_brlcks) {
769                 list_add_tail(&lock->llist, &cinode->llist);
770                 mutex_unlock(&cinode->lock_mutex);
771                 return rc;
772         }
773
774         if (!exist)
775                 rc = 1;
776         else if (!wait)
777                 rc = -EACCES;
778         else {
779                 list_add_tail(&lock->blist, &conf_lock->blist);
780                 mutex_unlock(&cinode->lock_mutex);
781                 rc = wait_event_interruptible(lock->block_q,
782                                         (lock->blist.prev == &lock->blist) &&
783                                         (lock->blist.next == &lock->blist));
784                 if (!rc)
785                         goto try_again;
786                 mutex_lock(&cinode->lock_mutex);
787                 list_del_init(&lock->blist);
788         }
789
790         mutex_unlock(&cinode->lock_mutex);
791         return rc;
792 }
793
794 /*
795  * Check if there is another lock that prevents us to set the lock (posix
796  * style). If such a lock exists, update the flock structure with its
797  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
798  * or leave it the same if we can't. Returns 0 if we don't need to request to
799  * the server or 1 otherwise.
800  */
801 static int
802 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
803 {
804         int rc = 0;
805         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
806         unsigned char saved_type = flock->fl_type;
807
808         if ((flock->fl_flags & FL_POSIX) == 0)
809                 return 1;
810
811         mutex_lock(&cinode->lock_mutex);
812         posix_test_lock(file, flock);
813
814         if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
815                 flock->fl_type = saved_type;
816                 rc = 1;
817         }
818
819         mutex_unlock(&cinode->lock_mutex);
820         return rc;
821 }
822
823 /*
824  * Set the byte-range lock (posix style). Returns:
825  * 1) 0, if we set the lock and don't need to request to the server;
826  * 2) 1, if we need to request to the server;
827  * 3) <0, if the error occurs while setting the lock.
828  */
829 static int
830 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
831 {
832         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
833         int rc = 1;
834
835         if ((flock->fl_flags & FL_POSIX) == 0)
836                 return rc;
837
838         mutex_lock(&cinode->lock_mutex);
839         if (!cinode->can_cache_brlcks) {
840                 mutex_unlock(&cinode->lock_mutex);
841                 return rc;
842         }
843         rc = posix_lock_file_wait(file, flock);
844         mutex_unlock(&cinode->lock_mutex);
845         return rc;
846 }
847
848 static int
849 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
850 {
851         int xid, rc = 0, stored_rc;
852         struct cifsLockInfo *li, *tmp;
853         struct cifs_tcon *tcon;
854         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
855         unsigned int num, max_num;
856         LOCKING_ANDX_RANGE *buf, *cur;
857         int types[] = {LOCKING_ANDX_LARGE_FILES,
858                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
859         int i;
860
861         xid = GetXid();
862         tcon = tlink_tcon(cfile->tlink);
863
864         mutex_lock(&cinode->lock_mutex);
865         if (!cinode->can_cache_brlcks) {
866                 mutex_unlock(&cinode->lock_mutex);
867                 FreeXid(xid);
868                 return rc;
869         }
870
871         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
872                   sizeof(LOCKING_ANDX_RANGE);
873         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
874         if (!buf) {
875                 mutex_unlock(&cinode->lock_mutex);
876                 FreeXid(xid);
877                 return rc;
878         }
879
880         for (i = 0; i < 2; i++) {
881                 cur = buf;
882                 num = 0;
883                 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
884                         if (li->type != types[i])
885                                 continue;
886                         cur->Pid = cpu_to_le16(li->pid);
887                         cur->LengthLow = cpu_to_le32((u32)li->length);
888                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
889                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
890                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
891                         if (++num == max_num) {
892                                 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
893                                                        li->type, 0, num, buf);
894                                 if (stored_rc)
895                                         rc = stored_rc;
896                                 cur = buf;
897                                 num = 0;
898                         } else
899                                 cur++;
900                 }
901
902                 if (num) {
903                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
904                                                types[i], 0, num, buf);
905                         if (stored_rc)
906                                 rc = stored_rc;
907                 }
908         }
909
910         cinode->can_cache_brlcks = false;
911         mutex_unlock(&cinode->lock_mutex);
912
913         kfree(buf);
914         FreeXid(xid);
915         return rc;
916 }
917
918 /* copied from fs/locks.c with a name change */
919 #define cifs_for_each_lock(inode, lockp) \
920         for (lockp = &inode->i_flock; *lockp != NULL; \
921              lockp = &(*lockp)->fl_next)
922
923 struct lock_to_push {
924         struct list_head llist;
925         __u64 offset;
926         __u64 length;
927         __u32 pid;
928         __u16 netfid;
929         __u8 type;
930 };
931
932 static int
933 cifs_push_posix_locks(struct cifsFileInfo *cfile)
934 {
935         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
936         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
937         struct file_lock *flock, **before;
938         unsigned int count = 0, i = 0;
939         int rc = 0, xid, type;
940         struct list_head locks_to_send, *el;
941         struct lock_to_push *lck, *tmp;
942         __u64 length;
943
944         xid = GetXid();
945
946         mutex_lock(&cinode->lock_mutex);
947         if (!cinode->can_cache_brlcks) {
948                 mutex_unlock(&cinode->lock_mutex);
949                 FreeXid(xid);
950                 return rc;
951         }
952
953         lock_flocks();
954         cifs_for_each_lock(cfile->dentry->d_inode, before) {
955                 if ((*before)->fl_flags & FL_POSIX)
956                         count++;
957         }
958         unlock_flocks();
959
960         INIT_LIST_HEAD(&locks_to_send);
961
962         /*
963          * Allocating count locks is enough because no FL_POSIX locks can be
964          * added to the list while we are holding cinode->lock_mutex that
965          * protects locking operations of this inode.
966          */
967         for (; i < count; i++) {
968                 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
969                 if (!lck) {
970                         rc = -ENOMEM;
971                         goto err_out;
972                 }
973                 list_add_tail(&lck->llist, &locks_to_send);
974         }
975
976         el = locks_to_send.next;
977         lock_flocks();
978         cifs_for_each_lock(cfile->dentry->d_inode, before) {
979                 flock = *before;
980                 if ((flock->fl_flags & FL_POSIX) == 0)
981                         continue;
982                 if (el == &locks_to_send) {
983                         /*
984                          * The list ended. We don't have enough allocated
985                          * structures - something is really wrong.
986                          */
987                         cERROR(1, "Can't push all brlocks!");
988                         break;
989                 }
990                 length = 1 + flock->fl_end - flock->fl_start;
991                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
992                         type = CIFS_RDLCK;
993                 else
994                         type = CIFS_WRLCK;
995                 lck = list_entry(el, struct lock_to_push, llist);
996                 lck->pid = flock->fl_pid;
997                 lck->netfid = cfile->netfid;
998                 lck->length = length;
999                 lck->type = type;
1000                 lck->offset = flock->fl_start;
1001                 el = el->next;
1002         }
1003         unlock_flocks();
1004
1005         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1006                 struct file_lock tmp_lock;
1007                 int stored_rc;
1008
1009                 tmp_lock.fl_start = lck->offset;
1010                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1011                                              0, lck->length, &tmp_lock,
1012                                              lck->type, 0);
1013                 if (stored_rc)
1014                         rc = stored_rc;
1015                 list_del(&lck->llist);
1016                 kfree(lck);
1017         }
1018
1019 out:
1020         cinode->can_cache_brlcks = false;
1021         mutex_unlock(&cinode->lock_mutex);
1022
1023         FreeXid(xid);
1024         return rc;
1025 err_out:
1026         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1027                 list_del(&lck->llist);
1028                 kfree(lck);
1029         }
1030         goto out;
1031 }
1032
1033 static int
1034 cifs_push_locks(struct cifsFileInfo *cfile)
1035 {
1036         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1037         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1038
1039         if ((tcon->ses->capabilities & CAP_UNIX) &&
1040             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1041             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1042                 return cifs_push_posix_locks(cfile);
1043
1044         return cifs_push_mandatory_locks(cfile);
1045 }
1046
1047 static void
1048 cifs_read_flock(struct file_lock *flock, __u8 *type, int *lock, int *unlock,
1049                 bool *wait_flag)
1050 {
1051         if (flock->fl_flags & FL_POSIX)
1052                 cFYI(1, "Posix");
1053         if (flock->fl_flags & FL_FLOCK)
1054                 cFYI(1, "Flock");
1055         if (flock->fl_flags & FL_SLEEP) {
1056                 cFYI(1, "Blocking lock");
1057                 *wait_flag = true;
1058         }
1059         if (flock->fl_flags & FL_ACCESS)
1060                 cFYI(1, "Process suspended by mandatory locking - "
1061                         "not implemented yet");
1062         if (flock->fl_flags & FL_LEASE)
1063                 cFYI(1, "Lease on file - not implemented yet");
1064         if (flock->fl_flags &
1065             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
1066                 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1067
1068         *type = LOCKING_ANDX_LARGE_FILES;
1069         if (flock->fl_type == F_WRLCK) {
1070                 cFYI(1, "F_WRLCK ");
1071                 *lock = 1;
1072         } else if (flock->fl_type == F_UNLCK) {
1073                 cFYI(1, "F_UNLCK");
1074                 *unlock = 1;
1075                 /* Check if unlock includes more than one lock range */
1076         } else if (flock->fl_type == F_RDLCK) {
1077                 cFYI(1, "F_RDLCK");
1078                 *type |= LOCKING_ANDX_SHARED_LOCK;
1079                 *lock = 1;
1080         } else if (flock->fl_type == F_EXLCK) {
1081                 cFYI(1, "F_EXLCK");
1082                 *lock = 1;
1083         } else if (flock->fl_type == F_SHLCK) {
1084                 cFYI(1, "F_SHLCK");
1085                 *type |= LOCKING_ANDX_SHARED_LOCK;
1086                 *lock = 1;
1087         } else
1088                 cFYI(1, "Unknown type of lock");
1089 }
1090
1091 static int
1092 cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
1093            bool wait_flag, bool posix_lck, int xid)
1094 {
1095         int rc = 0;
1096         __u64 length = 1 + flock->fl_end - flock->fl_start;
1097         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1098         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1099         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1100         __u16 netfid = cfile->netfid;
1101
1102         if (posix_lck) {
1103                 int posix_lock_type;
1104
1105                 rc = cifs_posix_lock_test(file, flock);
1106                 if (!rc)
1107                         return rc;
1108
1109                 if (type & LOCKING_ANDX_SHARED_LOCK)
1110                         posix_lock_type = CIFS_RDLCK;
1111                 else
1112                         posix_lock_type = CIFS_WRLCK;
1113                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1114                                       1 /* get */, length, flock,
1115                                       posix_lock_type, wait_flag);
1116                 return rc;
1117         }
1118
1119         rc = cifs_lock_test(cinode, flock->fl_start, length, type, netfid,
1120                             flock);
1121         if (!rc)
1122                 return rc;
1123
1124         /* BB we could chain these into one lock request BB */
1125         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1126                          flock->fl_start, 0, 1, type, 0, 0);
1127         if (rc == 0) {
1128                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1129                                  length, flock->fl_start, 1, 0,
1130                                  type, 0, 0);
1131                 flock->fl_type = F_UNLCK;
1132                 if (rc != 0)
1133                         cERROR(1, "Error unlocking previously locked "
1134                                    "range %d during test of lock", rc);
1135                 return 0;
1136         }
1137
1138         if (type & LOCKING_ANDX_SHARED_LOCK) {
1139                 flock->fl_type = F_WRLCK;
1140                 return 0;
1141         }
1142
1143         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1144                          flock->fl_start, 0, 1,
1145                          type | LOCKING_ANDX_SHARED_LOCK, 0, 0);
1146         if (rc == 0) {
1147                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1148                                  length, flock->fl_start, 1, 0,
1149                                  type | LOCKING_ANDX_SHARED_LOCK,
1150                                  0, 0);
1151                 flock->fl_type = F_RDLCK;
1152                 if (rc != 0)
1153                         cERROR(1, "Error unlocking previously locked "
1154                                   "range %d during test of lock", rc);
1155         } else
1156                 flock->fl_type = F_WRLCK;
1157
1158         return 0;
1159 }
1160
1161 static void
1162 cifs_move_llist(struct list_head *source, struct list_head *dest)
1163 {
1164         struct list_head *li, *tmp;
1165         list_for_each_safe(li, tmp, source)
1166                 list_move(li, dest);
1167 }
1168
1169 static void
1170 cifs_free_llist(struct list_head *llist)
1171 {
1172         struct cifsLockInfo *li, *tmp;
1173         list_for_each_entry_safe(li, tmp, llist, llist) {
1174                 cifs_del_lock_waiters(li);
1175                 list_del(&li->llist);
1176                 kfree(li);
1177         }
1178 }
1179
1180 static int
1181 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1182 {
1183         int rc = 0, stored_rc;
1184         int types[] = {LOCKING_ANDX_LARGE_FILES,
1185                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1186         unsigned int i;
1187         unsigned int max_num, num;
1188         LOCKING_ANDX_RANGE *buf, *cur;
1189         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1190         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1191         struct cifsLockInfo *li, *tmp;
1192         __u64 length = 1 + flock->fl_end - flock->fl_start;
1193         struct list_head tmp_llist;
1194
1195         INIT_LIST_HEAD(&tmp_llist);
1196
1197         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1198                   sizeof(LOCKING_ANDX_RANGE);
1199         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1200         if (!buf)
1201                 return -ENOMEM;
1202
1203         mutex_lock(&cinode->lock_mutex);
1204         for (i = 0; i < 2; i++) {
1205                 cur = buf;
1206                 num = 0;
1207                 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
1208                         if (flock->fl_start > li->offset ||
1209                             (flock->fl_start + length) <
1210                             (li->offset + li->length))
1211                                 continue;
1212                         if (current->tgid != li->pid)
1213                                 continue;
1214                         if (cfile->netfid != li->netfid)
1215                                 continue;
1216                         if (types[i] != li->type)
1217                                 continue;
1218                         if (!cinode->can_cache_brlcks) {
1219                                 cur->Pid = cpu_to_le16(li->pid);
1220                                 cur->LengthLow = cpu_to_le32((u32)li->length);
1221                                 cur->LengthHigh =
1222                                         cpu_to_le32((u32)(li->length>>32));
1223                                 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1224                                 cur->OffsetHigh =
1225                                         cpu_to_le32((u32)(li->offset>>32));
1226                                 /*
1227                                  * We need to save a lock here to let us add
1228                                  * it again to the inode list if the unlock
1229                                  * range request fails on the server.
1230                                  */
1231                                 list_move(&li->llist, &tmp_llist);
1232                                 if (++num == max_num) {
1233                                         stored_rc = cifs_lockv(xid, tcon,
1234                                                                cfile->netfid,
1235                                                                li->type, num,
1236                                                                0, buf);
1237                                         if (stored_rc) {
1238                                                 /*
1239                                                  * We failed on the unlock range
1240                                                  * request - add all locks from
1241                                                  * the tmp list to the head of
1242                                                  * the inode list.
1243                                                  */
1244                                                 cifs_move_llist(&tmp_llist,
1245                                                                 &cinode->llist);
1246                                                 rc = stored_rc;
1247                                         } else
1248                                                 /*
1249                                                  * The unlock range request
1250                                                  * succeed - free the tmp list.
1251                                                  */
1252                                                 cifs_free_llist(&tmp_llist);
1253                                         cur = buf;
1254                                         num = 0;
1255                                 } else
1256                                         cur++;
1257                         } else {
1258                                 /*
1259                                  * We can cache brlock requests - simply remove
1260                                  * a lock from the inode list.
1261                                  */
1262                                 list_del(&li->llist);
1263                                 cifs_del_lock_waiters(li);
1264                                 kfree(li);
1265                         }
1266                 }
1267                 if (num) {
1268                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1269                                                types[i], num, 0, buf);
1270                         if (stored_rc) {
1271                                 cifs_move_llist(&tmp_llist, &cinode->llist);
1272                                 rc = stored_rc;
1273                         } else
1274                                 cifs_free_llist(&tmp_llist);
1275                 }
1276         }
1277
1278         mutex_unlock(&cinode->lock_mutex);
1279         kfree(buf);
1280         return rc;
1281 }
1282
1283 static int
1284 cifs_setlk(struct file *file,  struct file_lock *flock, __u8 type,
1285            bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1286 {
1287         int rc = 0;
1288         __u64 length = 1 + flock->fl_end - flock->fl_start;
1289         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1290         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1291         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
1292         __u16 netfid = cfile->netfid;
1293
1294         if (posix_lck) {
1295                 int posix_lock_type;
1296
1297                 rc = cifs_posix_lock_set(file, flock);
1298                 if (!rc || rc < 0)
1299                         return rc;
1300
1301                 if (type & LOCKING_ANDX_SHARED_LOCK)
1302                         posix_lock_type = CIFS_RDLCK;
1303                 else
1304                         posix_lock_type = CIFS_WRLCK;
1305
1306                 if (unlock == 1)
1307                         posix_lock_type = CIFS_UNLCK;
1308
1309                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1310                                       0 /* set */, length, flock,
1311                                       posix_lock_type, wait_flag);
1312                 goto out;
1313         }
1314
1315         if (lock) {
1316                 struct cifsLockInfo *lock;
1317
1318                 lock = cifs_lock_init(flock->fl_start, length, type, netfid);
1319                 if (!lock)
1320                         return -ENOMEM;
1321
1322                 rc = cifs_lock_add_if(cinode, lock, wait_flag);
1323                 if (rc < 0)
1324                         kfree(lock);
1325                 if (rc <= 0)
1326                         goto out;
1327
1328                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1329                                  flock->fl_start, 0, 1, type, wait_flag, 0);
1330                 if (rc) {
1331                         kfree(lock);
1332                         goto out;
1333                 }
1334
1335                 cifs_lock_add(cinode, lock);
1336         } else if (unlock)
1337                 rc = cifs_unlock_range(cfile, flock, xid);
1338
1339 out:
1340         if (flock->fl_flags & FL_POSIX)
1341                 posix_lock_file_wait(file, flock);
1342         return rc;
1343 }
1344
1345 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1346 {
1347         int rc, xid;
1348         int lock = 0, unlock = 0;
1349         bool wait_flag = false;
1350         bool posix_lck = false;
1351         struct cifs_sb_info *cifs_sb;
1352         struct cifs_tcon *tcon;
1353         struct cifsInodeInfo *cinode;
1354         struct cifsFileInfo *cfile;
1355         __u16 netfid;
1356         __u8 type;
1357
1358         rc = -EACCES;
1359         xid = GetXid();
1360
1361         cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1362                 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1363                 flock->fl_start, flock->fl_end);
1364
1365         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag);
1366
1367         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1368         cfile = (struct cifsFileInfo *)file->private_data;
1369         tcon = tlink_tcon(cfile->tlink);
1370         netfid = cfile->netfid;
1371         cinode = CIFS_I(file->f_path.dentry->d_inode);
1372
1373         if ((tcon->ses->capabilities & CAP_UNIX) &&
1374             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1375             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1376                 posix_lck = true;
1377         /*
1378          * BB add code here to normalize offset and length to account for
1379          * negative length which we can not accept over the wire.
1380          */
1381         if (IS_GETLK(cmd)) {
1382                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1383                 FreeXid(xid);
1384                 return rc;
1385         }
1386
1387         if (!lock && !unlock) {
1388                 /*
1389                  * if no lock or unlock then nothing to do since we do not
1390                  * know what it is
1391                  */
1392                 FreeXid(xid);
1393                 return -EOPNOTSUPP;
1394         }
1395
1396         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1397                         xid);
1398         FreeXid(xid);
1399         return rc;
1400 }
1401
1402 /* update the file size (if needed) after a write */
1403 void
1404 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1405                       unsigned int bytes_written)
1406 {
1407         loff_t end_of_write = offset + bytes_written;
1408
1409         if (end_of_write > cifsi->server_eof)
1410                 cifsi->server_eof = end_of_write;
1411 }
1412
1413 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
1414                           const char *write_data, size_t write_size,
1415                           loff_t *poffset)
1416 {
1417         int rc = 0;
1418         unsigned int bytes_written = 0;
1419         unsigned int total_written;
1420         struct cifs_sb_info *cifs_sb;
1421         struct cifs_tcon *pTcon;
1422         int xid;
1423         struct dentry *dentry = open_file->dentry;
1424         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1425         struct cifs_io_parms io_parms;
1426
1427         cifs_sb = CIFS_SB(dentry->d_sb);
1428
1429         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1430            *poffset, dentry->d_name.name);
1431
1432         pTcon = tlink_tcon(open_file->tlink);
1433
1434         xid = GetXid();
1435
1436         for (total_written = 0; write_size > total_written;
1437              total_written += bytes_written) {
1438                 rc = -EAGAIN;
1439                 while (rc == -EAGAIN) {
1440                         struct kvec iov[2];
1441                         unsigned int len;
1442
1443                         if (open_file->invalidHandle) {
1444                                 /* we could deadlock if we called
1445                                    filemap_fdatawait from here so tell
1446                                    reopen_file not to flush data to
1447                                    server now */
1448                                 rc = cifs_reopen_file(open_file, false);
1449                                 if (rc != 0)
1450                                         break;
1451                         }
1452
1453                         len = min((size_t)cifs_sb->wsize,
1454                                   write_size - total_written);
1455                         /* iov[0] is reserved for smb header */
1456                         iov[1].iov_base = (char *)write_data + total_written;
1457                         iov[1].iov_len = len;
1458                         io_parms.netfid = open_file->netfid;
1459                         io_parms.pid = pid;
1460                         io_parms.tcon = pTcon;
1461                         io_parms.offset = *poffset;
1462                         io_parms.length = len;
1463                         rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1464                                            1, 0);
1465                 }
1466                 if (rc || (bytes_written == 0)) {
1467                         if (total_written)
1468                                 break;
1469                         else {
1470                                 FreeXid(xid);
1471                                 return rc;
1472                         }
1473                 } else {
1474                         cifs_update_eof(cifsi, *poffset, bytes_written);
1475                         *poffset += bytes_written;
1476                 }
1477         }
1478
1479         cifs_stats_bytes_written(pTcon, total_written);
1480
1481         if (total_written > 0) {
1482                 spin_lock(&dentry->d_inode->i_lock);
1483                 if (*poffset > dentry->d_inode->i_size)
1484                         i_size_write(dentry->d_inode, *poffset);
1485                 spin_unlock(&dentry->d_inode->i_lock);
1486         }
1487         mark_inode_dirty_sync(dentry->d_inode);
1488         FreeXid(xid);
1489         return total_written;
1490 }
1491
1492 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1493                                         bool fsuid_only)
1494 {
1495         struct cifsFileInfo *open_file = NULL;
1496         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1497
1498         /* only filter by fsuid on multiuser mounts */
1499         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1500                 fsuid_only = false;
1501
1502         spin_lock(&cifs_file_list_lock);
1503         /* we could simply get the first_list_entry since write-only entries
1504            are always at the end of the list but since the first entry might
1505            have a close pending, we go through the whole list */
1506         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1507                 if (fsuid_only && open_file->uid != current_fsuid())
1508                         continue;
1509                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1510                         if (!open_file->invalidHandle) {
1511                                 /* found a good file */
1512                                 /* lock it so it will not be closed on us */
1513                                 cifsFileInfo_get(open_file);
1514                                 spin_unlock(&cifs_file_list_lock);
1515                                 return open_file;
1516                         } /* else might as well continue, and look for
1517                              another, or simply have the caller reopen it
1518                              again rather than trying to fix this handle */
1519                 } else /* write only file */
1520                         break; /* write only files are last so must be done */
1521         }
1522         spin_unlock(&cifs_file_list_lock);
1523         return NULL;
1524 }
1525
1526 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1527                                         bool fsuid_only)
1528 {
1529         struct cifsFileInfo *open_file;
1530         struct cifs_sb_info *cifs_sb;
1531         bool any_available = false;
1532         int rc;
1533
1534         /* Having a null inode here (because mapping->host was set to zero by
1535         the VFS or MM) should not happen but we had reports of on oops (due to
1536         it being zero) during stress testcases so we need to check for it */
1537
1538         if (cifs_inode == NULL) {
1539                 cERROR(1, "Null inode passed to cifs_writeable_file");
1540                 dump_stack();
1541                 return NULL;
1542         }
1543
1544         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1545
1546         /* only filter by fsuid on multiuser mounts */
1547         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1548                 fsuid_only = false;
1549
1550         spin_lock(&cifs_file_list_lock);
1551 refind_writable:
1552         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1553                 if (!any_available && open_file->pid != current->tgid)
1554                         continue;
1555                 if (fsuid_only && open_file->uid != current_fsuid())
1556                         continue;
1557                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1558                         cifsFileInfo_get(open_file);
1559
1560                         if (!open_file->invalidHandle) {
1561                                 /* found a good writable file */
1562                                 spin_unlock(&cifs_file_list_lock);
1563                                 return open_file;
1564                         }
1565
1566                         spin_unlock(&cifs_file_list_lock);
1567
1568                         /* Had to unlock since following call can block */
1569                         rc = cifs_reopen_file(open_file, false);
1570                         if (!rc)
1571                                 return open_file;
1572
1573                         /* if it fails, try another handle if possible */
1574                         cFYI(1, "wp failed on reopen file");
1575                         cifsFileInfo_put(open_file);
1576
1577                         spin_lock(&cifs_file_list_lock);
1578
1579                         /* else we simply continue to the next entry. Thus
1580                            we do not loop on reopen errors.  If we
1581                            can not reopen the file, for example if we
1582                            reconnected to a server with another client
1583                            racing to delete or lock the file we would not
1584                            make progress if we restarted before the beginning
1585                            of the loop here. */
1586                 }
1587         }
1588         /* couldn't find useable FH with same pid, try any available */
1589         if (!any_available) {
1590                 any_available = true;
1591                 goto refind_writable;
1592         }
1593         spin_unlock(&cifs_file_list_lock);
1594         return NULL;
1595 }
1596
1597 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1598 {
1599         struct address_space *mapping = page->mapping;
1600         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1601         char *write_data;
1602         int rc = -EFAULT;
1603         int bytes_written = 0;
1604         struct inode *inode;
1605         struct cifsFileInfo *open_file;
1606
1607         if (!mapping || !mapping->host)
1608                 return -EFAULT;
1609
1610         inode = page->mapping->host;
1611
1612         offset += (loff_t)from;
1613         write_data = kmap(page);
1614         write_data += from;
1615
1616         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1617                 kunmap(page);
1618                 return -EIO;
1619         }
1620
1621         /* racing with truncate? */
1622         if (offset > mapping->host->i_size) {
1623                 kunmap(page);
1624                 return 0; /* don't care */
1625         }
1626
1627         /* check to make sure that we are not extending the file */
1628         if (mapping->host->i_size - offset < (loff_t)to)
1629                 to = (unsigned)(mapping->host->i_size - offset);
1630
1631         open_file = find_writable_file(CIFS_I(mapping->host), false);
1632         if (open_file) {
1633                 bytes_written = cifs_write(open_file, open_file->pid,
1634                                            write_data, to - from, &offset);
1635                 cifsFileInfo_put(open_file);
1636                 /* Does mm or vfs already set times? */
1637                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1638                 if ((bytes_written > 0) && (offset))
1639                         rc = 0;
1640                 else if (bytes_written < 0)
1641                         rc = bytes_written;
1642         } else {
1643                 cFYI(1, "No writeable filehandles for inode");
1644                 rc = -EIO;
1645         }
1646
1647         kunmap(page);
1648         return rc;
1649 }
1650
1651 static int cifs_writepages(struct address_space *mapping,
1652                            struct writeback_control *wbc)
1653 {
1654         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1655         bool done = false, scanned = false, range_whole = false;
1656         pgoff_t end, index;
1657         struct cifs_writedata *wdata;
1658         struct page *page;
1659         int rc = 0;
1660
1661         /*
1662          * If wsize is smaller than the page cache size, default to writing
1663          * one page at a time via cifs_writepage
1664          */
1665         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1666                 return generic_writepages(mapping, wbc);
1667
1668         if (wbc->range_cyclic) {
1669                 index = mapping->writeback_index; /* Start from prev offset */
1670                 end = -1;
1671         } else {
1672                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1673                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1674                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1675                         range_whole = true;
1676                 scanned = true;
1677         }
1678 retry:
1679         while (!done && index <= end) {
1680                 unsigned int i, nr_pages, found_pages;
1681                 pgoff_t next = 0, tofind;
1682                 struct page **pages;
1683
1684                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1685                                 end - index) + 1;
1686
1687                 wdata = cifs_writedata_alloc((unsigned int)tofind);
1688                 if (!wdata) {
1689                         rc = -ENOMEM;
1690                         break;
1691                 }
1692
1693                 /*
1694                  * find_get_pages_tag seems to return a max of 256 on each
1695                  * iteration, so we must call it several times in order to
1696                  * fill the array or the wsize is effectively limited to
1697                  * 256 * PAGE_CACHE_SIZE.
1698                  */
1699                 found_pages = 0;
1700                 pages = wdata->pages;
1701                 do {
1702                         nr_pages = find_get_pages_tag(mapping, &index,
1703                                                         PAGECACHE_TAG_DIRTY,
1704                                                         tofind, pages);
1705                         found_pages += nr_pages;
1706                         tofind -= nr_pages;
1707                         pages += nr_pages;
1708                 } while (nr_pages && tofind && index <= end);
1709
1710                 if (found_pages == 0) {
1711                         kref_put(&wdata->refcount, cifs_writedata_release);
1712                         break;
1713                 }
1714
1715                 nr_pages = 0;
1716                 for (i = 0; i < found_pages; i++) {
1717                         page = wdata->pages[i];
1718                         /*
1719                          * At this point we hold neither mapping->tree_lock nor
1720                          * lock on the page itself: the page may be truncated or
1721                          * invalidated (changing page->mapping to NULL), or even
1722                          * swizzled back from swapper_space to tmpfs file
1723                          * mapping
1724                          */
1725
1726                         if (nr_pages == 0)
1727                                 lock_page(page);
1728                         else if (!trylock_page(page))
1729                                 break;
1730
1731                         if (unlikely(page->mapping != mapping)) {
1732                                 unlock_page(page);
1733                                 break;
1734                         }
1735
1736                         if (!wbc->range_cyclic && page->index > end) {
1737                                 done = true;
1738                                 unlock_page(page);
1739                                 break;
1740                         }
1741
1742                         if (next && (page->index != next)) {
1743                                 /* Not next consecutive page */
1744                                 unlock_page(page);
1745                                 break;
1746                         }
1747
1748                         if (wbc->sync_mode != WB_SYNC_NONE)
1749                                 wait_on_page_writeback(page);
1750
1751                         if (PageWriteback(page) ||
1752                                         !clear_page_dirty_for_io(page)) {
1753                                 unlock_page(page);
1754                                 break;
1755                         }
1756
1757                         /*
1758                          * This actually clears the dirty bit in the radix tree.
1759                          * See cifs_writepage() for more commentary.
1760                          */
1761                         set_page_writeback(page);
1762
1763                         if (page_offset(page) >= mapping->host->i_size) {
1764                                 done = true;
1765                                 unlock_page(page);
1766                                 end_page_writeback(page);
1767                                 break;
1768                         }
1769
1770                         wdata->pages[i] = page;
1771                         next = page->index + 1;
1772                         ++nr_pages;
1773                 }
1774
1775                 /* reset index to refind any pages skipped */
1776                 if (nr_pages == 0)
1777                         index = wdata->pages[0]->index + 1;
1778
1779                 /* put any pages we aren't going to use */
1780                 for (i = nr_pages; i < found_pages; i++) {
1781                         page_cache_release(wdata->pages[i]);
1782                         wdata->pages[i] = NULL;
1783                 }
1784
1785                 /* nothing to write? */
1786                 if (nr_pages == 0) {
1787                         kref_put(&wdata->refcount, cifs_writedata_release);
1788                         continue;
1789                 }
1790
1791                 wdata->sync_mode = wbc->sync_mode;
1792                 wdata->nr_pages = nr_pages;
1793                 wdata->offset = page_offset(wdata->pages[0]);
1794
1795                 do {
1796                         if (wdata->cfile != NULL)
1797                                 cifsFileInfo_put(wdata->cfile);
1798                         wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1799                                                           false);
1800                         if (!wdata->cfile) {
1801                                 cERROR(1, "No writable handles for inode");
1802                                 rc = -EBADF;
1803                                 break;
1804                         }
1805                         rc = cifs_async_writev(wdata);
1806                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1807
1808                 for (i = 0; i < nr_pages; ++i)
1809                         unlock_page(wdata->pages[i]);
1810
1811                 /* send failure -- clean up the mess */
1812                 if (rc != 0) {
1813                         for (i = 0; i < nr_pages; ++i) {
1814                                 if (rc == -EAGAIN)
1815                                         redirty_page_for_writepage(wbc,
1816                                                            wdata->pages[i]);
1817                                 else
1818                                         SetPageError(wdata->pages[i]);
1819                                 end_page_writeback(wdata->pages[i]);
1820                                 page_cache_release(wdata->pages[i]);
1821                         }
1822                         if (rc != -EAGAIN)
1823                                 mapping_set_error(mapping, rc);
1824                 }
1825                 kref_put(&wdata->refcount, cifs_writedata_release);
1826
1827                 wbc->nr_to_write -= nr_pages;
1828                 if (wbc->nr_to_write <= 0)
1829                         done = true;
1830
1831                 index = next;
1832         }
1833
1834         if (!scanned && !done) {
1835                 /*
1836                  * We hit the last page and there is more work to be done: wrap
1837                  * back to the start of the file
1838                  */
1839                 scanned = true;
1840                 index = 0;
1841                 goto retry;
1842         }
1843
1844         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1845                 mapping->writeback_index = index;
1846
1847         return rc;
1848 }
1849
1850 static int
1851 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1852 {
1853         int rc;
1854         int xid;
1855
1856         xid = GetXid();
1857 /* BB add check for wbc flags */
1858         page_cache_get(page);
1859         if (!PageUptodate(page))
1860                 cFYI(1, "ppw - page not up to date");
1861
1862         /*
1863          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1864          *
1865          * A writepage() implementation always needs to do either this,
1866          * or re-dirty the page with "redirty_page_for_writepage()" in
1867          * the case of a failure.
1868          *
1869          * Just unlocking the page will cause the radix tree tag-bits
1870          * to fail to update with the state of the page correctly.
1871          */
1872         set_page_writeback(page);
1873 retry_write:
1874         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1875         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1876                 goto retry_write;
1877         else if (rc == -EAGAIN)
1878                 redirty_page_for_writepage(wbc, page);
1879         else if (rc != 0)
1880                 SetPageError(page);
1881         else
1882                 SetPageUptodate(page);
1883         end_page_writeback(page);
1884         page_cache_release(page);
1885         FreeXid(xid);
1886         return rc;
1887 }
1888
1889 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1890 {
1891         int rc = cifs_writepage_locked(page, wbc);
1892         unlock_page(page);
1893         return rc;
1894 }
1895
1896 static int cifs_write_end(struct file *file, struct address_space *mapping,
1897                         loff_t pos, unsigned len, unsigned copied,
1898                         struct page *page, void *fsdata)
1899 {
1900         int rc;
1901         struct inode *inode = mapping->host;
1902         struct cifsFileInfo *cfile = file->private_data;
1903         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1904         __u32 pid;
1905
1906         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1907                 pid = cfile->pid;
1908         else
1909                 pid = current->tgid;
1910
1911         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1912                  page, pos, copied);
1913
1914         if (PageChecked(page)) {
1915                 if (copied == len)
1916                         SetPageUptodate(page);
1917                 ClearPageChecked(page);
1918         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1919                 SetPageUptodate(page);
1920
1921         if (!PageUptodate(page)) {
1922                 char *page_data;
1923                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1924                 int xid;
1925
1926                 xid = GetXid();
1927                 /* this is probably better than directly calling
1928                    partialpage_write since in this function the file handle is
1929                    known which we might as well leverage */
1930                 /* BB check if anything else missing out of ppw
1931                    such as updating last write time */
1932                 page_data = kmap(page);
1933                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1934                 /* if (rc < 0) should we set writebehind rc? */
1935                 kunmap(page);
1936
1937                 FreeXid(xid);
1938         } else {
1939                 rc = copied;
1940                 pos += copied;
1941                 set_page_dirty(page);
1942         }
1943
1944         if (rc > 0) {
1945                 spin_lock(&inode->i_lock);
1946                 if (pos > inode->i_size)
1947                         i_size_write(inode, pos);
1948                 spin_unlock(&inode->i_lock);
1949         }
1950
1951         unlock_page(page);
1952         page_cache_release(page);
1953
1954         return rc;
1955 }
1956
1957 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1958                       int datasync)
1959 {
1960         int xid;
1961         int rc = 0;
1962         struct cifs_tcon *tcon;
1963         struct cifsFileInfo *smbfile = file->private_data;
1964         struct inode *inode = file->f_path.dentry->d_inode;
1965         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1966
1967         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1968         if (rc)
1969                 return rc;
1970         mutex_lock(&inode->i_mutex);
1971
1972         xid = GetXid();
1973
1974         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1975                 file->f_path.dentry->d_name.name, datasync);
1976
1977         if (!CIFS_I(inode)->clientCanCacheRead) {
1978                 rc = cifs_invalidate_mapping(inode);
1979                 if (rc) {
1980                         cFYI(1, "rc: %d during invalidate phase", rc);
1981                         rc = 0; /* don't care about it in fsync */
1982                 }
1983         }
1984
1985         tcon = tlink_tcon(smbfile->tlink);
1986         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1987                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1988
1989         FreeXid(xid);
1990         mutex_unlock(&inode->i_mutex);
1991         return rc;
1992 }
1993
1994 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1995 {
1996         int xid;
1997         int rc = 0;
1998         struct cifs_tcon *tcon;
1999         struct cifsFileInfo *smbfile = file->private_data;
2000         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2001         struct inode *inode = file->f_mapping->host;
2002
2003         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2004         if (rc)
2005                 return rc;
2006         mutex_lock(&inode->i_mutex);
2007
2008         xid = GetXid();
2009
2010         cFYI(1, "Sync file - name: %s datasync: 0x%x",
2011                 file->f_path.dentry->d_name.name, datasync);
2012
2013         tcon = tlink_tcon(smbfile->tlink);
2014         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2015                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2016
2017         FreeXid(xid);
2018         mutex_unlock(&inode->i_mutex);
2019         return rc;
2020 }
2021
2022 /*
2023  * As file closes, flush all cached write data for this inode checking
2024  * for write behind errors.
2025  */
2026 int cifs_flush(struct file *file, fl_owner_t id)
2027 {
2028         struct inode *inode = file->f_path.dentry->d_inode;
2029         int rc = 0;
2030
2031         if (file->f_mode & FMODE_WRITE)
2032                 rc = filemap_write_and_wait(inode->i_mapping);
2033
2034         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2035
2036         return rc;
2037 }
2038
2039 static int
2040 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2041 {
2042         int rc = 0;
2043         unsigned long i;
2044
2045         for (i = 0; i < num_pages; i++) {
2046                 pages[i] = alloc_page(__GFP_HIGHMEM);
2047                 if (!pages[i]) {
2048                         /*
2049                          * save number of pages we have already allocated and
2050                          * return with ENOMEM error
2051                          */
2052                         num_pages = i;
2053                         rc = -ENOMEM;
2054                         goto error;
2055                 }
2056         }
2057
2058         return rc;
2059
2060 error:
2061         for (i = 0; i < num_pages; i++)
2062                 put_page(pages[i]);
2063         return rc;
2064 }
2065
2066 static inline
2067 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2068 {
2069         size_t num_pages;
2070         size_t clen;
2071
2072         clen = min_t(const size_t, len, wsize);
2073         num_pages = clen / PAGE_CACHE_SIZE;
2074         if (clen % PAGE_CACHE_SIZE)
2075                 num_pages++;
2076
2077         if (cur_len)
2078                 *cur_len = clen;
2079
2080         return num_pages;
2081 }
2082
2083 static ssize_t
2084 cifs_iovec_write(struct file *file, const struct iovec *iov,
2085                  unsigned long nr_segs, loff_t *poffset)
2086 {
2087         unsigned int written;
2088         unsigned long num_pages, npages, i;
2089         size_t copied, len, cur_len;
2090         ssize_t total_written = 0;
2091         struct kvec *to_send;
2092         struct page **pages;
2093         struct iov_iter it;
2094         struct inode *inode;
2095         struct cifsFileInfo *open_file;
2096         struct cifs_tcon *pTcon;
2097         struct cifs_sb_info *cifs_sb;
2098         struct cifs_io_parms io_parms;
2099         int xid, rc;
2100         __u32 pid;
2101
2102         len = iov_length(iov, nr_segs);
2103         if (!len)
2104                 return 0;
2105
2106         rc = generic_write_checks(file, poffset, &len, 0);
2107         if (rc)
2108                 return rc;
2109
2110         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2111         num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2112
2113         pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2114         if (!pages)
2115                 return -ENOMEM;
2116
2117         to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2118         if (!to_send) {
2119                 kfree(pages);
2120                 return -ENOMEM;
2121         }
2122
2123         rc = cifs_write_allocate_pages(pages, num_pages);
2124         if (rc) {
2125                 kfree(pages);
2126                 kfree(to_send);
2127                 return rc;
2128         }
2129
2130         xid = GetXid();
2131         open_file = file->private_data;
2132
2133         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2134                 pid = open_file->pid;
2135         else
2136                 pid = current->tgid;
2137
2138         pTcon = tlink_tcon(open_file->tlink);
2139         inode = file->f_path.dentry->d_inode;
2140
2141         iov_iter_init(&it, iov, nr_segs, len, 0);
2142         npages = num_pages;
2143
2144         do {
2145                 size_t save_len = cur_len;
2146                 for (i = 0; i < npages; i++) {
2147                         copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2148                         copied = iov_iter_copy_from_user(pages[i], &it, 0,
2149                                                          copied);
2150                         cur_len -= copied;
2151                         iov_iter_advance(&it, copied);
2152                         to_send[i+1].iov_base = kmap(pages[i]);
2153                         to_send[i+1].iov_len = copied;
2154                 }
2155
2156                 cur_len = save_len - cur_len;
2157
2158                 do {
2159                         if (open_file->invalidHandle) {
2160                                 rc = cifs_reopen_file(open_file, false);
2161                                 if (rc != 0)
2162                                         break;
2163                         }
2164                         io_parms.netfid = open_file->netfid;
2165                         io_parms.pid = pid;
2166                         io_parms.tcon = pTcon;
2167                         io_parms.offset = *poffset;
2168                         io_parms.length = cur_len;
2169                         rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2170                                            npages, 0);
2171                 } while (rc == -EAGAIN);
2172
2173                 for (i = 0; i < npages; i++)
2174                         kunmap(pages[i]);
2175
2176                 if (written) {
2177                         len -= written;
2178                         total_written += written;
2179                         cifs_update_eof(CIFS_I(inode), *poffset, written);
2180                         *poffset += written;
2181                 } else if (rc < 0) {
2182                         if (!total_written)
2183                                 total_written = rc;
2184                         break;
2185                 }
2186
2187                 /* get length and number of kvecs of the next write */
2188                 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2189         } while (len > 0);
2190
2191         if (total_written > 0) {
2192                 spin_lock(&inode->i_lock);
2193                 if (*poffset > inode->i_size)
2194                         i_size_write(inode, *poffset);
2195                 spin_unlock(&inode->i_lock);
2196         }
2197
2198         cifs_stats_bytes_written(pTcon, total_written);
2199         mark_inode_dirty_sync(inode);
2200
2201         for (i = 0; i < num_pages; i++)
2202                 put_page(pages[i]);
2203         kfree(to_send);
2204         kfree(pages);
2205         FreeXid(xid);
2206         return total_written;
2207 }
2208
2209 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2210                                 unsigned long nr_segs, loff_t pos)
2211 {
2212         ssize_t written;
2213         struct inode *inode;
2214
2215         inode = iocb->ki_filp->f_path.dentry->d_inode;
2216
2217         /*
2218          * BB - optimize the way when signing is disabled. We can drop this
2219          * extra memory-to-memory copying and use iovec buffers for constructing
2220          * write request.
2221          */
2222
2223         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2224         if (written > 0) {
2225                 CIFS_I(inode)->invalid_mapping = true;
2226                 iocb->ki_pos = pos;
2227         }
2228
2229         return written;
2230 }
2231
2232 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2233                            unsigned long nr_segs, loff_t pos)
2234 {
2235         struct inode *inode;
2236
2237         inode = iocb->ki_filp->f_path.dentry->d_inode;
2238
2239         if (CIFS_I(inode)->clientCanCacheAll)
2240                 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2241
2242         /*
2243          * In strict cache mode we need to write the data to the server exactly
2244          * from the pos to pos+len-1 rather than flush all affected pages
2245          * because it may cause a error with mandatory locks on these pages but
2246          * not on the region from pos to ppos+len-1.
2247          */
2248
2249         return cifs_user_writev(iocb, iov, nr_segs, pos);
2250 }
2251
2252 static ssize_t
2253 cifs_iovec_read(struct file *file, const struct iovec *iov,
2254                  unsigned long nr_segs, loff_t *poffset)
2255 {
2256         int rc;
2257         int xid;
2258         ssize_t total_read;
2259         unsigned int bytes_read = 0;
2260         size_t len, cur_len;
2261         int iov_offset = 0;
2262         struct cifs_sb_info *cifs_sb;
2263         struct cifs_tcon *pTcon;
2264         struct cifsFileInfo *open_file;
2265         struct smb_com_read_rsp *pSMBr;
2266         struct cifs_io_parms io_parms;
2267         char *read_data;
2268         unsigned int rsize;
2269         __u32 pid;
2270
2271         if (!nr_segs)
2272                 return 0;
2273
2274         len = iov_length(iov, nr_segs);
2275         if (!len)
2276                 return 0;
2277
2278         xid = GetXid();
2279         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2280
2281         /* FIXME: set up handlers for larger reads and/or convert to async */
2282         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2283
2284         open_file = file->private_data;
2285         pTcon = tlink_tcon(open_file->tlink);
2286
2287         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2288                 pid = open_file->pid;
2289         else
2290                 pid = current->tgid;
2291
2292         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2293                 cFYI(1, "attempting read on write only file instance");
2294
2295         for (total_read = 0; total_read < len; total_read += bytes_read) {
2296                 cur_len = min_t(const size_t, len - total_read, rsize);
2297                 rc = -EAGAIN;
2298                 read_data = NULL;
2299
2300                 while (rc == -EAGAIN) {
2301                         int buf_type = CIFS_NO_BUFFER;
2302                         if (open_file->invalidHandle) {
2303                                 rc = cifs_reopen_file(open_file, true);
2304                                 if (rc != 0)
2305                                         break;
2306                         }
2307                         io_parms.netfid = open_file->netfid;
2308                         io_parms.pid = pid;
2309                         io_parms.tcon = pTcon;
2310                         io_parms.offset = *poffset;
2311                         io_parms.length = cur_len;
2312                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2313                                          &read_data, &buf_type);
2314                         pSMBr = (struct smb_com_read_rsp *)read_data;
2315                         if (read_data) {
2316                                 char *data_offset = read_data + 4 +
2317                                                 le16_to_cpu(pSMBr->DataOffset);
2318                                 if (memcpy_toiovecend(iov, data_offset,
2319                                                       iov_offset, bytes_read))
2320                                         rc = -EFAULT;
2321                                 if (buf_type == CIFS_SMALL_BUFFER)
2322                                         cifs_small_buf_release(read_data);
2323                                 else if (buf_type == CIFS_LARGE_BUFFER)
2324                                         cifs_buf_release(read_data);
2325                                 read_data = NULL;
2326                                 iov_offset += bytes_read;
2327                         }
2328                 }
2329
2330                 if (rc || (bytes_read == 0)) {
2331                         if (total_read) {
2332                                 break;
2333                         } else {
2334                                 FreeXid(xid);
2335                                 return rc;
2336                         }
2337                 } else {
2338                         cifs_stats_bytes_read(pTcon, bytes_read);
2339                         *poffset += bytes_read;
2340                 }
2341         }
2342
2343         FreeXid(xid);
2344         return total_read;
2345 }
2346
2347 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2348                                unsigned long nr_segs, loff_t pos)
2349 {
2350         ssize_t read;
2351
2352         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2353         if (read > 0)
2354                 iocb->ki_pos = pos;
2355
2356         return read;
2357 }
2358
2359 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2360                           unsigned long nr_segs, loff_t pos)
2361 {
2362         struct inode *inode;
2363
2364         inode = iocb->ki_filp->f_path.dentry->d_inode;
2365
2366         if (CIFS_I(inode)->clientCanCacheRead)
2367                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2368
2369         /*
2370          * In strict cache mode we need to read from the server all the time
2371          * if we don't have level II oplock because the server can delay mtime
2372          * change - so we can't make a decision about inode invalidating.
2373          * And we can also fail with pagereading if there are mandatory locks
2374          * on pages affected by this read but not on the region from pos to
2375          * pos+len-1.
2376          */
2377
2378         return cifs_user_readv(iocb, iov, nr_segs, pos);
2379 }
2380
2381 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2382                          loff_t *poffset)
2383 {
2384         int rc = -EACCES;
2385         unsigned int bytes_read = 0;
2386         unsigned int total_read;
2387         unsigned int current_read_size;
2388         unsigned int rsize;
2389         struct cifs_sb_info *cifs_sb;
2390         struct cifs_tcon *pTcon;
2391         int xid;
2392         char *current_offset;
2393         struct cifsFileInfo *open_file;
2394         struct cifs_io_parms io_parms;
2395         int buf_type = CIFS_NO_BUFFER;
2396         __u32 pid;
2397
2398         xid = GetXid();
2399         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2400
2401         /* FIXME: set up handlers for larger reads and/or convert to async */
2402         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2403
2404         if (file->private_data == NULL) {
2405                 rc = -EBADF;
2406                 FreeXid(xid);
2407                 return rc;
2408         }
2409         open_file = file->private_data;
2410         pTcon = tlink_tcon(open_file->tlink);
2411
2412         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2413                 pid = open_file->pid;
2414         else
2415                 pid = current->tgid;
2416
2417         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2418                 cFYI(1, "attempting read on write only file instance");
2419
2420         for (total_read = 0, current_offset = read_data;
2421              read_size > total_read;
2422              total_read += bytes_read, current_offset += bytes_read) {
2423                 current_read_size = min_t(uint, read_size - total_read, rsize);
2424
2425                 /* For windows me and 9x we do not want to request more
2426                 than it negotiated since it will refuse the read then */
2427                 if ((pTcon->ses) &&
2428                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2429                         current_read_size = min_t(uint, current_read_size,
2430                                         CIFSMaxBufSize);
2431                 }
2432                 rc = -EAGAIN;
2433                 while (rc == -EAGAIN) {
2434                         if (open_file->invalidHandle) {
2435                                 rc = cifs_reopen_file(open_file, true);
2436                                 if (rc != 0)
2437                                         break;
2438                         }
2439                         io_parms.netfid = open_file->netfid;
2440                         io_parms.pid = pid;
2441                         io_parms.tcon = pTcon;
2442                         io_parms.offset = *poffset;
2443                         io_parms.length = current_read_size;
2444                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2445                                          &current_offset, &buf_type);
2446                 }
2447                 if (rc || (bytes_read == 0)) {
2448                         if (total_read) {
2449                                 break;
2450                         } else {
2451                                 FreeXid(xid);
2452                                 return rc;
2453                         }
2454                 } else {
2455                         cifs_stats_bytes_read(pTcon, total_read);
2456                         *poffset += bytes_read;
2457                 }
2458         }
2459         FreeXid(xid);
2460         return total_read;
2461 }
2462
2463 /*
2464  * If the page is mmap'ed into a process' page tables, then we need to make
2465  * sure that it doesn't change while being written back.
2466  */
2467 static int
2468 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2469 {
2470         struct page *page = vmf->page;
2471
2472         lock_page(page);
2473         return VM_FAULT_LOCKED;
2474 }
2475
2476 static struct vm_operations_struct cifs_file_vm_ops = {
2477         .fault = filemap_fault,
2478         .page_mkwrite = cifs_page_mkwrite,
2479 };
2480
2481 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2482 {
2483         int rc, xid;
2484         struct inode *inode = file->f_path.dentry->d_inode;
2485
2486         xid = GetXid();
2487
2488         if (!CIFS_I(inode)->clientCanCacheRead) {
2489                 rc = cifs_invalidate_mapping(inode);
2490                 if (rc)
2491                         return rc;
2492         }
2493
2494         rc = generic_file_mmap(file, vma);
2495         if (rc == 0)
2496                 vma->vm_ops = &cifs_file_vm_ops;
2497         FreeXid(xid);
2498         return rc;
2499 }
2500
2501 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2502 {
2503         int rc, xid;
2504
2505         xid = GetXid();
2506         rc = cifs_revalidate_file(file);
2507         if (rc) {
2508                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2509                 FreeXid(xid);
2510                 return rc;
2511         }
2512         rc = generic_file_mmap(file, vma);
2513         if (rc == 0)
2514                 vma->vm_ops = &cifs_file_vm_ops;
2515         FreeXid(xid);
2516         return rc;
2517 }
2518
2519 static int cifs_readpages(struct file *file, struct address_space *mapping,
2520         struct list_head *page_list, unsigned num_pages)
2521 {
2522         int rc;
2523         struct list_head tmplist;
2524         struct cifsFileInfo *open_file = file->private_data;
2525         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2526         unsigned int rsize = cifs_sb->rsize;
2527         pid_t pid;
2528
2529         /*
2530          * Give up immediately if rsize is too small to read an entire page.
2531          * The VFS will fall back to readpage. We should never reach this
2532          * point however since we set ra_pages to 0 when the rsize is smaller
2533          * than a cache page.
2534          */
2535         if (unlikely(rsize < PAGE_CACHE_SIZE))
2536                 return 0;
2537
2538         /*
2539          * Reads as many pages as possible from fscache. Returns -ENOBUFS
2540          * immediately if the cookie is negative
2541          */
2542         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2543                                          &num_pages);
2544         if (rc == 0)
2545                 return rc;
2546
2547         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2548                 pid = open_file->pid;
2549         else
2550                 pid = current->tgid;
2551
2552         rc = 0;
2553         INIT_LIST_HEAD(&tmplist);
2554
2555         cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2556                 mapping, num_pages);
2557
2558         /*
2559          * Start with the page at end of list and move it to private
2560          * list. Do the same with any following pages until we hit
2561          * the rsize limit, hit an index discontinuity, or run out of
2562          * pages. Issue the async read and then start the loop again
2563          * until the list is empty.
2564          *
2565          * Note that list order is important. The page_list is in
2566          * the order of declining indexes. When we put the pages in
2567          * the rdata->pages, then we want them in increasing order.
2568          */
2569         while (!list_empty(page_list)) {
2570                 unsigned int bytes = PAGE_CACHE_SIZE;
2571                 unsigned int expected_index;
2572                 unsigned int nr_pages = 1;
2573                 loff_t offset;
2574                 struct page *page, *tpage;
2575                 struct cifs_readdata *rdata;
2576
2577                 page = list_entry(page_list->prev, struct page, lru);
2578
2579                 /*
2580                  * Lock the page and put it in the cache. Since no one else
2581                  * should have access to this page, we're safe to simply set
2582                  * PG_locked without checking it first.
2583                  */
2584                 __set_page_locked(page);
2585                 rc = add_to_page_cache_locked(page, mapping,
2586                                               page->index, GFP_KERNEL);
2587
2588                 /* give up if we can't stick it in the cache */
2589                 if (rc) {
2590                         __clear_page_locked(page);
2591                         break;
2592                 }
2593
2594                 /* move first page to the tmplist */
2595                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2596                 list_move_tail(&page->lru, &tmplist);
2597
2598                 /* now try and add more pages onto the request */
2599                 expected_index = page->index + 1;
2600                 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2601                         /* discontinuity ? */
2602                         if (page->index != expected_index)
2603                                 break;
2604
2605                         /* would this page push the read over the rsize? */
2606                         if (bytes + PAGE_CACHE_SIZE > rsize)
2607                                 break;
2608
2609                         __set_page_locked(page);
2610                         if (add_to_page_cache_locked(page, mapping,
2611                                                 page->index, GFP_KERNEL)) {
2612                                 __clear_page_locked(page);
2613                                 break;
2614                         }
2615                         list_move_tail(&page->lru, &tmplist);
2616                         bytes += PAGE_CACHE_SIZE;
2617                         expected_index++;
2618                         nr_pages++;
2619                 }
2620
2621                 rdata = cifs_readdata_alloc(nr_pages);
2622                 if (!rdata) {
2623                         /* best to give up if we're out of mem */
2624                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2625                                 list_del(&page->lru);
2626                                 lru_cache_add_file(page);
2627                                 unlock_page(page);
2628                                 page_cache_release(page);
2629                         }
2630                         rc = -ENOMEM;
2631                         break;
2632                 }
2633
2634                 spin_lock(&cifs_file_list_lock);
2635                 cifsFileInfo_get(open_file);
2636                 spin_unlock(&cifs_file_list_lock);
2637                 rdata->cfile = open_file;
2638                 rdata->mapping = mapping;
2639                 rdata->offset = offset;
2640                 rdata->bytes = bytes;
2641                 rdata->pid = pid;
2642                 list_splice_init(&tmplist, &rdata->pages);
2643
2644                 do {
2645                         if (open_file->invalidHandle) {
2646                                 rc = cifs_reopen_file(open_file, true);
2647                                 if (rc != 0)
2648                                         continue;
2649                         }
2650                         rc = cifs_async_readv(rdata);
2651                 } while (rc == -EAGAIN);
2652
2653                 if (rc != 0) {
2654                         list_for_each_entry_safe(page, tpage, &rdata->pages,
2655                                                  lru) {
2656                                 list_del(&page->lru);
2657                                 lru_cache_add_file(page);
2658                                 unlock_page(page);
2659                                 page_cache_release(page);
2660                         }
2661                         cifs_readdata_free(rdata);
2662                         break;
2663                 }
2664         }
2665
2666         return rc;
2667 }
2668
2669 static int cifs_readpage_worker(struct file *file, struct page *page,
2670         loff_t *poffset)
2671 {
2672         char *read_data;
2673         int rc;
2674
2675         /* Is the page cached? */
2676         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2677         if (rc == 0)
2678                 goto read_complete;
2679
2680         page_cache_get(page);
2681         read_data = kmap(page);
2682         /* for reads over a certain size could initiate async read ahead */
2683
2684         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2685
2686         if (rc < 0)
2687                 goto io_error;
2688         else
2689                 cFYI(1, "Bytes read %d", rc);
2690
2691         file->f_path.dentry->d_inode->i_atime =
2692                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2693
2694         if (PAGE_CACHE_SIZE > rc)
2695                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2696
2697         flush_dcache_page(page);
2698         SetPageUptodate(page);
2699
2700         /* send this page to the cache */
2701         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2702
2703         rc = 0;
2704
2705 io_error:
2706         kunmap(page);
2707         page_cache_release(page);
2708
2709 read_complete:
2710         return rc;
2711 }
2712
2713 static int cifs_readpage(struct file *file, struct page *page)
2714 {
2715         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2716         int rc = -EACCES;
2717         int xid;
2718
2719         xid = GetXid();
2720
2721         if (file->private_data == NULL) {
2722                 rc = -EBADF;
2723                 FreeXid(xid);
2724                 return rc;
2725         }
2726
2727         cFYI(1, "readpage %p at offset %d 0x%x\n",
2728                  page, (int)offset, (int)offset);
2729
2730         rc = cifs_readpage_worker(file, page, &offset);
2731
2732         unlock_page(page);
2733
2734         FreeXid(xid);
2735         return rc;
2736 }
2737
2738 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2739 {
2740         struct cifsFileInfo *open_file;
2741
2742         spin_lock(&cifs_file_list_lock);
2743         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2744                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2745                         spin_unlock(&cifs_file_list_lock);
2746                         return 1;
2747                 }
2748         }
2749         spin_unlock(&cifs_file_list_lock);
2750         return 0;
2751 }
2752
2753 /* We do not want to update the file size from server for inodes
2754    open for write - to avoid races with writepage extending
2755    the file - in the future we could consider allowing
2756    refreshing the inode only on increases in the file size
2757    but this is tricky to do without racing with writebehind
2758    page caching in the current Linux kernel design */
2759 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2760 {
2761         if (!cifsInode)
2762                 return true;
2763
2764         if (is_inode_writable(cifsInode)) {
2765                 /* This inode is open for write at least once */
2766                 struct cifs_sb_info *cifs_sb;
2767
2768                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2769                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2770                         /* since no page cache to corrupt on directio
2771                         we can change size safely */
2772                         return true;
2773                 }
2774
2775                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2776                         return true;
2777
2778                 return false;
2779         } else
2780                 return true;
2781 }
2782
2783 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2784                         loff_t pos, unsigned len, unsigned flags,
2785                         struct page **pagep, void **fsdata)
2786 {
2787         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2788         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2789         loff_t page_start = pos & PAGE_MASK;
2790         loff_t i_size;
2791         struct page *page;
2792         int rc = 0;
2793
2794         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2795
2796         page = grab_cache_page_write_begin(mapping, index, flags);
2797         if (!page) {
2798                 rc = -ENOMEM;
2799                 goto out;
2800         }
2801
2802         if (PageUptodate(page))
2803                 goto out;
2804
2805         /*
2806          * If we write a full page it will be up to date, no need to read from
2807          * the server. If the write is short, we'll end up doing a sync write
2808          * instead.
2809          */
2810         if (len == PAGE_CACHE_SIZE)
2811                 goto out;
2812
2813         /*
2814          * optimize away the read when we have an oplock, and we're not
2815          * expecting to use any of the data we'd be reading in. That
2816          * is, when the page lies beyond the EOF, or straddles the EOF
2817          * and the write will cover all of the existing data.
2818          */
2819         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2820                 i_size = i_size_read(mapping->host);
2821                 if (page_start >= i_size ||
2822                     (offset == 0 && (pos + len) >= i_size)) {
2823                         zero_user_segments(page, 0, offset,
2824                                            offset + len,
2825                                            PAGE_CACHE_SIZE);
2826                         /*
2827                          * PageChecked means that the parts of the page
2828                          * to which we're not writing are considered up
2829                          * to date. Once the data is copied to the
2830                          * page, it can be set uptodate.
2831                          */
2832                         SetPageChecked(page);
2833                         goto out;
2834                 }
2835         }
2836
2837         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2838                 /*
2839                  * might as well read a page, it is fast enough. If we get
2840                  * an error, we don't need to return it. cifs_write_end will
2841                  * do a sync write instead since PG_uptodate isn't set.
2842                  */
2843                 cifs_readpage_worker(file, page, &page_start);
2844         } else {
2845                 /* we could try using another file handle if there is one -
2846                    but how would we lock it to prevent close of that handle
2847                    racing with this read? In any case
2848                    this will be written out by write_end so is fine */
2849         }
2850 out:
2851         *pagep = page;
2852         return rc;
2853 }
2854
2855 static int cifs_release_page(struct page *page, gfp_t gfp)
2856 {
2857         if (PagePrivate(page))
2858                 return 0;
2859
2860         return cifs_fscache_release_page(page, gfp);
2861 }
2862
2863 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2864 {
2865         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2866
2867         if (offset == 0)
2868                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2869 }
2870
2871 static int cifs_launder_page(struct page *page)
2872 {
2873         int rc = 0;
2874         loff_t range_start = page_offset(page);
2875         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2876         struct writeback_control wbc = {
2877                 .sync_mode = WB_SYNC_ALL,
2878                 .nr_to_write = 0,
2879                 .range_start = range_start,
2880                 .range_end = range_end,
2881         };
2882
2883         cFYI(1, "Launder page: %p", page);
2884
2885         if (clear_page_dirty_for_io(page))
2886                 rc = cifs_writepage_locked(page, &wbc);
2887
2888         cifs_fscache_invalidate_page(page, page->mapping->host);
2889         return rc;
2890 }
2891
2892 void cifs_oplock_break(struct work_struct *work)
2893 {
2894         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2895                                                   oplock_break);
2896         struct inode *inode = cfile->dentry->d_inode;
2897         struct cifsInodeInfo *cinode = CIFS_I(inode);
2898         int rc = 0;
2899
2900         if (inode && S_ISREG(inode->i_mode)) {
2901                 if (cinode->clientCanCacheRead)
2902                         break_lease(inode, O_RDONLY);
2903                 else
2904                         break_lease(inode, O_WRONLY);
2905                 rc = filemap_fdatawrite(inode->i_mapping);
2906                 if (cinode->clientCanCacheRead == 0) {
2907                         rc = filemap_fdatawait(inode->i_mapping);
2908                         mapping_set_error(inode->i_mapping, rc);
2909                         invalidate_remote_inode(inode);
2910                 }
2911                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2912         }
2913
2914         rc = cifs_push_locks(cfile);
2915         if (rc)
2916                 cERROR(1, "Push locks rc = %d", rc);
2917
2918         /*
2919          * releasing stale oplock after recent reconnect of smb session using
2920          * a now incorrect file handle is not a data integrity issue but do
2921          * not bother sending an oplock release if session to server still is
2922          * disconnected since oplock already released by the server
2923          */
2924         if (!cfile->oplock_break_cancelled) {
2925                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2926                                  current->tgid, 0, 0, 0, 0,
2927                                  LOCKING_ANDX_OPLOCK_RELEASE, false,
2928                                  cinode->clientCanCacheRead ? 1 : 0);
2929                 cFYI(1, "Oplock release rc = %d", rc);
2930         }
2931 }
2932
2933 const struct address_space_operations cifs_addr_ops = {
2934         .readpage = cifs_readpage,
2935         .readpages = cifs_readpages,
2936         .writepage = cifs_writepage,
2937         .writepages = cifs_writepages,
2938         .write_begin = cifs_write_begin,
2939         .write_end = cifs_write_end,
2940         .set_page_dirty = __set_page_dirty_nobuffers,
2941         .releasepage = cifs_release_page,
2942         .invalidatepage = cifs_invalidate_page,
2943         .launder_page = cifs_launder_page,
2944 };
2945
2946 /*
2947  * cifs_readpages requires the server to support a buffer large enough to
2948  * contain the header plus one complete page of data.  Otherwise, we need
2949  * to leave cifs_readpages out of the address space operations.
2950  */
2951 const struct address_space_operations cifs_addr_ops_smallbuf = {
2952         .readpage = cifs_readpage,
2953         .writepage = cifs_writepage,
2954         .writepages = cifs_writepages,
2955         .write_begin = cifs_write_begin,
2956         .write_end = cifs_write_end,
2957         .set_page_dirty = __set_page_dirty_nobuffers,
2958         .releasepage = cifs_release_page,
2959         .invalidatepage = cifs_invalidate_page,
2960         .launder_page = cifs_launder_page,
2961 };