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