blob: a83541ec97131af495e339dfa1e0a482d98dee72 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/file.c
3 *
4 * vfs operations that deal with files
Steve Frenchfb8c4b12007-07-10 01:16:18 +00005 *
Steve Frenchf19159d2010-04-21 04:12:10 +00006 * Copyright (C) International Business Machines Corp., 2002,2010
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Author(s): Steve French (sfrench@us.ibm.com)
Jeremy Allison7ee1af72006-08-02 21:56:33 +00008 * Jeremy Allison (jra@samba.org)
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
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>
Steve French37c0eb42005-10-05 14:50:29 -070025#include <linux/backing-dev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/stat.h>
27#include <linux/fcntl.h>
28#include <linux/pagemap.h>
29#include <linux/pagevec.h>
Steve French37c0eb42005-10-05 14:50:29 -070030#include <linux/writeback.h>
Andrew Morton6f88cc22006-12-10 02:19:44 -080031#include <linux/task_io_accounting_ops.h>
Steve French23e7dd72005-10-20 13:44:56 -070032#include <linux/delay.h>
Jeff Layton3bc303c2009-09-21 06:47:50 -040033#include <linux/mount.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090034#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#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
Linus Torvalds1da177e2005-04-16 15:20:36 -070044static inline int cifs_convert_flags(unsigned int flags)
45{
46 if ((flags & O_ACCMODE) == O_RDONLY)
47 return GENERIC_READ;
48 else if ((flags & O_ACCMODE) == O_WRONLY)
49 return GENERIC_WRITE;
50 else if ((flags & O_ACCMODE) == O_RDWR) {
51 /* GENERIC_ALL is too much permission to request
52 can cause unnecessary access denied on create */
53 /* return GENERIC_ALL; */
54 return (GENERIC_READ | GENERIC_WRITE);
55 }
56
Jeff Laytone10f7b52008-05-14 10:21:33 -070057 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
58 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
59 FILE_READ_DATA);
Steve French7fc8f4e2009-02-23 20:43:11 +000060}
Jeff Laytone10f7b52008-05-14 10:21:33 -070061
Steve French7fc8f4e2009-02-23 20:43:11 +000062static inline fmode_t cifs_posix_convert_flags(unsigned int flags)
63{
64 fmode_t posix_flags = 0;
Jeff Laytone10f7b52008-05-14 10:21:33 -070065
Steve French7fc8f4e2009-02-23 20:43:11 +000066 if ((flags & O_ACCMODE) == O_RDONLY)
67 posix_flags = FMODE_READ;
68 else if ((flags & O_ACCMODE) == O_WRONLY)
69 posix_flags = FMODE_WRITE;
70 else if ((flags & O_ACCMODE) == O_RDWR) {
71 /* GENERIC_ALL is too much permission to request
72 can cause unnecessary access denied on create */
73 /* return GENERIC_ALL; */
74 posix_flags = FMODE_READ | FMODE_WRITE;
75 }
76 /* can not map O_CREAT or O_EXCL or O_TRUNC flags when
77 reopening a file. They had their effect on the original open */
78 if (flags & O_APPEND)
79 posix_flags |= (fmode_t)O_APPEND;
Christoph Hellwig6b2f3d12009-10-27 11:05:28 +010080 if (flags & O_DSYNC)
81 posix_flags |= (fmode_t)O_DSYNC;
82 if (flags & __O_SYNC)
83 posix_flags |= (fmode_t)__O_SYNC;
Steve French7fc8f4e2009-02-23 20:43:11 +000084 if (flags & O_DIRECTORY)
85 posix_flags |= (fmode_t)O_DIRECTORY;
86 if (flags & O_NOFOLLOW)
87 posix_flags |= (fmode_t)O_NOFOLLOW;
88 if (flags & O_DIRECT)
89 posix_flags |= (fmode_t)O_DIRECT;
90
91 return posix_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092}
93
94static inline int cifs_get_disposition(unsigned int flags)
95{
96 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
97 return FILE_CREATE;
98 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
99 return FILE_OVERWRITE_IF;
100 else if ((flags & O_CREAT) == O_CREAT)
101 return FILE_OPEN_IF;
Steve French55aa2e02006-05-30 18:09:31 +0000102 else if ((flags & O_TRUNC) == O_TRUNC)
103 return FILE_OVERWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 else
105 return FILE_OPEN;
106}
107
108/* all arguments to this function must be checked for validity in caller */
Jeff Layton590a3fe2009-09-12 11:54:28 -0400109static inline int
110cifs_posix_open_inode_helper(struct inode *inode, struct file *file,
Suresh Jayaraman51c81762010-05-10 15:15:24 +0530111 struct cifsInodeInfo *pCifsInode, __u32 oplock,
Jeff Layton590a3fe2009-09-12 11:54:28 -0400112 u16 netfid)
Steve French276a74a2009-03-03 18:00:34 +0000113{
Steve French276a74a2009-03-03 18:00:34 +0000114
Steve French276a74a2009-03-03 18:00:34 +0000115 write_lock(&GlobalSMBSeslock);
Steve French276a74a2009-03-03 18:00:34 +0000116
117 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
118 if (pCifsInode == NULL) {
119 write_unlock(&GlobalSMBSeslock);
120 return -EINVAL;
121 }
122
Steve French276a74a2009-03-03 18:00:34 +0000123 if (pCifsInode->clientCanCacheRead) {
124 /* we have the inode open somewhere else
125 no need to discard cache data */
126 goto psx_client_can_cache;
127 }
128
129 /* BB FIXME need to fix this check to move it earlier into posix_open
130 BB fIX following section BB FIXME */
131
132 /* if not oplocked, invalidate inode pages if mtime or file
133 size changed */
134/* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
135 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
136 (file->f_path.dentry->d_inode->i_size ==
137 (loff_t)le64_to_cpu(buf->EndOfFile))) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000138 cFYI(1, "inode unchanged on server");
Steve French276a74a2009-03-03 18:00:34 +0000139 } else {
140 if (file->f_path.dentry->d_inode->i_mapping) {
141 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
142 if (rc != 0)
143 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
144 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000145 cFYI(1, "invalidating remote inode since open detected it "
146 "changed");
Steve French276a74a2009-03-03 18:00:34 +0000147 invalidate_remote_inode(file->f_path.dentry->d_inode);
148 } */
149
150psx_client_can_cache:
151 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
152 pCifsInode->clientCanCacheAll = true;
153 pCifsInode->clientCanCacheRead = true;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000154 cFYI(1, "Exclusive Oplock granted on inode %p",
155 file->f_path.dentry->d_inode);
Steve French276a74a2009-03-03 18:00:34 +0000156 } else if ((oplock & 0xF) == OPLOCK_READ)
157 pCifsInode->clientCanCacheRead = true;
158
159 /* will have to change the unlock if we reenable the
160 filemap_fdatawrite (which does not seem necessary */
161 write_unlock(&GlobalSMBSeslock);
162 return 0;
163}
164
Steve French703a3b82009-05-21 22:21:53 +0000165static struct cifsFileInfo *
166cifs_fill_filedata(struct file *file)
167{
168 struct list_head *tmp;
169 struct cifsFileInfo *pCifsFile = NULL;
170 struct cifsInodeInfo *pCifsInode = NULL;
171
172 /* search inode for this file and fill in file->private_data */
173 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
174 read_lock(&GlobalSMBSeslock);
175 list_for_each(tmp, &pCifsInode->openFileList) {
176 pCifsFile = list_entry(tmp, struct cifsFileInfo, flist);
177 if ((pCifsFile->pfile == NULL) &&
178 (pCifsFile->pid == current->tgid)) {
179 /* mode set in cifs_create */
180
181 /* needed for writepage */
182 pCifsFile->pfile = file;
183 file->private_data = pCifsFile;
184 break;
185 }
186 }
187 read_unlock(&GlobalSMBSeslock);
188
189 if (file->private_data != NULL) {
190 return pCifsFile;
191 } else if ((file->f_flags & O_CREAT) && (file->f_flags & O_EXCL))
Joe Perchesb6b38f72010-04-21 03:50:45 +0000192 cERROR(1, "could not find file instance for "
193 "new file %p", file);
Steve French703a3b82009-05-21 22:21:53 +0000194 return NULL;
195}
196
Steve French276a74a2009-03-03 18:00:34 +0000197/* all arguments to this function must be checked for validity in caller */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
199 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
200 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
201 char *full_path, int xid)
202{
203 struct timespec temp;
204 int rc;
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 if (pCifsInode->clientCanCacheRead) {
207 /* we have the inode open somewhere else
208 no need to discard cache data */
209 goto client_can_cache;
210 }
211
212 /* BB need same check in cifs_create too? */
213 /* if not oplocked, invalidate inode pages if mtime or file
214 size changed */
Jeff Layton07119a42009-05-27 09:37:33 -0400215 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800216 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
217 (file->f_path.dentry->d_inode->i_size ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 (loff_t)le64_to_cpu(buf->EndOfFile))) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000219 cFYI(1, "inode unchanged on server");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 } else {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800221 if (file->f_path.dentry->d_inode->i_mapping) {
Steve Frenchff2157132010-03-09 20:30:42 +0000222 /* BB no need to lock inode until after invalidate
223 since namei code should already have it locked? */
Jeff Laytoncea21802007-11-20 23:19:03 +0000224 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
225 if (rc != 0)
226 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000228 cFYI(1, "invalidating remote inode since open detected it "
229 "changed");
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800230 invalidate_remote_inode(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 }
232
233client_can_cache:
Steve Frenchc18c8422007-07-18 23:21:09 +0000234 if (pTcon->unix_ext)
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800235 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 full_path, inode->i_sb, xid);
237 else
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800238 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
Steve French8b1327f2008-03-14 22:37:16 +0000239 full_path, buf, inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000242 pCifsInode->clientCanCacheAll = true;
243 pCifsInode->clientCanCacheRead = true;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000244 cFYI(1, "Exclusive Oplock granted on inode %p",
245 file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 } else if ((*oplock & 0xF) == OPLOCK_READ)
Steve French4b18f2a2008-04-29 00:06:05 +0000247 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
249 return rc;
250}
251
252int cifs_open(struct inode *inode, struct file *file)
253{
254 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400255 int xid;
256 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 struct cifs_sb_info *cifs_sb;
Steve French276a74a2009-03-03 18:00:34 +0000258 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 struct cifsFileInfo *pCifsFile;
260 struct cifsInodeInfo *pCifsInode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 char *full_path = NULL;
262 int desiredAccess;
263 int disposition;
264 __u16 netfid;
265 FILE_ALL_INFO *buf = NULL;
266
267 xid = GetXid();
268
269 cifs_sb = CIFS_SB(inode->i_sb);
Steve French276a74a2009-03-03 18:00:34 +0000270 tcon = cifs_sb->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
Steve Frencha6ce4932009-04-09 01:14:32 +0000272 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Steve French703a3b82009-05-21 22:21:53 +0000273 pCifsFile = cifs_fill_filedata(file);
274 if (pCifsFile) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530275 rc = 0;
Steve Frencha6ce4932009-04-09 01:14:32 +0000276 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530277 return rc;
Steve French703a3b82009-05-21 22:21:53 +0000278 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800280 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530282 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530284 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 }
286
Joe Perchesb6b38f72010-04-21 03:50:45 +0000287 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
288 inode, file->f_flags, full_path);
Steve French276a74a2009-03-03 18:00:34 +0000289
290 if (oplockEnabled)
291 oplock = REQ_OPLOCK;
292 else
293 oplock = 0;
294
Steve French64cc2c62009-03-04 19:54:08 +0000295 if (!tcon->broken_posix_open && tcon->unix_ext &&
296 (tcon->ses->capabilities & CAP_UNIX) &&
Steve French276a74a2009-03-03 18:00:34 +0000297 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
298 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
299 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
Steve Frenchfa588e02010-04-22 19:21:55 +0000300 oflags |= SMB_O_CREAT;
Steve French276a74a2009-03-03 18:00:34 +0000301 /* can not refresh inode info since size could be stale */
Jeff Layton3bc303c2009-09-21 06:47:50 -0400302 rc = cifs_posix_open(full_path, &inode, file->f_path.mnt,
Steve Frenchfa588e02010-04-22 19:21:55 +0000303 inode->i_sb,
304 cifs_sb->mnt_file_mode /* ignored */,
305 oflags, &oplock, &netfid, xid);
Steve French276a74a2009-03-03 18:00:34 +0000306 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000307 cFYI(1, "posix open succeeded");
Steve French276a74a2009-03-03 18:00:34 +0000308 /* no need for special case handling of setting mode
309 on read only files needed here */
310
Steve French703a3b82009-05-21 22:21:53 +0000311 pCifsFile = cifs_fill_filedata(file);
Steve French276a74a2009-03-03 18:00:34 +0000312 cifs_posix_open_inode_helper(inode, file, pCifsInode,
Suresh Jayaraman51c81762010-05-10 15:15:24 +0530313 oplock, netfid);
Steve French276a74a2009-03-03 18:00:34 +0000314 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000315 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
316 if (tcon->ses->serverNOS)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000317 cERROR(1, "server %s of type %s returned"
Steve French64cc2c62009-03-04 19:54:08 +0000318 " unexpected error on SMB posix open"
319 ", disabling posix open support."
320 " Check if server update available.",
321 tcon->ses->serverName,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000322 tcon->ses->serverNOS);
Steve French64cc2c62009-03-04 19:54:08 +0000323 tcon->broken_posix_open = true;
Steve French276a74a2009-03-03 18:00:34 +0000324 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
325 (rc != -EOPNOTSUPP)) /* path not found or net err */
326 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000327 /* else fallthrough to retry open the old way on network i/o
328 or DFS errors */
Steve French276a74a2009-03-03 18:00:34 +0000329 }
330
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 desiredAccess = cifs_convert_flags(file->f_flags);
332
333/*********************************************************************
334 * open flag mapping table:
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000335 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 * POSIX Flag CIFS Disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000337 * ---------- ----------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 * O_CREAT FILE_OPEN_IF
339 * O_CREAT | O_EXCL FILE_CREATE
340 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
341 * O_TRUNC FILE_OVERWRITE
342 * none of the above FILE_OPEN
343 *
344 * Note that there is not a direct match between disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000345 * FILE_SUPERSEDE (ie create whether or not file exists although
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 * O_CREAT | O_TRUNC is similar but truncates the existing
347 * file rather than creating a new file as FILE_SUPERSEDE does
348 * (which uses the attributes / metadata passed in on open call)
349 *?
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000350 *? O_SYNC is a reasonable match to CIFS writethrough flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 *? and the read write flags match reasonably. O_LARGEFILE
352 *? is irrelevant because largefile support is always used
353 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
354 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
355 *********************************************************************/
356
357 disposition = cifs_get_disposition(file->f_flags);
358
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 /* BB pass O_SYNC flag through on file attributes .. BB */
360
361 /* Also refresh inode by passing in file_info buf returned by SMBOpen
362 and calling get_inode_info with returned buf (at least helps
363 non-Unix server case) */
364
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000365 /* BB we can not do this if this is the second open of a file
366 and the first handle has writebehind data, we might be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
368 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
369 if (!buf) {
370 rc = -ENOMEM;
371 goto out;
372 }
Steve French5bafd762006-06-07 00:18:43 +0000373
374 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
Steve French276a74a2009-03-03 18:00:34 +0000375 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
Steve French5bafd762006-06-07 00:18:43 +0000376 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
Steve French737b7582005-04-28 22:41:06 -0700377 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
378 & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000379 else
380 rc = -EIO; /* no NT SMB support fall into legacy open below */
381
Steve Frencha9d02ad2005-08-24 23:06:05 -0700382 if (rc == -EIO) {
383 /* Old server, try legacy style OpenX */
Steve French276a74a2009-03-03 18:00:34 +0000384 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
Steve Frencha9d02ad2005-08-24 23:06:05 -0700385 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
386 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
387 & CIFS_MOUNT_MAP_SPECIAL_CHR);
388 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000390 cFYI(1, "cifs_open returned 0x%x", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 goto out;
392 }
Jeff Layton3321b792009-09-25 09:53:37 -0400393
Jeff Layton086f68b2009-09-21 14:08:18 -0400394 pCifsFile = cifs_new_fileinfo(inode, netfid, file, file->f_path.mnt,
395 file->f_flags);
396 file->private_data = pCifsFile;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 if (file->private_data == NULL) {
398 rc = -ENOMEM;
399 goto out;
400 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
Jeff Layton3321b792009-09-25 09:53:37 -0400402 rc = cifs_open_inode_helper(inode, file, pCifsInode, pCifsFile, tcon,
403 &oplock, buf, full_path, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000405 if (oplock & CIFS_CREATE_ACTION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 /* time to set mode which we can not set earlier due to
407 problems creating new read-only files */
Steve French276a74a2009-03-03 18:00:34 +0000408 if (tcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400409 struct cifs_unix_set_info_args args = {
410 .mode = inode->i_mode,
411 .uid = NO_CHANGE_64,
412 .gid = NO_CHANGE_64,
413 .ctime = NO_CHANGE_64,
414 .atime = NO_CHANGE_64,
415 .mtime = NO_CHANGE_64,
416 .device = 0,
417 };
Jeff Layton01ea95e2009-07-09 20:02:49 -0400418 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
419 cifs_sb->local_nls,
420 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700421 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 }
423 }
424
425out:
426 kfree(buf);
427 kfree(full_path);
428 FreeXid(xid);
429 return rc;
430}
431
Adrian Bunk04187262006-06-30 18:23:04 +0200432/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433/* to server was lost */
434static int cifs_relock_file(struct cifsFileInfo *cifsFile)
435{
436 int rc = 0;
437
438/* BB list all locks open on this file and relock */
439
440 return rc;
441}
442
Steve French4b18f2a2008-04-29 00:06:05 +0000443static int cifs_reopen_file(struct file *file, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444{
445 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400446 int xid;
447 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 struct cifs_sb_info *cifs_sb;
Steve French7fc8f4e2009-02-23 20:43:11 +0000449 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 struct cifsFileInfo *pCifsFile;
451 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000452 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 char *full_path = NULL;
454 int desiredAccess;
455 int disposition = FILE_OPEN;
456 __u16 netfid;
457
Steve Frenchad7a2922008-02-07 23:25:02 +0000458 if (file->private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 pCifsFile = (struct cifsFileInfo *)file->private_data;
Steve Frenchad7a2922008-02-07 23:25:02 +0000460 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 return -EBADF;
462
463 xid = GetXid();
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400464 mutex_lock(&pCifsFile->fh_mutex);
Steve French4b18f2a2008-04-29 00:06:05 +0000465 if (!pCifsFile->invalidHandle) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400466 mutex_unlock(&pCifsFile->fh_mutex);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530467 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530469 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 }
471
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800472 if (file->f_path.dentry == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000473 cERROR(1, "no valid name if dentry freed");
Steve French3a9f4622007-04-04 17:10:24 +0000474 dump_stack();
475 rc = -EBADF;
476 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 }
Steve French3a9f4622007-04-04 17:10:24 +0000478
479 inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000480 if (inode == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000481 cERROR(1, "inode not valid");
Steve French3a9f4622007-04-04 17:10:24 +0000482 dump_stack();
483 rc = -EBADF;
484 goto reopen_error_exit;
485 }
Steve French50c2f752007-07-13 00:33:32 +0000486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 cifs_sb = CIFS_SB(inode->i_sb);
Steve French7fc8f4e2009-02-23 20:43:11 +0000488 tcon = cifs_sb->tcon;
Steve French3a9f4622007-04-04 17:10:24 +0000489
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490/* can not grab rename sem here because various ops, including
491 those that already have the rename sem can end up causing writepage
492 to get called and if the server was down that means we end up here,
493 and we can never tell if the caller already has the rename_sem */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800494 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000496 rc = -ENOMEM;
497reopen_error_exit:
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400498 mutex_unlock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000500 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 }
502
Joe Perchesb6b38f72010-04-21 03:50:45 +0000503 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
504 inode, file->f_flags, full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
506 if (oplockEnabled)
507 oplock = REQ_OPLOCK;
508 else
Steve French4b18f2a2008-04-29 00:06:05 +0000509 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
Steve French7fc8f4e2009-02-23 20:43:11 +0000511 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
512 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
513 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
514 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
515 /* can not refresh inode info since size could be stale */
Jeff Layton3bc303c2009-09-21 06:47:50 -0400516 rc = cifs_posix_open(full_path, NULL, file->f_path.mnt,
Steve Frenchfa588e02010-04-22 19:21:55 +0000517 inode->i_sb,
518 cifs_sb->mnt_file_mode /* ignored */,
519 oflags, &oplock, &netfid, xid);
Steve French7fc8f4e2009-02-23 20:43:11 +0000520 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000521 cFYI(1, "posix reopen succeeded");
Steve French7fc8f4e2009-02-23 20:43:11 +0000522 goto reopen_success;
523 }
524 /* fallthrough to retry open the old way on errors, especially
525 in the reconnect path it is important to retry hard */
526 }
527
528 desiredAccess = cifs_convert_flags(file->f_flags);
529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000531 by SMBOpen and then calling get_inode_info with returned buf
532 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 and server version of file size can be stale. If we knew for sure
534 that inode was not dirty locally we could do this */
535
Steve French7fc8f4e2009-02-23 20:43:11 +0000536 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 CREATE_NOT_DIR, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000538 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700539 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 if (rc) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400541 mutex_unlock(&pCifsFile->fh_mutex);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000542 cFYI(1, "cifs_open returned 0x%x", rc);
543 cFYI(1, "oplock: %d", oplock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 } else {
Steve French7fc8f4e2009-02-23 20:43:11 +0000545reopen_success:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 pCifsFile->netfid = netfid;
Steve French4b18f2a2008-04-29 00:06:05 +0000547 pCifsFile->invalidHandle = false;
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400548 mutex_unlock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 pCifsInode = CIFS_I(inode);
550 if (pCifsInode) {
551 if (can_flush) {
Jeff Laytoncea21802007-11-20 23:19:03 +0000552 rc = filemap_write_and_wait(inode->i_mapping);
553 if (rc != 0)
554 CIFS_I(inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 /* temporarily disable caching while we
556 go to server to get inode info */
Steve French4b18f2a2008-04-29 00:06:05 +0000557 pCifsInode->clientCanCacheAll = false;
558 pCifsInode->clientCanCacheRead = false;
Steve French7fc8f4e2009-02-23 20:43:11 +0000559 if (tcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 rc = cifs_get_inode_info_unix(&inode,
561 full_path, inode->i_sb, xid);
562 else
563 rc = cifs_get_inode_info(&inode,
564 full_path, NULL, inode->i_sb,
Steve French8b1327f2008-03-14 22:37:16 +0000565 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 } /* else we are writing out data to server already
567 and could deadlock if we tried to flush data, and
568 since we do not know if we have data that would
569 invalidate the current end of file on the server
570 we can not go to the server to get the new inod
571 info */
572 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000573 pCifsInode->clientCanCacheAll = true;
574 pCifsInode->clientCanCacheRead = true;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000575 cFYI(1, "Exclusive Oplock granted on inode %p",
576 file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 } else if ((oplock & 0xF) == OPLOCK_READ) {
Steve French4b18f2a2008-04-29 00:06:05 +0000578 pCifsInode->clientCanCacheRead = true;
579 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 } else {
Steve French4b18f2a2008-04-29 00:06:05 +0000581 pCifsInode->clientCanCacheRead = false;
582 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 }
584 cifs_relock_file(pCifsFile);
585 }
586 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 kfree(full_path);
588 FreeXid(xid);
589 return rc;
590}
591
592int cifs_close(struct inode *inode, struct file *file)
593{
594 int rc = 0;
Steve French15745322007-09-07 22:23:48 +0000595 int xid, timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 struct cifs_sb_info *cifs_sb;
597 struct cifsTconInfo *pTcon;
598 struct cifsFileInfo *pSMBFile =
599 (struct cifsFileInfo *)file->private_data;
600
601 xid = GetXid();
602
603 cifs_sb = CIFS_SB(inode->i_sb);
604 pTcon = cifs_sb->tcon;
605 if (pSMBFile) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000606 struct cifsLockInfo *li, *tmp;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000607 write_lock(&GlobalSMBSeslock);
Steve French4b18f2a2008-04-29 00:06:05 +0000608 pSMBFile->closePend = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 if (pTcon) {
610 /* no sense reconnecting to close a file that is
611 already closed */
Steve French3b795212008-11-13 19:45:32 +0000612 if (!pTcon->need_reconnect) {
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000613 write_unlock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +0000614 timeout = 2;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400615 while ((atomic_read(&pSMBFile->count) != 1)
Steve French15745322007-09-07 22:23:48 +0000616 && (timeout <= 2048)) {
Steve French23e7dd72005-10-20 13:44:56 -0700617 /* Give write a better chance to get to
618 server ahead of the close. We do not
619 want to add a wait_q here as it would
620 increase the memory utilization as
621 the struct would be in each open file,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000622 but this should give enough time to
Steve French23e7dd72005-10-20 13:44:56 -0700623 clear the socket */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000624 cFYI(DBG2, "close delay, write pending");
Steve French23e7dd72005-10-20 13:44:56 -0700625 msleep(timeout);
626 timeout *= 4;
Steve French4891d532006-11-07 16:31:16 +0000627 }
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000628 if (!pTcon->need_reconnect &&
629 !pSMBFile->invalidHandle)
630 rc = CIFSSMBClose(xid, pTcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 pSMBFile->netfid);
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000632 } else
633 write_unlock(&GlobalSMBSeslock);
634 } else
635 write_unlock(&GlobalSMBSeslock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000636
637 /* Delete any outstanding lock records.
638 We'll lose them when the file is closed anyway. */
Roland Dreier796e5662007-05-03 04:33:45 +0000639 mutex_lock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000640 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
641 list_del(&li->llist);
642 kfree(li);
643 }
Roland Dreier796e5662007-05-03 04:33:45 +0000644 mutex_unlock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000645
Steve Frenchcbe04762005-04-28 22:41:05 -0700646 write_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 list_del(&pSMBFile->flist);
648 list_del(&pSMBFile->tlist);
Steve Frenchcbe04762005-04-28 22:41:05 -0700649 write_unlock(&GlobalSMBSeslock);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400650 cifsFileInfo_put(file->private_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 file->private_data = NULL;
652 } else
653 rc = -EBADF;
654
Steve French4efa53f2007-09-11 05:50:53 +0000655 read_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 if (list_empty(&(CIFS_I(inode)->openFileList))) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000657 cFYI(1, "closing last open instance for inode %p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 /* if the file is not open we do not know if we can cache info
659 on this inode, much less write behind and read ahead */
Steve French4b18f2a2008-04-29 00:06:05 +0000660 CIFS_I(inode)->clientCanCacheRead = false;
661 CIFS_I(inode)->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 }
Steve French4efa53f2007-09-11 05:50:53 +0000663 read_unlock(&GlobalSMBSeslock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000664 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 rc = CIFS_I(inode)->write_behind_rc;
666 FreeXid(xid);
667 return rc;
668}
669
670int cifs_closedir(struct inode *inode, struct file *file)
671{
672 int rc = 0;
673 int xid;
674 struct cifsFileInfo *pCFileStruct =
675 (struct cifsFileInfo *)file->private_data;
676 char *ptmp;
677
Joe Perchesb6b38f72010-04-21 03:50:45 +0000678 cFYI(1, "Closedir inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
680 xid = GetXid();
681
682 if (pCFileStruct) {
683 struct cifsTconInfo *pTcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000684 struct cifs_sb_info *cifs_sb =
685 CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686
687 pTcon = cifs_sb->tcon;
688
Joe Perchesb6b38f72010-04-21 03:50:45 +0000689 cFYI(1, "Freeing private data in close dir");
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000690 write_lock(&GlobalSMBSeslock);
Steve French4b18f2a2008-04-29 00:06:05 +0000691 if (!pCFileStruct->srch_inf.endOfSearch &&
692 !pCFileStruct->invalidHandle) {
693 pCFileStruct->invalidHandle = true;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000694 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000696 cFYI(1, "Closing uncompleted readdir with rc %d",
697 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 /* not much we can do if it fails anyway, ignore rc */
699 rc = 0;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000700 } else
701 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
703 if (ptmp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000704 cFYI(1, "closedir free smb buf in srch struct");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000706 if (pCFileStruct->srch_inf.smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000707 cifs_small_buf_release(ptmp);
708 else
709 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 kfree(file->private_data);
712 file->private_data = NULL;
713 }
714 /* BB can we lock the filestruct while this is going on? */
715 FreeXid(xid);
716 return rc;
717}
718
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000719static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
720 __u64 offset, __u8 lockType)
721{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000722 struct cifsLockInfo *li =
723 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000724 if (li == NULL)
725 return -ENOMEM;
726 li->offset = offset;
727 li->length = len;
728 li->type = lockType;
Roland Dreier796e5662007-05-03 04:33:45 +0000729 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000730 list_add(&li->llist, &fid->llist);
Roland Dreier796e5662007-05-03 04:33:45 +0000731 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000732 return 0;
733}
734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
736{
737 int rc, xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738 __u32 numLock = 0;
739 __u32 numUnlock = 0;
740 __u64 length;
Steve French4b18f2a2008-04-29 00:06:05 +0000741 bool wait_flag = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 struct cifs_sb_info *cifs_sb;
Steve French13a6e422008-12-02 17:24:33 +0000743 struct cifsTconInfo *tcon;
Steve French08547b02006-02-28 22:39:25 +0000744 __u16 netfid;
745 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
Steve French13a6e422008-12-02 17:24:33 +0000746 bool posix_locking = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
748 length = 1 + pfLock->fl_end - pfLock->fl_start;
749 rc = -EACCES;
750 xid = GetXid();
751
Joe Perchesb6b38f72010-04-21 03:50:45 +0000752 cFYI(1, "Lock parm: 0x%x flockflags: "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 "0x%x flocktype: 0x%x start: %lld end: %lld",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000754 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000755 pfLock->fl_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
757 if (pfLock->fl_flags & FL_POSIX)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000758 cFYI(1, "Posix");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 if (pfLock->fl_flags & FL_FLOCK)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000760 cFYI(1, "Flock");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 if (pfLock->fl_flags & FL_SLEEP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000762 cFYI(1, "Blocking lock");
Steve French4b18f2a2008-04-29 00:06:05 +0000763 wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 }
765 if (pfLock->fl_flags & FL_ACCESS)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000766 cFYI(1, "Process suspended by mandatory locking - "
767 "not implemented yet");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 if (pfLock->fl_flags & FL_LEASE)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000769 cFYI(1, "Lease on file - not implemented yet");
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000770 if (pfLock->fl_flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
Joe Perchesb6b38f72010-04-21 03:50:45 +0000772 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
774 if (pfLock->fl_type == F_WRLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000775 cFYI(1, "F_WRLCK ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 numLock = 1;
777 } else if (pfLock->fl_type == F_UNLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000778 cFYI(1, "F_UNLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 numUnlock = 1;
Steve Frenchd47d7c12006-02-28 03:45:48 +0000780 /* Check if unlock includes more than
781 one lock range */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 } else if (pfLock->fl_type == F_RDLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000783 cFYI(1, "F_RDLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 lockType |= LOCKING_ANDX_SHARED_LOCK;
785 numLock = 1;
786 } else if (pfLock->fl_type == F_EXLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000787 cFYI(1, "F_EXLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 numLock = 1;
789 } else if (pfLock->fl_type == F_SHLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000790 cFYI(1, "F_SHLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 lockType |= LOCKING_ANDX_SHARED_LOCK;
792 numLock = 1;
793 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +0000794 cFYI(1, "Unknown type of lock");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800796 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Steve French13a6e422008-12-02 17:24:33 +0000797 tcon = cifs_sb->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798
799 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530800 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530802 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 }
Steve French08547b02006-02-28 22:39:25 +0000804 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805
Steve French13a6e422008-12-02 17:24:33 +0000806 if ((tcon->ses->capabilities & CAP_UNIX) &&
807 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
Steve Frenchacc18aa2008-12-02 18:53:55 +0000808 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
Steve French13a6e422008-12-02 17:24:33 +0000809 posix_locking = 1;
Steve French08547b02006-02-28 22:39:25 +0000810 /* BB add code here to normalize offset and length to
811 account for negative length which we can not accept over the
812 wire */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 if (IS_GETLK(cmd)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000814 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000815 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000816 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000817 posix_lock_type = CIFS_RDLCK;
818 else
819 posix_lock_type = CIFS_WRLCK;
Steve French13a6e422008-12-02 17:24:33 +0000820 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000821 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000822 posix_lock_type, wait_flag);
823 FreeXid(xid);
824 return rc;
825 }
826
827 /* BB we could chain these into one lock request BB */
Steve French13a6e422008-12-02 17:24:33 +0000828 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
Steve French08547b02006-02-28 22:39:25 +0000829 0, 1, lockType, 0 /* wait flag */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 if (rc == 0) {
Steve French13a6e422008-12-02 17:24:33 +0000831 rc = CIFSSMBLock(xid, tcon, netfid, length,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 pfLock->fl_start, 1 /* numUnlock */ ,
833 0 /* numLock */ , lockType,
834 0 /* wait flag */ );
835 pfLock->fl_type = F_UNLCK;
836 if (rc != 0)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000837 cERROR(1, "Error unlocking previously locked "
838 "range %d during test of lock", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 rc = 0;
840
841 } else {
842 /* if rc == ERR_SHARING_VIOLATION ? */
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400843 rc = 0;
844
845 if (lockType & LOCKING_ANDX_SHARED_LOCK) {
846 pfLock->fl_type = F_WRLCK;
847 } else {
848 rc = CIFSSMBLock(xid, tcon, netfid, length,
849 pfLock->fl_start, 0, 1,
850 lockType | LOCKING_ANDX_SHARED_LOCK,
851 0 /* wait flag */);
852 if (rc == 0) {
853 rc = CIFSSMBLock(xid, tcon, netfid,
854 length, pfLock->fl_start, 1, 0,
855 lockType |
856 LOCKING_ANDX_SHARED_LOCK,
857 0 /* wait flag */);
858 pfLock->fl_type = F_RDLCK;
859 if (rc != 0)
Steve Frenchf19159d2010-04-21 04:12:10 +0000860 cERROR(1, "Error unlocking "
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400861 "previously locked range %d "
Steve Frenchf19159d2010-04-21 04:12:10 +0000862 "during test of lock", rc);
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400863 rc = 0;
864 } else {
865 pfLock->fl_type = F_WRLCK;
866 rc = 0;
867 }
868 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 }
870
871 FreeXid(xid);
872 return rc;
873 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000874
875 if (!numLock && !numUnlock) {
876 /* if no lock or unlock then nothing
877 to do since we do not know what it is */
878 FreeXid(xid);
879 return -EOPNOTSUPP;
880 }
881
882 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000883 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000884 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000885 posix_lock_type = CIFS_RDLCK;
886 else
887 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +0000888
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000889 if (numUnlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +0000890 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000891
Steve French13a6e422008-12-02 17:24:33 +0000892 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000893 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000894 posix_lock_type, wait_flag);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000895 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000896 struct cifsFileInfo *fid =
897 (struct cifsFileInfo *)file->private_data;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000898
899 if (numLock) {
Steve French13a6e422008-12-02 17:24:33 +0000900 rc = CIFSSMBLock(xid, tcon, netfid, length,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000901 pfLock->fl_start,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000902 0, numLock, lockType, wait_flag);
903
904 if (rc == 0) {
905 /* For Windows locks we must store them. */
906 rc = store_file_lock(fid, length,
907 pfLock->fl_start, lockType);
908 }
909 } else if (numUnlock) {
910 /* For each stored lock that this unlock overlaps
911 completely, unlock it. */
912 int stored_rc = 0;
913 struct cifsLockInfo *li, *tmp;
914
Steve French6b70c952006-09-21 07:35:29 +0000915 rc = 0;
Roland Dreier796e5662007-05-03 04:33:45 +0000916 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000917 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
918 if (pfLock->fl_start <= li->offset &&
Steve Frenchc19eb712007-08-24 03:22:48 +0000919 (pfLock->fl_start + length) >=
Jeff Layton39db8102007-08-24 03:16:51 +0000920 (li->offset + li->length)) {
Steve French13a6e422008-12-02 17:24:33 +0000921 stored_rc = CIFSSMBLock(xid, tcon,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000922 netfid,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000923 li->length, li->offset,
Steve French4b18f2a2008-04-29 00:06:05 +0000924 1, 0, li->type, false);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000925 if (stored_rc)
926 rc = stored_rc;
Pavel Shilovsky2c964d12010-04-21 19:44:24 +0000927 else {
928 list_del(&li->llist);
929 kfree(li);
930 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000931 }
932 }
Roland Dreier796e5662007-05-03 04:33:45 +0000933 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000934 }
935 }
936
Steve Frenchd634cc12005-08-26 14:42:59 -0500937 if (pfLock->fl_flags & FL_POSIX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 posix_lock_file_wait(file, pfLock);
939 FreeXid(xid);
940 return rc;
941}
942
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400943/*
944 * Set the timeout on write requests past EOF. For some servers (Windows)
945 * these calls can be very long.
946 *
947 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
948 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
949 * The 10M cutoff is totally arbitrary. A better scheme for this would be
950 * welcome if someone wants to suggest one.
951 *
952 * We may be able to do a better job with this if there were some way to
953 * declare that a file should be sparse.
954 */
955static int
956cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
957{
958 if (offset <= cifsi->server_eof)
959 return CIFS_STD_OP;
960 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
961 return CIFS_VLONG_OP;
962 else
963 return CIFS_LONG_OP;
964}
965
966/* update the file size (if needed) after a write */
967static void
968cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
969 unsigned int bytes_written)
970{
971 loff_t end_of_write = offset + bytes_written;
972
973 if (end_of_write > cifsi->server_eof)
974 cifsi->server_eof = end_of_write;
975}
976
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977ssize_t cifs_user_write(struct file *file, const char __user *write_data,
978 size_t write_size, loff_t *poffset)
979{
980 int rc = 0;
981 unsigned int bytes_written = 0;
982 unsigned int total_written;
983 struct cifs_sb_info *cifs_sb;
984 struct cifsTconInfo *pTcon;
985 int xid, long_op;
986 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400987 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800989 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990
991 pTcon = cifs_sb->tcon;
992
Joe Perchesb6b38f72010-04-21 03:50:45 +0000993 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
994 *poffset, file->f_path.dentry->d_name.name); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995
996 if (file->private_data == NULL)
997 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000998 open_file = (struct cifsFileInfo *) file->private_data;
Steve French50c2f752007-07-13 00:33:32 +0000999
Jeff Layton838726c2008-08-28 07:54:59 -04001000 rc = generic_write_checks(file, poffset, &write_size, 0);
1001 if (rc)
1002 return rc;
1003
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001006 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 for (total_written = 0; write_size > total_written;
1008 total_written += bytes_written) {
1009 rc = -EAGAIN;
1010 while (rc == -EAGAIN) {
1011 if (file->private_data == NULL) {
1012 /* file has been closed on us */
1013 FreeXid(xid);
1014 /* if we have gotten here we have written some data
1015 and blocked, and the file has been freed on us while
1016 we blocked so return what we managed to write */
1017 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001018 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 if (open_file->closePend) {
1020 FreeXid(xid);
1021 if (total_written)
1022 return total_written;
1023 else
1024 return -EBADF;
1025 }
1026 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 /* we could deadlock if we called
1028 filemap_fdatawait from here so tell
1029 reopen_file not to flush data to server
1030 now */
Steve French4b18f2a2008-04-29 00:06:05 +00001031 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 if (rc != 0)
1033 break;
1034 }
1035
1036 rc = CIFSSMBWrite(xid, pTcon,
1037 open_file->netfid,
1038 min_t(const int, cifs_sb->wsize,
1039 write_size - total_written),
1040 *poffset, &bytes_written,
1041 NULL, write_data + total_written, long_op);
1042 }
1043 if (rc || (bytes_written == 0)) {
1044 if (total_written)
1045 break;
1046 else {
1047 FreeXid(xid);
1048 return rc;
1049 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001050 } else {
1051 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001053 }
Steve French133672e2007-11-13 22:41:37 +00001054 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 15 seconds is plenty */
1056 }
1057
Steve Frencha4544342005-08-24 13:59:35 -07001058 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059
1060 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001061 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1062 struct inode *inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001063/* Do not update local mtime - server will set its actual value on write
1064 * inode->i_ctime = inode->i_mtime =
Steve French3677db12007-02-26 16:46:11 +00001065 * current_fs_time(inode->i_sb);*/
1066 if (total_written > 0) {
1067 spin_lock(&inode->i_lock);
1068 if (*poffset > file->f_path.dentry->d_inode->i_size)
1069 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 *poffset);
Steve French3677db12007-02-26 16:46:11 +00001071 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001073 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 }
1075 FreeXid(xid);
1076 return total_written;
1077}
1078
1079static ssize_t cifs_write(struct file *file, const char *write_data,
Nick Piggind9414772008-09-24 11:32:59 -04001080 size_t write_size, loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081{
1082 int rc = 0;
1083 unsigned int bytes_written = 0;
1084 unsigned int total_written;
1085 struct cifs_sb_info *cifs_sb;
1086 struct cifsTconInfo *pTcon;
1087 int xid, long_op;
1088 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001089 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001091 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
1093 pTcon = cifs_sb->tcon;
1094
Joe Perchesb6b38f72010-04-21 03:50:45 +00001095 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1096 *poffset, file->f_path.dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097
1098 if (file->private_data == NULL)
1099 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +00001100 open_file = (struct cifsFileInfo *)file->private_data;
Steve French50c2f752007-07-13 00:33:32 +00001101
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001104 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 for (total_written = 0; write_size > total_written;
1106 total_written += bytes_written) {
1107 rc = -EAGAIN;
1108 while (rc == -EAGAIN) {
1109 if (file->private_data == NULL) {
1110 /* file has been closed on us */
1111 FreeXid(xid);
1112 /* if we have gotten here we have written some data
1113 and blocked, and the file has been freed on us
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001114 while we blocked so return what we managed to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 write */
1116 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001117 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 if (open_file->closePend) {
1119 FreeXid(xid);
1120 if (total_written)
1121 return total_written;
1122 else
1123 return -EBADF;
1124 }
1125 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 /* we could deadlock if we called
1127 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001128 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 server now */
Steve French4b18f2a2008-04-29 00:06:05 +00001130 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 if (rc != 0)
1132 break;
1133 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001134 if (experimEnabled || (pTcon->ses->server &&
1135 ((pTcon->ses->server->secMode &
Steve French08775832006-05-30 18:08:26 +00001136 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +00001137 == 0))) {
Steve French3e844692005-10-03 13:37:24 -07001138 struct kvec iov[2];
1139 unsigned int len;
1140
Steve French0ae0efa2005-10-10 10:57:19 -07001141 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -07001142 write_size - total_written);
1143 /* iov[0] is reserved for smb header */
1144 iov[1].iov_base = (char *)write_data +
1145 total_written;
1146 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001147 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -07001148 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001149 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -07001150 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001151 } else
Steve French60808232006-04-22 15:53:05 +00001152 rc = CIFSSMBWrite(xid, pTcon,
1153 open_file->netfid,
1154 min_t(const int, cifs_sb->wsize,
1155 write_size - total_written),
1156 *poffset, &bytes_written,
1157 write_data + total_written,
1158 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 }
1160 if (rc || (bytes_written == 0)) {
1161 if (total_written)
1162 break;
1163 else {
1164 FreeXid(xid);
1165 return rc;
1166 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001167 } else {
1168 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001170 }
Steve French133672e2007-11-13 22:41:37 +00001171 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172 15 seconds is plenty */
1173 }
1174
Steve Frencha4544342005-08-24 13:59:35 -07001175 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176
1177 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001178 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
Steve French004c46b2007-02-17 04:34:13 +00001179/*BB We could make this contingent on superblock ATIME flag too */
Steve French3677db12007-02-26 16:46:11 +00001180/* file->f_path.dentry->d_inode->i_ctime =
1181 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1182 if (total_written > 0) {
1183 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1184 if (*poffset > file->f_path.dentry->d_inode->i_size)
1185 i_size_write(file->f_path.dentry->d_inode,
1186 *poffset);
1187 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 }
Steve French3677db12007-02-26 16:46:11 +00001189 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 }
1191 FreeXid(xid);
1192 return total_written;
1193}
1194
Steve French630f3f0c2007-10-25 21:17:17 +00001195#ifdef CONFIG_CIFS_EXPERIMENTAL
1196struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1197{
1198 struct cifsFileInfo *open_file = NULL;
1199
1200 read_lock(&GlobalSMBSeslock);
1201 /* we could simply get the first_list_entry since write-only entries
1202 are always at the end of the list but since the first entry might
1203 have a close pending, we go through the whole list */
1204 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1205 if (open_file->closePend)
1206 continue;
1207 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1208 (open_file->pfile->f_flags & O_RDONLY))) {
1209 if (!open_file->invalidHandle) {
1210 /* found a good file */
1211 /* lock it so it will not be closed on us */
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001212 cifsFileInfo_get(open_file);
Steve French630f3f0c2007-10-25 21:17:17 +00001213 read_unlock(&GlobalSMBSeslock);
1214 return open_file;
1215 } /* else might as well continue, and look for
1216 another, or simply have the caller reopen it
1217 again rather than trying to fix this handle */
1218 } else /* write only file */
1219 break; /* write only files are last so must be done */
1220 }
1221 read_unlock(&GlobalSMBSeslock);
1222 return NULL;
1223}
1224#endif
1225
Steve Frenchdd99cd82005-10-05 19:32:49 -07001226struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
Steve French6148a742005-10-05 12:23:19 -07001227{
1228 struct cifsFileInfo *open_file;
Jeff Layton2846d382008-09-22 21:33:33 -04001229 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001230 int rc;
Steve French6148a742005-10-05 12:23:19 -07001231
Steve French60808232006-04-22 15:53:05 +00001232 /* Having a null inode here (because mapping->host was set to zero by
1233 the VFS or MM) should not happen but we had reports of on oops (due to
1234 it being zero) during stress testcases so we need to check for it */
1235
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001236 if (cifs_inode == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001237 cERROR(1, "Null inode passed to cifs_writeable_file");
Steve French60808232006-04-22 15:53:05 +00001238 dump_stack();
1239 return NULL;
1240 }
1241
Steve French6148a742005-10-05 12:23:19 -07001242 read_lock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001243refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001244 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2846d382008-09-22 21:33:33 -04001245 if (open_file->closePend ||
1246 (!any_available && open_file->pid != current->tgid))
Steve French6148a742005-10-05 12:23:19 -07001247 continue;
Jeff Layton2846d382008-09-22 21:33:33 -04001248
Steve French6148a742005-10-05 12:23:19 -07001249 if (open_file->pfile &&
1250 ((open_file->pfile->f_flags & O_RDWR) ||
1251 (open_file->pfile->f_flags & O_WRONLY))) {
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001252 cifsFileInfo_get(open_file);
Steve French9b22b0b2007-10-02 01:11:08 +00001253
1254 if (!open_file->invalidHandle) {
1255 /* found a good writable file */
1256 read_unlock(&GlobalSMBSeslock);
1257 return open_file;
1258 }
Steve French8840dee2007-11-16 23:05:52 +00001259
Steve French6148a742005-10-05 12:23:19 -07001260 read_unlock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001261 /* Had to unlock since following call can block */
Steve French4b18f2a2008-04-29 00:06:05 +00001262 rc = cifs_reopen_file(open_file->pfile, false);
Steve French8840dee2007-11-16 23:05:52 +00001263 if (!rc) {
Steve French9b22b0b2007-10-02 01:11:08 +00001264 if (!open_file->closePend)
1265 return open_file;
1266 else { /* start over in case this was deleted */
1267 /* since the list could be modified */
Steve French37c0eb42005-10-05 14:50:29 -07001268 read_lock(&GlobalSMBSeslock);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001269 cifsFileInfo_put(open_file);
Steve French9b22b0b2007-10-02 01:11:08 +00001270 goto refind_writable;
Steve French37c0eb42005-10-05 14:50:29 -07001271 }
1272 }
Steve French9b22b0b2007-10-02 01:11:08 +00001273
1274 /* if it fails, try another handle if possible -
1275 (we can not do this if closePending since
1276 loop could be modified - in which case we
1277 have to start at the beginning of the list
1278 again. Note that it would be bad
1279 to hold up writepages here (rather than
1280 in caller) with continuous retries */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001281 cFYI(1, "wp failed on reopen file");
Steve French9b22b0b2007-10-02 01:11:08 +00001282 read_lock(&GlobalSMBSeslock);
1283 /* can not use this handle, no write
1284 pending on this one after all */
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001285 cifsFileInfo_put(open_file);
Steve French8840dee2007-11-16 23:05:52 +00001286
Steve French9b22b0b2007-10-02 01:11:08 +00001287 if (open_file->closePend) /* list could have changed */
1288 goto refind_writable;
1289 /* else we simply continue to the next entry. Thus
1290 we do not loop on reopen errors. If we
1291 can not reopen the file, for example if we
1292 reconnected to a server with another client
1293 racing to delete or lock the file we would not
1294 make progress if we restarted before the beginning
1295 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001296 }
1297 }
Jeff Layton2846d382008-09-22 21:33:33 -04001298 /* couldn't find useable FH with same pid, try any available */
1299 if (!any_available) {
1300 any_available = true;
1301 goto refind_writable;
1302 }
Steve French6148a742005-10-05 12:23:19 -07001303 read_unlock(&GlobalSMBSeslock);
1304 return NULL;
1305}
1306
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1308{
1309 struct address_space *mapping = page->mapping;
1310 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1311 char *write_data;
1312 int rc = -EFAULT;
1313 int bytes_written = 0;
1314 struct cifs_sb_info *cifs_sb;
1315 struct cifsTconInfo *pTcon;
1316 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001317 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
1319 if (!mapping || !mapping->host)
1320 return -EFAULT;
1321
1322 inode = page->mapping->host;
1323 cifs_sb = CIFS_SB(inode->i_sb);
1324 pTcon = cifs_sb->tcon;
1325
1326 offset += (loff_t)from;
1327 write_data = kmap(page);
1328 write_data += from;
1329
1330 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1331 kunmap(page);
1332 return -EIO;
1333 }
1334
1335 /* racing with truncate? */
1336 if (offset > mapping->host->i_size) {
1337 kunmap(page);
1338 return 0; /* don't care */
1339 }
1340
1341 /* check to make sure that we are not extending the file */
1342 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001343 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344
Steve French6148a742005-10-05 12:23:19 -07001345 open_file = find_writable_file(CIFS_I(mapping->host));
1346 if (open_file) {
1347 bytes_written = cifs_write(open_file->pfile, write_data,
1348 to-from, &offset);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001349 cifsFileInfo_put(open_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001351 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001352 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001353 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001354 else if (bytes_written < 0)
1355 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001356 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001357 cFYI(1, "No writeable filehandles for inode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 rc = -EIO;
1359 }
1360
1361 kunmap(page);
1362 return rc;
1363}
1364
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001366 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367{
Steve French37c0eb42005-10-05 14:50:29 -07001368 struct backing_dev_info *bdi = mapping->backing_dev_info;
1369 unsigned int bytes_to_write;
1370 unsigned int bytes_written;
1371 struct cifs_sb_info *cifs_sb;
1372 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001373 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001374 pgoff_t index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001375 int range_whole = 0;
1376 struct kvec *iov;
Steve French84d2f072005-10-12 15:32:05 -07001377 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001378 int n_iov = 0;
1379 pgoff_t next;
1380 int nr_pages;
1381 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001382 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001383 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
Steve French37c0eb42005-10-05 14:50:29 -07001384 struct page *page;
1385 struct pagevec pvec;
1386 int rc = 0;
1387 int scanned = 0;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001388 int xid, long_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
Steve French37c0eb42005-10-05 14:50:29 -07001390 cifs_sb = CIFS_SB(mapping->host->i_sb);
Steve French50c2f752007-07-13 00:33:32 +00001391
Steve French37c0eb42005-10-05 14:50:29 -07001392 /*
1393 * If wsize is smaller that the page cache size, default to writing
1394 * one page at a time via cifs_writepage
1395 */
1396 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1397 return generic_writepages(mapping, wbc);
1398
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001399 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1400 if (cifs_sb->tcon->ses->server->secMode &
1401 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1402 if (!experimEnabled)
Steve French60808232006-04-22 15:53:05 +00001403 return generic_writepages(mapping, wbc);
Steve French4a771182005-10-05 15:14:33 -07001404
Steve French9a0c8232007-02-02 04:21:57 +00001405 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001406 if (iov == NULL)
Steve French9a0c8232007-02-02 04:21:57 +00001407 return generic_writepages(mapping, wbc);
1408
1409
Steve French37c0eb42005-10-05 14:50:29 -07001410 /*
1411 * BB: Is this meaningful for a non-block-device file system?
1412 * If it is, we should test it again after we do I/O
1413 */
1414 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1415 wbc->encountered_congestion = 1;
Steve French9a0c8232007-02-02 04:21:57 +00001416 kfree(iov);
Steve French37c0eb42005-10-05 14:50:29 -07001417 return 0;
1418 }
1419
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 xid = GetXid();
1421
Steve French37c0eb42005-10-05 14:50:29 -07001422 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001423 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001424 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001425 end = -1;
1426 } else {
1427 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1428 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1429 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1430 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001431 scanned = 1;
1432 }
1433retry:
1434 while (!done && (index <= end) &&
1435 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1436 PAGECACHE_TAG_DIRTY,
1437 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1438 int first;
1439 unsigned int i;
1440
Steve French37c0eb42005-10-05 14:50:29 -07001441 first = -1;
1442 next = 0;
1443 n_iov = 0;
1444 bytes_to_write = 0;
1445
1446 for (i = 0; i < nr_pages; i++) {
1447 page = pvec.pages[i];
1448 /*
1449 * At this point we hold neither mapping->tree_lock nor
1450 * lock on the page itself: the page may be truncated or
1451 * invalidated (changing page->mapping to NULL), or even
1452 * swizzled back from swapper_space to tmpfs file
1453 * mapping
1454 */
1455
1456 if (first < 0)
1457 lock_page(page);
Nick Piggin529ae9a2008-08-02 12:01:03 +02001458 else if (!trylock_page(page))
Steve French37c0eb42005-10-05 14:50:29 -07001459 break;
1460
1461 if (unlikely(page->mapping != mapping)) {
1462 unlock_page(page);
1463 break;
1464 }
1465
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001466 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001467 done = 1;
1468 unlock_page(page);
1469 break;
1470 }
1471
1472 if (next && (page->index != next)) {
1473 /* Not next consecutive page */
1474 unlock_page(page);
1475 break;
1476 }
1477
1478 if (wbc->sync_mode != WB_SYNC_NONE)
1479 wait_on_page_writeback(page);
1480
1481 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001482 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001483 unlock_page(page);
1484 break;
1485 }
Steve French84d2f072005-10-12 15:32:05 -07001486
Linus Torvaldscb876f42006-12-23 16:19:07 -08001487 /*
1488 * This actually clears the dirty bit in the radix tree.
1489 * See cifs_writepage() for more commentary.
1490 */
1491 set_page_writeback(page);
1492
Steve French84d2f072005-10-12 15:32:05 -07001493 if (page_offset(page) >= mapping->host->i_size) {
1494 done = 1;
1495 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001496 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001497 break;
1498 }
1499
Steve French37c0eb42005-10-05 14:50:29 -07001500 /*
1501 * BB can we get rid of this? pages are held by pvec
1502 */
1503 page_cache_get(page);
1504
Steve French84d2f072005-10-12 15:32:05 -07001505 len = min(mapping->host->i_size - page_offset(page),
1506 (loff_t)PAGE_CACHE_SIZE);
1507
Steve French37c0eb42005-10-05 14:50:29 -07001508 /* reserve iov[0] for the smb header */
1509 n_iov++;
1510 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001511 iov[n_iov].iov_len = len;
1512 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001513
1514 if (first < 0) {
1515 first = i;
1516 offset = page_offset(page);
1517 }
1518 next = page->index + 1;
1519 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1520 break;
1521 }
1522 if (n_iov) {
Steve French23e7dd72005-10-20 13:44:56 -07001523 /* Search for a writable handle every time we call
1524 * CIFSSMBWrite2. We can't rely on the last handle
1525 * we used to still be valid
1526 */
1527 open_file = find_writable_file(CIFS_I(mapping->host));
1528 if (!open_file) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001529 cERROR(1, "No writable handles for inode");
Steve French23e7dd72005-10-20 13:44:56 -07001530 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001531 } else {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001532 long_op = cifs_write_timeout(cifsi, offset);
Steve French23e7dd72005-10-20 13:44:56 -07001533 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1534 open_file->netfid,
1535 bytes_to_write, offset,
1536 &bytes_written, iov, n_iov,
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001537 long_op);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001538 cifsFileInfo_put(open_file);
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001539 cifs_update_eof(cifsi, offset, bytes_written);
1540
Steve French23e7dd72005-10-20 13:44:56 -07001541 if (rc || bytes_written < bytes_to_write) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001542 cERROR(1, "Write2 ret %d, wrote %d",
1543 rc, bytes_written);
Steve French23e7dd72005-10-20 13:44:56 -07001544 /* BB what if continued retry is
1545 requested via mount flags? */
Jeff Laytoncea21802007-11-20 23:19:03 +00001546 if (rc == -ENOSPC)
1547 set_bit(AS_ENOSPC, &mapping->flags);
1548 else
1549 set_bit(AS_EIO, &mapping->flags);
Steve French23e7dd72005-10-20 13:44:56 -07001550 } else {
1551 cifs_stats_bytes_written(cifs_sb->tcon,
1552 bytes_written);
1553 }
Steve French37c0eb42005-10-05 14:50:29 -07001554 }
1555 for (i = 0; i < n_iov; i++) {
1556 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001557 /* Should we also set page error on
1558 success rc but too little data written? */
1559 /* BB investigate retry logic on temporary
1560 server crash cases and how recovery works
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001561 when page marked as error */
1562 if (rc)
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001563 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001564 kunmap(page);
1565 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001566 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001567 page_cache_release(page);
1568 }
1569 if ((wbc->nr_to_write -= n_iov) <= 0)
1570 done = 1;
1571 index = next;
Dave Kleikampb066a482008-11-18 03:49:05 +00001572 } else
1573 /* Need to re-find the pages we skipped */
1574 index = pvec.pages[0]->index + 1;
1575
Steve French37c0eb42005-10-05 14:50:29 -07001576 pagevec_release(&pvec);
1577 }
1578 if (!scanned && !done) {
1579 /*
1580 * We hit the last page and there is more work to be done: wrap
1581 * back to the start of the file
1582 */
1583 scanned = 1;
1584 index = 0;
1585 goto retry;
1586 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001587 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001588 mapping->writeback_index = index;
1589
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001591 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 return rc;
1593}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001595static int cifs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596{
1597 int rc = -EFAULT;
1598 int xid;
1599
1600 xid = GetXid();
1601/* BB add check for wbc flags */
1602 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001603 if (!PageUptodate(page))
Joe Perchesb6b38f72010-04-21 03:50:45 +00001604 cFYI(1, "ppw - page not up to date");
Linus Torvaldscb876f42006-12-23 16:19:07 -08001605
1606 /*
1607 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1608 *
1609 * A writepage() implementation always needs to do either this,
1610 * or re-dirty the page with "redirty_page_for_writepage()" in
1611 * the case of a failure.
1612 *
1613 * Just unlocking the page will cause the radix tree tag-bits
1614 * to fail to update with the state of the page correctly.
1615 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001616 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1618 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1619 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001620 end_page_writeback(page);
1621 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 FreeXid(xid);
1623 return rc;
1624}
1625
Nick Piggind9414772008-09-24 11:32:59 -04001626static int cifs_write_end(struct file *file, struct address_space *mapping,
1627 loff_t pos, unsigned len, unsigned copied,
1628 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629{
Nick Piggind9414772008-09-24 11:32:59 -04001630 int rc;
1631 struct inode *inode = mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001632
Joe Perchesb6b38f72010-04-21 03:50:45 +00001633 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1634 page, pos, copied);
Steve Frenchad7a2922008-02-07 23:25:02 +00001635
Jeff Laytona98ee8c2008-11-26 19:32:33 +00001636 if (PageChecked(page)) {
1637 if (copied == len)
1638 SetPageUptodate(page);
1639 ClearPageChecked(page);
1640 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04001641 SetPageUptodate(page);
1642
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04001644 char *page_data;
1645 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1646 int xid;
1647
1648 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 /* this is probably better than directly calling
1650 partialpage_write since in this function the file handle is
1651 known which we might as well leverage */
1652 /* BB check if anything else missing out of ppw
1653 such as updating last write time */
1654 page_data = kmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001655 rc = cifs_write(file, page_data + offset, copied, &pos);
1656 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001658
1659 FreeXid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001660 } else {
Nick Piggind9414772008-09-24 11:32:59 -04001661 rc = copied;
1662 pos += copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 set_page_dirty(page);
1664 }
1665
Nick Piggind9414772008-09-24 11:32:59 -04001666 if (rc > 0) {
1667 spin_lock(&inode->i_lock);
1668 if (pos > inode->i_size)
1669 i_size_write(inode, pos);
1670 spin_unlock(&inode->i_lock);
1671 }
1672
1673 unlock_page(page);
1674 page_cache_release(page);
1675
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 return rc;
1677}
1678
1679int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1680{
1681 int xid;
1682 int rc = 0;
Steve Frenchb298f222009-02-21 21:17:43 +00001683 struct cifsTconInfo *tcon;
1684 struct cifsFileInfo *smbfile =
1685 (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001686 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687
1688 xid = GetXid();
1689
Joe Perchesb6b38f72010-04-21 03:50:45 +00001690 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1691 dentry->d_name.name, datasync);
Steve French50c2f752007-07-13 00:33:32 +00001692
Jeff Laytoncea21802007-11-20 23:19:03 +00001693 rc = filemap_write_and_wait(inode->i_mapping);
1694 if (rc == 0) {
1695 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 CIFS_I(inode)->write_behind_rc = 0;
Steve Frenchb298f222009-02-21 21:17:43 +00001697 tcon = CIFS_SB(inode->i_sb)->tcon;
Steve Frenchbe652442009-02-23 15:21:59 +00001698 if (!rc && tcon && smbfile &&
Steve French4717bed2009-02-24 14:44:19 +00001699 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
Steve Frenchb298f222009-02-21 21:17:43 +00001700 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
Jeff Laytoncea21802007-11-20 23:19:03 +00001701 }
Steve Frenchb298f222009-02-21 21:17:43 +00001702
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 FreeXid(xid);
1704 return rc;
1705}
1706
NeilBrown3978d7172006-03-26 01:37:17 -08001707/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708{
1709 struct address_space *mapping;
1710 struct inode *inode;
1711 unsigned long index = page->index;
1712 unsigned int rpages = 0;
1713 int rc = 0;
1714
Steve Frenchf19159d2010-04-21 04:12:10 +00001715 cFYI(1, "sync page %p", page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 mapping = page->mapping;
1717 if (!mapping)
1718 return 0;
1719 inode = mapping->host;
1720 if (!inode)
NeilBrown3978d7172006-03-26 01:37:17 -08001721 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001723/* fill in rpages then
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1725
Joe Perchesb6b38f72010-04-21 03:50:45 +00001726/* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727
NeilBrown3978d7172006-03-26 01:37:17 -08001728#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729 if (rc < 0)
1730 return rc;
1731 return 0;
NeilBrown3978d7172006-03-26 01:37:17 -08001732#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733} */
1734
1735/*
1736 * As file closes, flush all cached write data for this inode checking
1737 * for write behind errors.
1738 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001739int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001741 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001742 int rc = 0;
1743
1744 /* Rather than do the steps manually:
1745 lock the inode for writing
1746 loop through pages looking for write behind data (dirty pages)
1747 coalesce into contiguous 16K (or smaller) chunks to write to server
1748 send to server (prefer in parallel)
1749 deal with writebehind errors
1750 unlock inode for writing
1751 filemapfdatawrite appears easier for the time being */
1752
1753 rc = filemap_fdatawrite(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +00001754 /* reset wb rc if we were able to write out dirty pages */
1755 if (!rc) {
1756 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001758 }
Steve French50c2f752007-07-13 00:33:32 +00001759
Joe Perchesb6b38f72010-04-21 03:50:45 +00001760 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761
1762 return rc;
1763}
1764
1765ssize_t cifs_user_read(struct file *file, char __user *read_data,
1766 size_t read_size, loff_t *poffset)
1767{
1768 int rc = -EACCES;
1769 unsigned int bytes_read = 0;
1770 unsigned int total_read = 0;
1771 unsigned int current_read_size;
1772 struct cifs_sb_info *cifs_sb;
1773 struct cifsTconInfo *pTcon;
1774 int xid;
1775 struct cifsFileInfo *open_file;
1776 char *smb_read_data;
1777 char __user *current_offset;
1778 struct smb_com_read_rsp *pSMBr;
1779
1780 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001781 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 pTcon = cifs_sb->tcon;
1783
1784 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301785 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301787 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 }
1789 open_file = (struct cifsFileInfo *)file->private_data;
1790
Steve Frenchad7a2922008-02-07 23:25:02 +00001791 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001792 cFYI(1, "attempting read on write only file instance");
Steve Frenchad7a2922008-02-07 23:25:02 +00001793
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 for (total_read = 0, current_offset = read_data;
1795 read_size > total_read;
1796 total_read += bytes_read, current_offset += bytes_read) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001797 current_read_size = min_t(const int, read_size - total_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 cifs_sb->rsize);
1799 rc = -EAGAIN;
1800 smb_read_data = NULL;
1801 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001802 int buf_type = CIFS_NO_BUFFER;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001803 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001805 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001806 if (rc != 0)
1807 break;
1808 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001809 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001810 open_file->netfid,
1811 current_read_size, *poffset,
1812 &bytes_read, &smb_read_data,
1813 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001816 if (copy_to_user(current_offset,
1817 smb_read_data +
1818 4 /* RFC1001 length field */ +
1819 le16_to_cpu(pSMBr->DataOffset),
Steve Frenchad7a2922008-02-07 23:25:02 +00001820 bytes_read))
Steve French93544cc2006-02-14 22:30:52 -06001821 rc = -EFAULT;
Steve French93544cc2006-02-14 22:30:52 -06001822
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001823 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001824 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001825 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001826 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 smb_read_data = NULL;
1828 }
1829 }
1830 if (rc || (bytes_read == 0)) {
1831 if (total_read) {
1832 break;
1833 } else {
1834 FreeXid(xid);
1835 return rc;
1836 }
1837 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001838 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 *poffset += bytes_read;
1840 }
1841 }
1842 FreeXid(xid);
1843 return total_read;
1844}
1845
1846
1847static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1848 loff_t *poffset)
1849{
1850 int rc = -EACCES;
1851 unsigned int bytes_read = 0;
1852 unsigned int total_read;
1853 unsigned int current_read_size;
1854 struct cifs_sb_info *cifs_sb;
1855 struct cifsTconInfo *pTcon;
1856 int xid;
1857 char *current_offset;
1858 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001859 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860
1861 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001862 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001863 pTcon = cifs_sb->tcon;
1864
1865 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301866 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301868 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 }
1870 open_file = (struct cifsFileInfo *)file->private_data;
1871
1872 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001873 cFYI(1, "attempting read on write only file instance");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001875 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 read_size > total_read;
1877 total_read += bytes_read, current_offset += bytes_read) {
1878 current_read_size = min_t(const int, read_size - total_read,
1879 cifs_sb->rsize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001880 /* For windows me and 9x we do not want to request more
1881 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001882 if ((pTcon->ses) &&
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001883 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1884 current_read_size = min_t(const int, current_read_size,
1885 pTcon->ses->server->maxBuf - 128);
1886 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 rc = -EAGAIN;
1888 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001889 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001891 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 if (rc != 0)
1893 break;
1894 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001895 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001896 open_file->netfid,
1897 current_read_size, *poffset,
1898 &bytes_read, &current_offset,
1899 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 }
1901 if (rc || (bytes_read == 0)) {
1902 if (total_read) {
1903 break;
1904 } else {
1905 FreeXid(xid);
1906 return rc;
1907 }
1908 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001909 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 *poffset += bytes_read;
1911 }
1912 }
1913 FreeXid(xid);
1914 return total_read;
1915}
1916
1917int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1918{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 int rc, xid;
1920
1921 xid = GetXid();
Jeff Laytonabab0952010-02-12 07:44:18 -05001922 rc = cifs_revalidate_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001924 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 FreeXid(xid);
1926 return rc;
1927 }
1928 rc = generic_file_mmap(file, vma);
1929 FreeXid(xid);
1930 return rc;
1931}
1932
1933
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001934static void cifs_copy_cache_pages(struct address_space *mapping,
Nick Piggin315e9952010-04-21 03:18:28 +00001935 struct list_head *pages, int bytes_read, char *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936{
1937 struct page *page;
1938 char *target;
1939
1940 while (bytes_read > 0) {
1941 if (list_empty(pages))
1942 break;
1943
1944 page = list_entry(pages->prev, struct page, lru);
1945 list_del(&page->lru);
1946
Nick Piggin315e9952010-04-21 03:18:28 +00001947 if (add_to_page_cache_lru(page, mapping, page->index,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948 GFP_KERNEL)) {
1949 page_cache_release(page);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001950 cFYI(1, "Add page cache failed");
Steve French3079ca62005-06-09 14:44:07 -07001951 data += PAGE_CACHE_SIZE;
1952 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 continue;
1954 }
1955
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001956 target = kmap_atomic(page, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957
1958 if (PAGE_CACHE_SIZE > bytes_read) {
1959 memcpy(target, data, bytes_read);
1960 /* zero the tail end of this partial page */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001961 memset(target + bytes_read, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962 PAGE_CACHE_SIZE - bytes_read);
1963 bytes_read = 0;
1964 } else {
1965 memcpy(target, data, PAGE_CACHE_SIZE);
1966 bytes_read -= PAGE_CACHE_SIZE;
1967 }
1968 kunmap_atomic(target, KM_USER0);
1969
1970 flush_dcache_page(page);
1971 SetPageUptodate(page);
1972 unlock_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 data += PAGE_CACHE_SIZE;
1974 }
1975 return;
1976}
1977
1978static int cifs_readpages(struct file *file, struct address_space *mapping,
1979 struct list_head *page_list, unsigned num_pages)
1980{
1981 int rc = -EACCES;
1982 int xid;
1983 loff_t offset;
1984 struct page *page;
1985 struct cifs_sb_info *cifs_sb;
1986 struct cifsTconInfo *pTcon;
Steve French2c2130e2007-10-12 19:10:28 +00001987 unsigned int bytes_read = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001988 unsigned int read_size, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 char *smb_read_data = NULL;
1990 struct smb_com_read_rsp *pSMBr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001992 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993
1994 xid = GetXid();
1995 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301996 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301998 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 }
2000 open_file = (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002001 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002 pTcon = cifs_sb->tcon;
Steve Frenchbfa0d752005-08-31 21:50:37 -07002003
Steve Frenchf19159d2010-04-21 04:12:10 +00002004 cFYI(DBG2, "rpages: num pages %d", num_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 for (i = 0; i < num_pages; ) {
2006 unsigned contig_pages;
2007 struct page *tmp_page;
2008 unsigned long expected_index;
2009
2010 if (list_empty(page_list))
2011 break;
2012
2013 page = list_entry(page_list->prev, struct page, lru);
2014 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2015
2016 /* count adjacent pages that we will read into */
2017 contig_pages = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002018 expected_index =
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 list_entry(page_list->prev, struct page, lru)->index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002020 list_for_each_entry_reverse(tmp_page, page_list, lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 if (tmp_page->index == expected_index) {
2022 contig_pages++;
2023 expected_index++;
2024 } else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002025 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 }
2027 if (contig_pages + i > num_pages)
2028 contig_pages = num_pages - i;
2029
2030 /* for reads over a certain size could initiate async
2031 read ahead */
2032
2033 read_size = contig_pages * PAGE_CACHE_SIZE;
2034 /* Read size needs to be in multiples of one page */
2035 read_size = min_t(const unsigned int, read_size,
2036 cifs_sb->rsize & PAGE_CACHE_MASK);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002037 cFYI(DBG2, "rpages: read size 0x%x contiguous pages %d",
2038 read_size, contig_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 rc = -EAGAIN;
2040 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002041 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00002043 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044 if (rc != 0)
2045 break;
2046 }
2047
Steve Frenchbfa0d752005-08-31 21:50:37 -07002048 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08002049 open_file->netfid,
2050 read_size, offset,
2051 &bytes_read, &smb_read_data,
2052 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07002053 /* BB more RC checks ? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002054 if (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002056 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002057 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002058 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002059 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 smb_read_data = NULL;
2061 }
2062 }
2063 }
2064 if ((rc < 0) || (smb_read_data == NULL)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002065 cFYI(1, "Read error in readpages: %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066 break;
2067 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08002068 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2070 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2071 smb_read_data + 4 /* RFC1001 hdr */ +
Nick Piggin315e9952010-04-21 03:18:28 +00002072 le16_to_cpu(pSMBr->DataOffset));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073
2074 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha4544342005-08-24 13:59:35 -07002075 cifs_stats_bytes_read(pTcon, bytes_read);
Steve French2c2130e2007-10-12 19:10:28 +00002076 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 i++; /* account for partial page */
2078
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002079 /* server copy of file can have smaller size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 than client */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002081 /* BB do we need to verify this common case ?
2082 this case is ok - if we are at server EOF
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 we will hit it on next read */
2084
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08002085 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 }
2087 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002088 cFYI(1, "No bytes read (%d) at offset %lld . "
Steve Frenchf19159d2010-04-21 04:12:10 +00002089 "Cleaning remaining pages from readahead list",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002090 bytes_read, offset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002091 /* BB turn off caching and do new lookup on
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093 break;
2094 }
2095 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002096 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002097 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002098 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002099 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002100 smb_read_data = NULL;
2101 }
2102 bytes_read = 0;
2103 }
2104
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105/* need to free smb_read_data buf before exit */
2106 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002107 if (buf_type == CIFS_SMALL_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002108 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002109 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002110 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 smb_read_data = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002112 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113
2114 FreeXid(xid);
2115 return rc;
2116}
2117
2118static int cifs_readpage_worker(struct file *file, struct page *page,
2119 loff_t *poffset)
2120{
2121 char *read_data;
2122 int rc;
2123
2124 page_cache_get(page);
2125 read_data = kmap(page);
2126 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002127
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002129
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 if (rc < 0)
2131 goto io_error;
2132 else
Joe Perchesb6b38f72010-04-21 03:50:45 +00002133 cFYI(1, "Bytes read %d", rc);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002134
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002135 file->f_path.dentry->d_inode->i_atime =
2136 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002137
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138 if (PAGE_CACHE_SIZE > rc)
2139 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2140
2141 flush_dcache_page(page);
2142 SetPageUptodate(page);
2143 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002144
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002146 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147 page_cache_release(page);
2148 return rc;
2149}
2150
2151static int cifs_readpage(struct file *file, struct page *page)
2152{
2153 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2154 int rc = -EACCES;
2155 int xid;
2156
2157 xid = GetXid();
2158
2159 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302160 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302162 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 }
2164
Joe Perchesb6b38f72010-04-21 03:50:45 +00002165 cFYI(1, "readpage %p at offset %d 0x%x\n",
2166 page, (int)offset, (int)offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002167
2168 rc = cifs_readpage_worker(file, page, &offset);
2169
2170 unlock_page(page);
2171
2172 FreeXid(xid);
2173 return rc;
2174}
2175
Steve Frencha403a0a2007-07-26 15:54:16 +00002176static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2177{
2178 struct cifsFileInfo *open_file;
2179
2180 read_lock(&GlobalSMBSeslock);
2181 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2182 if (open_file->closePend)
2183 continue;
2184 if (open_file->pfile &&
2185 ((open_file->pfile->f_flags & O_RDWR) ||
2186 (open_file->pfile->f_flags & O_WRONLY))) {
2187 read_unlock(&GlobalSMBSeslock);
2188 return 1;
2189 }
2190 }
2191 read_unlock(&GlobalSMBSeslock);
2192 return 0;
2193}
2194
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195/* We do not want to update the file size from server for inodes
2196 open for write - to avoid races with writepage extending
2197 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002198 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002199 but this is tricky to do without racing with writebehind
2200 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00002201bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202{
Steve Frencha403a0a2007-07-26 15:54:16 +00002203 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00002204 return true;
Steve French23e7dd72005-10-20 13:44:56 -07002205
Steve Frencha403a0a2007-07-26 15:54:16 +00002206 if (is_inode_writable(cifsInode)) {
2207 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08002208 struct cifs_sb_info *cifs_sb;
2209
Steve Frenchc32a0b62006-01-12 14:41:28 -08002210 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00002211 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002212 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08002213 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00002214 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08002215 }
2216
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002217 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00002218 return true;
Steve French7ba52632007-02-08 18:14:13 +00002219
Steve French4b18f2a2008-04-29 00:06:05 +00002220 return false;
Steve French23e7dd72005-10-20 13:44:56 -07002221 } else
Steve French4b18f2a2008-04-29 00:06:05 +00002222 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223}
2224
Nick Piggind9414772008-09-24 11:32:59 -04002225static int cifs_write_begin(struct file *file, struct address_space *mapping,
2226 loff_t pos, unsigned len, unsigned flags,
2227 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228{
Nick Piggind9414772008-09-24 11:32:59 -04002229 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2230 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002231 loff_t page_start = pos & PAGE_MASK;
2232 loff_t i_size;
2233 struct page *page;
2234 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235
Joe Perchesb6b38f72010-04-21 03:50:45 +00002236 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
Nick Piggind9414772008-09-24 11:32:59 -04002237
Nick Piggin54566b22009-01-04 12:00:53 -08002238 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002239 if (!page) {
2240 rc = -ENOMEM;
2241 goto out;
2242 }
Nick Piggind9414772008-09-24 11:32:59 -04002243
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002244 if (PageUptodate(page))
2245 goto out;
Steve French8a236262007-03-06 00:31:00 +00002246
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002247 /*
2248 * If we write a full page it will be up to date, no need to read from
2249 * the server. If the write is short, we'll end up doing a sync write
2250 * instead.
2251 */
2252 if (len == PAGE_CACHE_SIZE)
2253 goto out;
2254
2255 /*
2256 * optimize away the read when we have an oplock, and we're not
2257 * expecting to use any of the data we'd be reading in. That
2258 * is, when the page lies beyond the EOF, or straddles the EOF
2259 * and the write will cover all of the existing data.
2260 */
2261 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2262 i_size = i_size_read(mapping->host);
2263 if (page_start >= i_size ||
2264 (offset == 0 && (pos + len) >= i_size)) {
2265 zero_user_segments(page, 0, offset,
2266 offset + len,
2267 PAGE_CACHE_SIZE);
2268 /*
2269 * PageChecked means that the parts of the page
2270 * to which we're not writing are considered up
2271 * to date. Once the data is copied to the
2272 * page, it can be set uptodate.
2273 */
2274 SetPageChecked(page);
2275 goto out;
2276 }
2277 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002278
Nick Piggind9414772008-09-24 11:32:59 -04002279 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002280 /*
2281 * might as well read a page, it is fast enough. If we get
2282 * an error, we don't need to return it. cifs_write_end will
2283 * do a sync write instead since PG_uptodate isn't set.
2284 */
2285 cifs_readpage_worker(file, page, &page_start);
Steve French8a236262007-03-06 00:31:00 +00002286 } else {
2287 /* we could try using another file handle if there is one -
2288 but how would we lock it to prevent close of that handle
2289 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04002290 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00002291 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002292out:
2293 *pagep = page;
2294 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295}
2296
Jeff Layton3bc303c2009-09-21 06:47:50 -04002297static void
2298cifs_oplock_break(struct slow_work *work)
2299{
2300 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2301 oplock_break);
2302 struct inode *inode = cfile->pInode;
2303 struct cifsInodeInfo *cinode = CIFS_I(inode);
2304 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->mnt->mnt_sb);
2305 int rc, waitrc = 0;
2306
2307 if (inode && S_ISREG(inode->i_mode)) {
Steve Frenchd54ff732010-04-27 04:38:15 +00002308 if (cinode->clientCanCacheRead)
Al Viro8737c932009-12-24 06:47:55 -05002309 break_lease(inode, O_RDONLY);
Steve Frenchd54ff732010-04-27 04:38:15 +00002310 else
Al Viro8737c932009-12-24 06:47:55 -05002311 break_lease(inode, O_WRONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002312 rc = filemap_fdatawrite(inode->i_mapping);
2313 if (cinode->clientCanCacheRead == 0) {
2314 waitrc = filemap_fdatawait(inode->i_mapping);
2315 invalidate_remote_inode(inode);
2316 }
2317 if (!rc)
2318 rc = waitrc;
2319 if (rc)
2320 cinode->write_behind_rc = rc;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002321 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002322 }
2323
2324 /*
2325 * releasing stale oplock after recent reconnect of smb session using
2326 * a now incorrect file handle is not a data integrity issue but do
2327 * not bother sending an oplock release if session to server still is
2328 * disconnected since oplock already released by the server
2329 */
2330 if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2331 rc = CIFSSMBLock(0, cifs_sb->tcon, cfile->netfid, 0, 0, 0, 0,
2332 LOCKING_ANDX_OPLOCK_RELEASE, false);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002333 cFYI(1, "Oplock release rc = %d", rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002334 }
2335}
2336
2337static int
2338cifs_oplock_break_get(struct slow_work *work)
2339{
2340 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2341 oplock_break);
2342 mntget(cfile->mnt);
2343 cifsFileInfo_get(cfile);
2344 return 0;
2345}
2346
2347static void
2348cifs_oplock_break_put(struct slow_work *work)
2349{
2350 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2351 oplock_break);
2352 mntput(cfile->mnt);
2353 cifsFileInfo_put(cfile);
2354}
2355
2356const struct slow_work_ops cifs_oplock_break_ops = {
2357 .get_ref = cifs_oplock_break_get,
2358 .put_ref = cifs_oplock_break_put,
2359 .execute = cifs_oplock_break,
2360};
2361
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002362const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363 .readpage = cifs_readpage,
2364 .readpages = cifs_readpages,
2365 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002366 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002367 .write_begin = cifs_write_begin,
2368 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 .set_page_dirty = __set_page_dirty_nobuffers,
2370 /* .sync_page = cifs_sync_page, */
2371 /* .direct_IO = */
2372};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002373
2374/*
2375 * cifs_readpages requires the server to support a buffer large enough to
2376 * contain the header plus one complete page of data. Otherwise, we need
2377 * to leave cifs_readpages out of the address space operations.
2378 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002379const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002380 .readpage = cifs_readpage,
2381 .writepage = cifs_writepage,
2382 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002383 .write_begin = cifs_write_begin,
2384 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002385 .set_page_dirty = __set_page_dirty_nobuffers,
2386 /* .sync_page = cifs_sync_page, */
2387 /* .direct_IO = */
2388};