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