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