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