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