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