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