blob: 2ba4c41be97279e30d32234e16e1eacc467472b7 [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,
111 struct cifsInodeInfo *pCifsInode,
112 struct cifsFileInfo *pCifsFile, __u32 oplock,
113 u16 netfid)
Steve French276a74a2009-03-03 18:00:34 +0000114{
Steve French276a74a2009-03-03 18:00:34 +0000115
Steve French276a74a2009-03-03 18:00:34 +0000116 write_lock(&GlobalSMBSeslock);
Steve French276a74a2009-03-03 18:00:34 +0000117
118 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
119 if (pCifsInode == NULL) {
120 write_unlock(&GlobalSMBSeslock);
121 return -EINVAL;
122 }
123
Steve French276a74a2009-03-03 18:00:34 +0000124 if (pCifsInode->clientCanCacheRead) {
125 /* we have the inode open somewhere else
126 no need to discard cache data */
127 goto psx_client_can_cache;
128 }
129
130 /* BB FIXME need to fix this check to move it earlier into posix_open
131 BB fIX following section BB FIXME */
132
133 /* if not oplocked, invalidate inode pages if mtime or file
134 size changed */
135/* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
136 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
137 (file->f_path.dentry->d_inode->i_size ==
138 (loff_t)le64_to_cpu(buf->EndOfFile))) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000139 cFYI(1, "inode unchanged on server");
Steve French276a74a2009-03-03 18:00:34 +0000140 } else {
141 if (file->f_path.dentry->d_inode->i_mapping) {
142 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
143 if (rc != 0)
144 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
145 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000146 cFYI(1, "invalidating remote inode since open detected it "
147 "changed");
Steve French276a74a2009-03-03 18:00:34 +0000148 invalidate_remote_inode(file->f_path.dentry->d_inode);
149 } */
150
151psx_client_can_cache:
152 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
153 pCifsInode->clientCanCacheAll = true;
154 pCifsInode->clientCanCacheRead = true;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000155 cFYI(1, "Exclusive Oplock granted on inode %p",
156 file->f_path.dentry->d_inode);
Steve French276a74a2009-03-03 18:00:34 +0000157 } else if ((oplock & 0xF) == OPLOCK_READ)
158 pCifsInode->clientCanCacheRead = true;
159
160 /* will have to change the unlock if we reenable the
161 filemap_fdatawrite (which does not seem necessary */
162 write_unlock(&GlobalSMBSeslock);
163 return 0;
164}
165
Steve French703a3b82009-05-21 22:21:53 +0000166static struct cifsFileInfo *
167cifs_fill_filedata(struct file *file)
168{
169 struct list_head *tmp;
170 struct cifsFileInfo *pCifsFile = NULL;
171 struct cifsInodeInfo *pCifsInode = NULL;
172
173 /* search inode for this file and fill in file->private_data */
174 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
175 read_lock(&GlobalSMBSeslock);
176 list_for_each(tmp, &pCifsInode->openFileList) {
177 pCifsFile = list_entry(tmp, struct cifsFileInfo, flist);
178 if ((pCifsFile->pfile == NULL) &&
179 (pCifsFile->pid == current->tgid)) {
180 /* mode set in cifs_create */
181
182 /* needed for writepage */
183 pCifsFile->pfile = file;
184 file->private_data = pCifsFile;
185 break;
186 }
187 }
188 read_unlock(&GlobalSMBSeslock);
189
190 if (file->private_data != NULL) {
191 return pCifsFile;
192 } else if ((file->f_flags & O_CREAT) && (file->f_flags & O_EXCL))
Joe Perchesb6b38f72010-04-21 03:50:45 +0000193 cERROR(1, "could not find file instance for "
194 "new file %p", file);
Steve French703a3b82009-05-21 22:21:53 +0000195 return NULL;
196}
197
Steve French276a74a2009-03-03 18:00:34 +0000198/* all arguments to this function must be checked for validity in caller */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
200 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
201 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
202 char *full_path, int xid)
203{
204 struct timespec temp;
205 int rc;
206
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 if (pCifsInode->clientCanCacheRead) {
208 /* we have the inode open somewhere else
209 no need to discard cache data */
210 goto client_can_cache;
211 }
212
213 /* BB need same check in cifs_create too? */
214 /* if not oplocked, invalidate inode pages if mtime or file
215 size changed */
Jeff Layton07119a42009-05-27 09:37:33 -0400216 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800217 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
218 (file->f_path.dentry->d_inode->i_size ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219 (loff_t)le64_to_cpu(buf->EndOfFile))) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000220 cFYI(1, "inode unchanged on server");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221 } else {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800222 if (file->f_path.dentry->d_inode->i_mapping) {
Steve Frenchff2157132010-03-09 20:30:42 +0000223 /* BB no need to lock inode until after invalidate
224 since namei code should already have it locked? */
Jeff Laytoncea21802007-11-20 23:19:03 +0000225 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
226 if (rc != 0)
227 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000229 cFYI(1, "invalidating remote inode since open detected it "
230 "changed");
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800231 invalidate_remote_inode(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 }
233
234client_can_cache:
Steve Frenchc18c8422007-07-18 23:21:09 +0000235 if (pTcon->unix_ext)
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800236 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 full_path, inode->i_sb, xid);
238 else
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800239 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
Steve French8b1327f2008-03-14 22:37:16 +0000240 full_path, buf, inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
242 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000243 pCifsInode->clientCanCacheAll = true;
244 pCifsInode->clientCanCacheRead = true;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000245 cFYI(1, "Exclusive Oplock granted on inode %p",
246 file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 } else if ((*oplock & 0xF) == OPLOCK_READ)
Steve French4b18f2a2008-04-29 00:06:05 +0000248 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
250 return rc;
251}
252
253int cifs_open(struct inode *inode, struct file *file)
254{
255 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400256 int xid;
257 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 struct cifs_sb_info *cifs_sb;
Steve French276a74a2009-03-03 18:00:34 +0000259 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 struct cifsFileInfo *pCifsFile;
261 struct cifsInodeInfo *pCifsInode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 char *full_path = NULL;
263 int desiredAccess;
264 int disposition;
265 __u16 netfid;
266 FILE_ALL_INFO *buf = NULL;
267
268 xid = GetXid();
269
270 cifs_sb = CIFS_SB(inode->i_sb);
Steve French276a74a2009-03-03 18:00:34 +0000271 tcon = cifs_sb->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Steve Frencha6ce4932009-04-09 01:14:32 +0000273 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Steve French703a3b82009-05-21 22:21:53 +0000274 pCifsFile = cifs_fill_filedata(file);
275 if (pCifsFile) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530276 rc = 0;
Steve Frencha6ce4932009-04-09 01:14:32 +0000277 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530278 return rc;
Steve French703a3b82009-05-21 22:21:53 +0000279 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800281 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530283 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530285 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 }
287
Joe Perchesb6b38f72010-04-21 03:50:45 +0000288 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
289 inode, file->f_flags, full_path);
Steve French276a74a2009-03-03 18:00:34 +0000290
291 if (oplockEnabled)
292 oplock = REQ_OPLOCK;
293 else
294 oplock = 0;
295
Steve French64cc2c62009-03-04 19:54:08 +0000296 if (!tcon->broken_posix_open && tcon->unix_ext &&
297 (tcon->ses->capabilities & CAP_UNIX) &&
Steve French276a74a2009-03-03 18:00:34 +0000298 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
299 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
300 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
301 /* 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 French276a74a2009-03-03 18:00:34 +0000303 cifs_sb->mnt_file_mode /* ignored */,
304 oflags, &oplock, &netfid, xid);
305 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000306 cFYI(1, "posix open succeeded");
Steve French276a74a2009-03-03 18:00:34 +0000307 /* no need for special case handling of setting mode
308 on read only files needed here */
309
Steve French703a3b82009-05-21 22:21:53 +0000310 pCifsFile = cifs_fill_filedata(file);
Steve French276a74a2009-03-03 18:00:34 +0000311 cifs_posix_open_inode_helper(inode, file, pCifsInode,
312 pCifsFile, oplock, netfid);
313 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000314 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
315 if (tcon->ses->serverNOS)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000316 cERROR(1, "server %s of type %s returned"
Steve French64cc2c62009-03-04 19:54:08 +0000317 " unexpected error on SMB posix open"
318 ", disabling posix open support."
319 " Check if server update available.",
320 tcon->ses->serverName,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000321 tcon->ses->serverNOS);
Steve French64cc2c62009-03-04 19:54:08 +0000322 tcon->broken_posix_open = true;
Steve French276a74a2009-03-03 18:00:34 +0000323 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
324 (rc != -EOPNOTSUPP)) /* path not found or net err */
325 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000326 /* else fallthrough to retry open the old way on network i/o
327 or DFS errors */
Steve French276a74a2009-03-03 18:00:34 +0000328 }
329
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 desiredAccess = cifs_convert_flags(file->f_flags);
331
332/*********************************************************************
333 * open flag mapping table:
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000334 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 * POSIX Flag CIFS Disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000336 * ---------- ----------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 * O_CREAT FILE_OPEN_IF
338 * O_CREAT | O_EXCL FILE_CREATE
339 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
340 * O_TRUNC FILE_OVERWRITE
341 * none of the above FILE_OPEN
342 *
343 * Note that there is not a direct match between disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000344 * FILE_SUPERSEDE (ie create whether or not file exists although
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 * O_CREAT | O_TRUNC is similar but truncates the existing
346 * file rather than creating a new file as FILE_SUPERSEDE does
347 * (which uses the attributes / metadata passed in on open call)
348 *?
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000349 *? O_SYNC is a reasonable match to CIFS writethrough flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 *? and the read write flags match reasonably. O_LARGEFILE
351 *? is irrelevant because largefile support is always used
352 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
353 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
354 *********************************************************************/
355
356 disposition = cifs_get_disposition(file->f_flags);
357
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 /* BB pass O_SYNC flag through on file attributes .. BB */
359
360 /* Also refresh inode by passing in file_info buf returned by SMBOpen
361 and calling get_inode_info with returned buf (at least helps
362 non-Unix server case) */
363
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000364 /* BB we can not do this if this is the second open of a file
365 and the first handle has writebehind data, we might be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
367 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
368 if (!buf) {
369 rc = -ENOMEM;
370 goto out;
371 }
Steve French5bafd762006-06-07 00:18:43 +0000372
373 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
Steve French276a74a2009-03-03 18:00:34 +0000374 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
Steve French5bafd762006-06-07 00:18:43 +0000375 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
Steve French737b7582005-04-28 22:41:06 -0700376 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
377 & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000378 else
379 rc = -EIO; /* no NT SMB support fall into legacy open below */
380
Steve Frencha9d02ad2005-08-24 23:06:05 -0700381 if (rc == -EIO) {
382 /* Old server, try legacy style OpenX */
Steve French276a74a2009-03-03 18:00:34 +0000383 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
Steve Frencha9d02ad2005-08-24 23:06:05 -0700384 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
385 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
386 & CIFS_MOUNT_MAP_SPECIAL_CHR);
387 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000389 cFYI(1, "cifs_open returned 0x%x", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390 goto out;
391 }
Jeff Layton3321b792009-09-25 09:53:37 -0400392
Jeff Layton086f68b2009-09-21 14:08:18 -0400393 pCifsFile = cifs_new_fileinfo(inode, netfid, file, file->f_path.mnt,
394 file->f_flags);
395 file->private_data = pCifsFile;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 if (file->private_data == NULL) {
397 rc = -ENOMEM;
398 goto out;
399 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
Jeff Layton3321b792009-09-25 09:53:37 -0400401 rc = cifs_open_inode_helper(inode, file, pCifsInode, pCifsFile, tcon,
402 &oplock, buf, full_path, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000404 if (oplock & CIFS_CREATE_ACTION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 /* time to set mode which we can not set earlier due to
406 problems creating new read-only files */
Steve French276a74a2009-03-03 18:00:34 +0000407 if (tcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400408 struct cifs_unix_set_info_args args = {
409 .mode = inode->i_mode,
410 .uid = NO_CHANGE_64,
411 .gid = NO_CHANGE_64,
412 .ctime = NO_CHANGE_64,
413 .atime = NO_CHANGE_64,
414 .mtime = NO_CHANGE_64,
415 .device = 0,
416 };
Jeff Layton01ea95e2009-07-09 20:02:49 -0400417 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
418 cifs_sb->local_nls,
419 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700420 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 }
422 }
423
424out:
425 kfree(buf);
426 kfree(full_path);
427 FreeXid(xid);
428 return rc;
429}
430
Adrian Bunk04187262006-06-30 18:23:04 +0200431/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432/* to server was lost */
433static int cifs_relock_file(struct cifsFileInfo *cifsFile)
434{
435 int rc = 0;
436
437/* BB list all locks open on this file and relock */
438
439 return rc;
440}
441
Steve French4b18f2a2008-04-29 00:06:05 +0000442static int cifs_reopen_file(struct file *file, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443{
444 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400445 int xid;
446 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 struct cifs_sb_info *cifs_sb;
Steve French7fc8f4e2009-02-23 20:43:11 +0000448 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 struct cifsFileInfo *pCifsFile;
450 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000451 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 char *full_path = NULL;
453 int desiredAccess;
454 int disposition = FILE_OPEN;
455 __u16 netfid;
456
Steve Frenchad7a2922008-02-07 23:25:02 +0000457 if (file->private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 pCifsFile = (struct cifsFileInfo *)file->private_data;
Steve Frenchad7a2922008-02-07 23:25:02 +0000459 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 return -EBADF;
461
462 xid = GetXid();
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400463 mutex_lock(&pCifsFile->fh_mutex);
Steve French4b18f2a2008-04-29 00:06:05 +0000464 if (!pCifsFile->invalidHandle) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400465 mutex_unlock(&pCifsFile->fh_mutex);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530466 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530468 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 }
470
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800471 if (file->f_path.dentry == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000472 cERROR(1, "no valid name if dentry freed");
Steve French3a9f4622007-04-04 17:10:24 +0000473 dump_stack();
474 rc = -EBADF;
475 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 }
Steve French3a9f4622007-04-04 17:10:24 +0000477
478 inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000479 if (inode == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000480 cERROR(1, "inode not valid");
Steve French3a9f4622007-04-04 17:10:24 +0000481 dump_stack();
482 rc = -EBADF;
483 goto reopen_error_exit;
484 }
Steve French50c2f752007-07-13 00:33:32 +0000485
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 cifs_sb = CIFS_SB(inode->i_sb);
Steve French7fc8f4e2009-02-23 20:43:11 +0000487 tcon = cifs_sb->tcon;
Steve French3a9f4622007-04-04 17:10:24 +0000488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489/* can not grab rename sem here because various ops, including
490 those that already have the rename sem can end up causing writepage
491 to get called and if the server was down that means we end up here,
492 and we can never tell if the caller already has the rename_sem */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800493 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000495 rc = -ENOMEM;
496reopen_error_exit:
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400497 mutex_unlock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000499 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 }
501
Joe Perchesb6b38f72010-04-21 03:50:45 +0000502 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
503 inode, file->f_flags, full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
505 if (oplockEnabled)
506 oplock = REQ_OPLOCK;
507 else
Steve French4b18f2a2008-04-29 00:06:05 +0000508 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509
Steve French7fc8f4e2009-02-23 20:43:11 +0000510 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
511 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
512 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
513 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
514 /* can not refresh inode info since size could be stale */
Jeff Layton3bc303c2009-09-21 06:47:50 -0400515 rc = cifs_posix_open(full_path, NULL, file->f_path.mnt,
Steve French7fc8f4e2009-02-23 20:43:11 +0000516 cifs_sb->mnt_file_mode /* ignored */,
517 oflags, &oplock, &netfid, xid);
518 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000519 cFYI(1, "posix reopen succeeded");
Steve French7fc8f4e2009-02-23 20:43:11 +0000520 goto reopen_success;
521 }
522 /* fallthrough to retry open the old way on errors, especially
523 in the reconnect path it is important to retry hard */
524 }
525
526 desiredAccess = cifs_convert_flags(file->f_flags);
527
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000529 by SMBOpen and then calling get_inode_info with returned buf
530 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 and server version of file size can be stale. If we knew for sure
532 that inode was not dirty locally we could do this */
533
Steve French7fc8f4e2009-02-23 20:43:11 +0000534 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 CREATE_NOT_DIR, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000536 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700537 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 if (rc) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400539 mutex_unlock(&pCifsFile->fh_mutex);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000540 cFYI(1, "cifs_open returned 0x%x", rc);
541 cFYI(1, "oplock: %d", oplock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 } else {
Steve French7fc8f4e2009-02-23 20:43:11 +0000543reopen_success:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 pCifsFile->netfid = netfid;
Steve French4b18f2a2008-04-29 00:06:05 +0000545 pCifsFile->invalidHandle = false;
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400546 mutex_unlock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 pCifsInode = CIFS_I(inode);
548 if (pCifsInode) {
549 if (can_flush) {
Jeff Laytoncea21802007-11-20 23:19:03 +0000550 rc = filemap_write_and_wait(inode->i_mapping);
551 if (rc != 0)
552 CIFS_I(inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 /* temporarily disable caching while we
554 go to server to get inode info */
Steve French4b18f2a2008-04-29 00:06:05 +0000555 pCifsInode->clientCanCacheAll = false;
556 pCifsInode->clientCanCacheRead = false;
Steve French7fc8f4e2009-02-23 20:43:11 +0000557 if (tcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 rc = cifs_get_inode_info_unix(&inode,
559 full_path, inode->i_sb, xid);
560 else
561 rc = cifs_get_inode_info(&inode,
562 full_path, NULL, inode->i_sb,
Steve French8b1327f2008-03-14 22:37:16 +0000563 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 } /* else we are writing out data to server already
565 and could deadlock if we tried to flush data, and
566 since we do not know if we have data that would
567 invalidate the current end of file on the server
568 we can not go to the server to get the new inod
569 info */
570 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000571 pCifsInode->clientCanCacheAll = true;
572 pCifsInode->clientCanCacheRead = true;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000573 cFYI(1, "Exclusive Oplock granted on inode %p",
574 file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 } else if ((oplock & 0xF) == OPLOCK_READ) {
Steve French4b18f2a2008-04-29 00:06:05 +0000576 pCifsInode->clientCanCacheRead = true;
577 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 } else {
Steve French4b18f2a2008-04-29 00:06:05 +0000579 pCifsInode->clientCanCacheRead = false;
580 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 }
582 cifs_relock_file(pCifsFile);
583 }
584 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 kfree(full_path);
586 FreeXid(xid);
587 return rc;
588}
589
590int cifs_close(struct inode *inode, struct file *file)
591{
592 int rc = 0;
Steve French15745322007-09-07 22:23:48 +0000593 int xid, timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 struct cifs_sb_info *cifs_sb;
595 struct cifsTconInfo *pTcon;
596 struct cifsFileInfo *pSMBFile =
597 (struct cifsFileInfo *)file->private_data;
598
599 xid = GetXid();
600
601 cifs_sb = CIFS_SB(inode->i_sb);
602 pTcon = cifs_sb->tcon;
603 if (pSMBFile) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000604 struct cifsLockInfo *li, *tmp;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000605 write_lock(&GlobalSMBSeslock);
Steve French4b18f2a2008-04-29 00:06:05 +0000606 pSMBFile->closePend = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 if (pTcon) {
608 /* no sense reconnecting to close a file that is
609 already closed */
Steve French3b795212008-11-13 19:45:32 +0000610 if (!pTcon->need_reconnect) {
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000611 write_unlock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +0000612 timeout = 2;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400613 while ((atomic_read(&pSMBFile->count) != 1)
Steve French15745322007-09-07 22:23:48 +0000614 && (timeout <= 2048)) {
Steve French23e7dd72005-10-20 13:44:56 -0700615 /* Give write a better chance to get to
616 server ahead of the close. We do not
617 want to add a wait_q here as it would
618 increase the memory utilization as
619 the struct would be in each open file,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000620 but this should give enough time to
Steve French23e7dd72005-10-20 13:44:56 -0700621 clear the socket */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000622 cFYI(DBG2, "close delay, write pending");
Steve French23e7dd72005-10-20 13:44:56 -0700623 msleep(timeout);
624 timeout *= 4;
Steve French4891d532006-11-07 16:31:16 +0000625 }
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000626 if (!pTcon->need_reconnect &&
627 !pSMBFile->invalidHandle)
628 rc = CIFSSMBClose(xid, pTcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 pSMBFile->netfid);
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000630 } else
631 write_unlock(&GlobalSMBSeslock);
632 } else
633 write_unlock(&GlobalSMBSeslock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000634
635 /* Delete any outstanding lock records.
636 We'll lose them when the file is closed anyway. */
Roland Dreier796e5662007-05-03 04:33:45 +0000637 mutex_lock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000638 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
639 list_del(&li->llist);
640 kfree(li);
641 }
Roland Dreier796e5662007-05-03 04:33:45 +0000642 mutex_unlock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000643
Steve Frenchcbe04762005-04-28 22:41:05 -0700644 write_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 list_del(&pSMBFile->flist);
646 list_del(&pSMBFile->tlist);
Steve Frenchcbe04762005-04-28 22:41:05 -0700647 write_unlock(&GlobalSMBSeslock);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400648 cifsFileInfo_put(file->private_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 file->private_data = NULL;
650 } else
651 rc = -EBADF;
652
Steve French4efa53f2007-09-11 05:50:53 +0000653 read_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 if (list_empty(&(CIFS_I(inode)->openFileList))) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000655 cFYI(1, "closing last open instance for inode %p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 /* if the file is not open we do not know if we can cache info
657 on this inode, much less write behind and read ahead */
Steve French4b18f2a2008-04-29 00:06:05 +0000658 CIFS_I(inode)->clientCanCacheRead = false;
659 CIFS_I(inode)->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 }
Steve French4efa53f2007-09-11 05:50:53 +0000661 read_unlock(&GlobalSMBSeslock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000662 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 rc = CIFS_I(inode)->write_behind_rc;
664 FreeXid(xid);
665 return rc;
666}
667
668int cifs_closedir(struct inode *inode, struct file *file)
669{
670 int rc = 0;
671 int xid;
672 struct cifsFileInfo *pCFileStruct =
673 (struct cifsFileInfo *)file->private_data;
674 char *ptmp;
675
Joe Perchesb6b38f72010-04-21 03:50:45 +0000676 cFYI(1, "Closedir inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
678 xid = GetXid();
679
680 if (pCFileStruct) {
681 struct cifsTconInfo *pTcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000682 struct cifs_sb_info *cifs_sb =
683 CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684
685 pTcon = cifs_sb->tcon;
686
Joe Perchesb6b38f72010-04-21 03:50:45 +0000687 cFYI(1, "Freeing private data in close dir");
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000688 write_lock(&GlobalSMBSeslock);
Steve French4b18f2a2008-04-29 00:06:05 +0000689 if (!pCFileStruct->srch_inf.endOfSearch &&
690 !pCFileStruct->invalidHandle) {
691 pCFileStruct->invalidHandle = true;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000692 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000694 cFYI(1, "Closing uncompleted readdir with rc %d",
695 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 /* not much we can do if it fails anyway, ignore rc */
697 rc = 0;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000698 } else
699 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
701 if (ptmp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000702 cFYI(1, "closedir free smb buf in srch struct");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000704 if (pCFileStruct->srch_inf.smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000705 cifs_small_buf_release(ptmp);
706 else
707 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 kfree(file->private_data);
710 file->private_data = NULL;
711 }
712 /* BB can we lock the filestruct while this is going on? */
713 FreeXid(xid);
714 return rc;
715}
716
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000717static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
718 __u64 offset, __u8 lockType)
719{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000720 struct cifsLockInfo *li =
721 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000722 if (li == NULL)
723 return -ENOMEM;
724 li->offset = offset;
725 li->length = len;
726 li->type = lockType;
Roland Dreier796e5662007-05-03 04:33:45 +0000727 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000728 list_add(&li->llist, &fid->llist);
Roland Dreier796e5662007-05-03 04:33:45 +0000729 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000730 return 0;
731}
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
734{
735 int rc, xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 __u32 numLock = 0;
737 __u32 numUnlock = 0;
738 __u64 length;
Steve French4b18f2a2008-04-29 00:06:05 +0000739 bool wait_flag = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 struct cifs_sb_info *cifs_sb;
Steve French13a6e422008-12-02 17:24:33 +0000741 struct cifsTconInfo *tcon;
Steve French08547b02006-02-28 22:39:25 +0000742 __u16 netfid;
743 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
Steve French13a6e422008-12-02 17:24:33 +0000744 bool posix_locking = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745
746 length = 1 + pfLock->fl_end - pfLock->fl_start;
747 rc = -EACCES;
748 xid = GetXid();
749
Joe Perchesb6b38f72010-04-21 03:50:45 +0000750 cFYI(1, "Lock parm: 0x%x flockflags: "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 "0x%x flocktype: 0x%x start: %lld end: %lld",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000752 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000753 pfLock->fl_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
755 if (pfLock->fl_flags & FL_POSIX)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000756 cFYI(1, "Posix");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 if (pfLock->fl_flags & FL_FLOCK)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000758 cFYI(1, "Flock");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 if (pfLock->fl_flags & FL_SLEEP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000760 cFYI(1, "Blocking lock");
Steve French4b18f2a2008-04-29 00:06:05 +0000761 wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 }
763 if (pfLock->fl_flags & FL_ACCESS)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000764 cFYI(1, "Process suspended by mandatory locking - "
765 "not implemented yet");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 if (pfLock->fl_flags & FL_LEASE)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000767 cFYI(1, "Lease on file - not implemented yet");
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000768 if (pfLock->fl_flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
Joe Perchesb6b38f72010-04-21 03:50:45 +0000770 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
772 if (pfLock->fl_type == F_WRLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000773 cFYI(1, "F_WRLCK ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 numLock = 1;
775 } else if (pfLock->fl_type == F_UNLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000776 cFYI(1, "F_UNLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 numUnlock = 1;
Steve Frenchd47d7c12006-02-28 03:45:48 +0000778 /* Check if unlock includes more than
779 one lock range */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 } else if (pfLock->fl_type == F_RDLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000781 cFYI(1, "F_RDLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 lockType |= LOCKING_ANDX_SHARED_LOCK;
783 numLock = 1;
784 } else if (pfLock->fl_type == F_EXLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000785 cFYI(1, "F_EXLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 numLock = 1;
787 } else if (pfLock->fl_type == F_SHLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000788 cFYI(1, "F_SHLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 lockType |= LOCKING_ANDX_SHARED_LOCK;
790 numLock = 1;
791 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +0000792 cFYI(1, "Unknown type of lock");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800794 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Steve French13a6e422008-12-02 17:24:33 +0000795 tcon = cifs_sb->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
797 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530798 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530800 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 }
Steve French08547b02006-02-28 22:39:25 +0000802 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803
Steve French13a6e422008-12-02 17:24:33 +0000804 if ((tcon->ses->capabilities & CAP_UNIX) &&
805 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
Steve Frenchacc18aa2008-12-02 18:53:55 +0000806 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
Steve French13a6e422008-12-02 17:24:33 +0000807 posix_locking = 1;
Steve French08547b02006-02-28 22:39:25 +0000808 /* BB add code here to normalize offset and length to
809 account for negative length which we can not accept over the
810 wire */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 if (IS_GETLK(cmd)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000812 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000813 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000814 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000815 posix_lock_type = CIFS_RDLCK;
816 else
817 posix_lock_type = CIFS_WRLCK;
Steve French13a6e422008-12-02 17:24:33 +0000818 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000819 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000820 posix_lock_type, wait_flag);
821 FreeXid(xid);
822 return rc;
823 }
824
825 /* BB we could chain these into one lock request BB */
Steve French13a6e422008-12-02 17:24:33 +0000826 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
Steve French08547b02006-02-28 22:39:25 +0000827 0, 1, lockType, 0 /* wait flag */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 if (rc == 0) {
Steve French13a6e422008-12-02 17:24:33 +0000829 rc = CIFSSMBLock(xid, tcon, netfid, length,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 pfLock->fl_start, 1 /* numUnlock */ ,
831 0 /* numLock */ , lockType,
832 0 /* wait flag */ );
833 pfLock->fl_type = F_UNLCK;
834 if (rc != 0)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000835 cERROR(1, "Error unlocking previously locked "
836 "range %d during test of lock", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 rc = 0;
838
839 } else {
840 /* if rc == ERR_SHARING_VIOLATION ? */
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400841 rc = 0;
842
843 if (lockType & LOCKING_ANDX_SHARED_LOCK) {
844 pfLock->fl_type = F_WRLCK;
845 } else {
846 rc = CIFSSMBLock(xid, tcon, netfid, length,
847 pfLock->fl_start, 0, 1,
848 lockType | LOCKING_ANDX_SHARED_LOCK,
849 0 /* wait flag */);
850 if (rc == 0) {
851 rc = CIFSSMBLock(xid, tcon, netfid,
852 length, pfLock->fl_start, 1, 0,
853 lockType |
854 LOCKING_ANDX_SHARED_LOCK,
855 0 /* wait flag */);
856 pfLock->fl_type = F_RDLCK;
857 if (rc != 0)
Steve Frenchf19159d2010-04-21 04:12:10 +0000858 cERROR(1, "Error unlocking "
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400859 "previously locked range %d "
Steve Frenchf19159d2010-04-21 04:12:10 +0000860 "during test of lock", rc);
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400861 rc = 0;
862 } else {
863 pfLock->fl_type = F_WRLCK;
864 rc = 0;
865 }
866 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 }
868
869 FreeXid(xid);
870 return rc;
871 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000872
873 if (!numLock && !numUnlock) {
874 /* if no lock or unlock then nothing
875 to do since we do not know what it is */
876 FreeXid(xid);
877 return -EOPNOTSUPP;
878 }
879
880 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000881 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000882 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000883 posix_lock_type = CIFS_RDLCK;
884 else
885 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +0000886
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000887 if (numUnlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +0000888 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000889
Steve French13a6e422008-12-02 17:24:33 +0000890 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000891 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000892 posix_lock_type, wait_flag);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000893 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000894 struct cifsFileInfo *fid =
895 (struct cifsFileInfo *)file->private_data;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000896
897 if (numLock) {
Steve French13a6e422008-12-02 17:24:33 +0000898 rc = CIFSSMBLock(xid, tcon, netfid, length,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000899 pfLock->fl_start,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000900 0, numLock, lockType, wait_flag);
901
902 if (rc == 0) {
903 /* For Windows locks we must store them. */
904 rc = store_file_lock(fid, length,
905 pfLock->fl_start, lockType);
906 }
907 } else if (numUnlock) {
908 /* For each stored lock that this unlock overlaps
909 completely, unlock it. */
910 int stored_rc = 0;
911 struct cifsLockInfo *li, *tmp;
912
Steve French6b70c952006-09-21 07:35:29 +0000913 rc = 0;
Roland Dreier796e5662007-05-03 04:33:45 +0000914 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000915 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
916 if (pfLock->fl_start <= li->offset &&
Steve Frenchc19eb712007-08-24 03:22:48 +0000917 (pfLock->fl_start + length) >=
Jeff Layton39db8102007-08-24 03:16:51 +0000918 (li->offset + li->length)) {
Steve French13a6e422008-12-02 17:24:33 +0000919 stored_rc = CIFSSMBLock(xid, tcon,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000920 netfid,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000921 li->length, li->offset,
Steve French4b18f2a2008-04-29 00:06:05 +0000922 1, 0, li->type, false);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000923 if (stored_rc)
924 rc = stored_rc;
Pavel Shilovsky2c964d12010-04-21 19:44:24 +0000925 else {
926 list_del(&li->llist);
927 kfree(li);
928 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000929 }
930 }
Roland Dreier796e5662007-05-03 04:33:45 +0000931 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000932 }
933 }
934
Steve Frenchd634cc12005-08-26 14:42:59 -0500935 if (pfLock->fl_flags & FL_POSIX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 posix_lock_file_wait(file, pfLock);
937 FreeXid(xid);
938 return rc;
939}
940
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400941/*
942 * Set the timeout on write requests past EOF. For some servers (Windows)
943 * these calls can be very long.
944 *
945 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
946 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
947 * The 10M cutoff is totally arbitrary. A better scheme for this would be
948 * welcome if someone wants to suggest one.
949 *
950 * We may be able to do a better job with this if there were some way to
951 * declare that a file should be sparse.
952 */
953static int
954cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
955{
956 if (offset <= cifsi->server_eof)
957 return CIFS_STD_OP;
958 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
959 return CIFS_VLONG_OP;
960 else
961 return CIFS_LONG_OP;
962}
963
964/* update the file size (if needed) after a write */
965static void
966cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
967 unsigned int bytes_written)
968{
969 loff_t end_of_write = offset + bytes_written;
970
971 if (end_of_write > cifsi->server_eof)
972 cifsi->server_eof = end_of_write;
973}
974
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975ssize_t cifs_user_write(struct file *file, const char __user *write_data,
976 size_t write_size, loff_t *poffset)
977{
978 int rc = 0;
979 unsigned int bytes_written = 0;
980 unsigned int total_written;
981 struct cifs_sb_info *cifs_sb;
982 struct cifsTconInfo *pTcon;
983 int xid, long_op;
984 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400985 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800987 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988
989 pTcon = cifs_sb->tcon;
990
Joe Perchesb6b38f72010-04-21 03:50:45 +0000991 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
992 *poffset, file->f_path.dentry->d_name.name); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993
994 if (file->private_data == NULL)
995 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000996 open_file = (struct cifsFileInfo *) file->private_data;
Steve French50c2f752007-07-13 00:33:32 +0000997
Jeff Layton838726c2008-08-28 07:54:59 -0400998 rc = generic_write_checks(file, poffset, &write_size, 0);
999 if (rc)
1000 return rc;
1001
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001004 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 for (total_written = 0; write_size > total_written;
1006 total_written += bytes_written) {
1007 rc = -EAGAIN;
1008 while (rc == -EAGAIN) {
1009 if (file->private_data == NULL) {
1010 /* file has been closed on us */
1011 FreeXid(xid);
1012 /* if we have gotten here we have written some data
1013 and blocked, and the file has been freed on us while
1014 we blocked so return what we managed to write */
1015 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001016 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017 if (open_file->closePend) {
1018 FreeXid(xid);
1019 if (total_written)
1020 return total_written;
1021 else
1022 return -EBADF;
1023 }
1024 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 /* we could deadlock if we called
1026 filemap_fdatawait from here so tell
1027 reopen_file not to flush data to server
1028 now */
Steve French4b18f2a2008-04-29 00:06:05 +00001029 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 if (rc != 0)
1031 break;
1032 }
1033
1034 rc = CIFSSMBWrite(xid, pTcon,
1035 open_file->netfid,
1036 min_t(const int, cifs_sb->wsize,
1037 write_size - total_written),
1038 *poffset, &bytes_written,
1039 NULL, write_data + total_written, long_op);
1040 }
1041 if (rc || (bytes_written == 0)) {
1042 if (total_written)
1043 break;
1044 else {
1045 FreeXid(xid);
1046 return rc;
1047 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001048 } else {
1049 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001051 }
Steve French133672e2007-11-13 22:41:37 +00001052 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 15 seconds is plenty */
1054 }
1055
Steve Frencha4544342005-08-24 13:59:35 -07001056 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
1058 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001059 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1060 struct inode *inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001061/* Do not update local mtime - server will set its actual value on write
1062 * inode->i_ctime = inode->i_mtime =
Steve French3677db12007-02-26 16:46:11 +00001063 * current_fs_time(inode->i_sb);*/
1064 if (total_written > 0) {
1065 spin_lock(&inode->i_lock);
1066 if (*poffset > file->f_path.dentry->d_inode->i_size)
1067 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 *poffset);
Steve French3677db12007-02-26 16:46:11 +00001069 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001071 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 }
1073 FreeXid(xid);
1074 return total_written;
1075}
1076
1077static ssize_t cifs_write(struct file *file, const char *write_data,
Nick Piggind9414772008-09-24 11:32:59 -04001078 size_t write_size, loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079{
1080 int rc = 0;
1081 unsigned int bytes_written = 0;
1082 unsigned int total_written;
1083 struct cifs_sb_info *cifs_sb;
1084 struct cifsTconInfo *pTcon;
1085 int xid, long_op;
1086 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001087 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001088
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001089 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090
1091 pTcon = cifs_sb->tcon;
1092
Joe Perchesb6b38f72010-04-21 03:50:45 +00001093 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1094 *poffset, file->f_path.dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095
1096 if (file->private_data == NULL)
1097 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +00001098 open_file = (struct cifsFileInfo *)file->private_data;
Steve French50c2f752007-07-13 00:33:32 +00001099
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001101
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001102 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 for (total_written = 0; write_size > total_written;
1104 total_written += bytes_written) {
1105 rc = -EAGAIN;
1106 while (rc == -EAGAIN) {
1107 if (file->private_data == NULL) {
1108 /* file has been closed on us */
1109 FreeXid(xid);
1110 /* if we have gotten here we have written some data
1111 and blocked, and the file has been freed on us
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001112 while we blocked so return what we managed to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 write */
1114 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001115 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 if (open_file->closePend) {
1117 FreeXid(xid);
1118 if (total_written)
1119 return total_written;
1120 else
1121 return -EBADF;
1122 }
1123 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 /* we could deadlock if we called
1125 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001126 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127 server now */
Steve French4b18f2a2008-04-29 00:06:05 +00001128 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 if (rc != 0)
1130 break;
1131 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001132 if (experimEnabled || (pTcon->ses->server &&
1133 ((pTcon->ses->server->secMode &
Steve French08775832006-05-30 18:08:26 +00001134 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +00001135 == 0))) {
Steve French3e844692005-10-03 13:37:24 -07001136 struct kvec iov[2];
1137 unsigned int len;
1138
Steve French0ae0efa2005-10-10 10:57:19 -07001139 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -07001140 write_size - total_written);
1141 /* iov[0] is reserved for smb header */
1142 iov[1].iov_base = (char *)write_data +
1143 total_written;
1144 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001145 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -07001146 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001147 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -07001148 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001149 } else
Steve French60808232006-04-22 15:53:05 +00001150 rc = CIFSSMBWrite(xid, pTcon,
1151 open_file->netfid,
1152 min_t(const int, cifs_sb->wsize,
1153 write_size - total_written),
1154 *poffset, &bytes_written,
1155 write_data + total_written,
1156 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 }
1158 if (rc || (bytes_written == 0)) {
1159 if (total_written)
1160 break;
1161 else {
1162 FreeXid(xid);
1163 return rc;
1164 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001165 } else {
1166 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001168 }
Steve French133672e2007-11-13 22:41:37 +00001169 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 15 seconds is plenty */
1171 }
1172
Steve Frencha4544342005-08-24 13:59:35 -07001173 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174
1175 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001176 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
Steve French004c46b2007-02-17 04:34:13 +00001177/*BB We could make this contingent on superblock ATIME flag too */
Steve French3677db12007-02-26 16:46:11 +00001178/* file->f_path.dentry->d_inode->i_ctime =
1179 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1180 if (total_written > 0) {
1181 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1182 if (*poffset > file->f_path.dentry->d_inode->i_size)
1183 i_size_write(file->f_path.dentry->d_inode,
1184 *poffset);
1185 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 }
Steve French3677db12007-02-26 16:46:11 +00001187 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 }
1189 FreeXid(xid);
1190 return total_written;
1191}
1192
Steve French630f3f0c2007-10-25 21:17:17 +00001193#ifdef CONFIG_CIFS_EXPERIMENTAL
1194struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1195{
1196 struct cifsFileInfo *open_file = NULL;
1197
1198 read_lock(&GlobalSMBSeslock);
1199 /* we could simply get the first_list_entry since write-only entries
1200 are always at the end of the list but since the first entry might
1201 have a close pending, we go through the whole list */
1202 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1203 if (open_file->closePend)
1204 continue;
1205 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1206 (open_file->pfile->f_flags & O_RDONLY))) {
1207 if (!open_file->invalidHandle) {
1208 /* found a good file */
1209 /* lock it so it will not be closed on us */
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001210 cifsFileInfo_get(open_file);
Steve French630f3f0c2007-10-25 21:17:17 +00001211 read_unlock(&GlobalSMBSeslock);
1212 return open_file;
1213 } /* else might as well continue, and look for
1214 another, or simply have the caller reopen it
1215 again rather than trying to fix this handle */
1216 } else /* write only file */
1217 break; /* write only files are last so must be done */
1218 }
1219 read_unlock(&GlobalSMBSeslock);
1220 return NULL;
1221}
1222#endif
1223
Steve Frenchdd99cd82005-10-05 19:32:49 -07001224struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
Steve French6148a742005-10-05 12:23:19 -07001225{
1226 struct cifsFileInfo *open_file;
Jeff Layton2846d382008-09-22 21:33:33 -04001227 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001228 int rc;
Steve French6148a742005-10-05 12:23:19 -07001229
Steve French60808232006-04-22 15:53:05 +00001230 /* Having a null inode here (because mapping->host was set to zero by
1231 the VFS or MM) should not happen but we had reports of on oops (due to
1232 it being zero) during stress testcases so we need to check for it */
1233
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001234 if (cifs_inode == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001235 cERROR(1, "Null inode passed to cifs_writeable_file");
Steve French60808232006-04-22 15:53:05 +00001236 dump_stack();
1237 return NULL;
1238 }
1239
Steve French6148a742005-10-05 12:23:19 -07001240 read_lock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001241refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001242 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2846d382008-09-22 21:33:33 -04001243 if (open_file->closePend ||
1244 (!any_available && open_file->pid != current->tgid))
Steve French6148a742005-10-05 12:23:19 -07001245 continue;
Jeff Layton2846d382008-09-22 21:33:33 -04001246
Steve French6148a742005-10-05 12:23:19 -07001247 if (open_file->pfile &&
1248 ((open_file->pfile->f_flags & O_RDWR) ||
1249 (open_file->pfile->f_flags & O_WRONLY))) {
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001250 cifsFileInfo_get(open_file);
Steve French9b22b0b2007-10-02 01:11:08 +00001251
1252 if (!open_file->invalidHandle) {
1253 /* found a good writable file */
1254 read_unlock(&GlobalSMBSeslock);
1255 return open_file;
1256 }
Steve French8840dee2007-11-16 23:05:52 +00001257
Steve French6148a742005-10-05 12:23:19 -07001258 read_unlock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001259 /* Had to unlock since following call can block */
Steve French4b18f2a2008-04-29 00:06:05 +00001260 rc = cifs_reopen_file(open_file->pfile, false);
Steve French8840dee2007-11-16 23:05:52 +00001261 if (!rc) {
Steve French9b22b0b2007-10-02 01:11:08 +00001262 if (!open_file->closePend)
1263 return open_file;
1264 else { /* start over in case this was deleted */
1265 /* since the list could be modified */
Steve French37c0eb42005-10-05 14:50:29 -07001266 read_lock(&GlobalSMBSeslock);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001267 cifsFileInfo_put(open_file);
Steve French9b22b0b2007-10-02 01:11:08 +00001268 goto refind_writable;
Steve French37c0eb42005-10-05 14:50:29 -07001269 }
1270 }
Steve French9b22b0b2007-10-02 01:11:08 +00001271
1272 /* if it fails, try another handle if possible -
1273 (we can not do this if closePending since
1274 loop could be modified - in which case we
1275 have to start at the beginning of the list
1276 again. Note that it would be bad
1277 to hold up writepages here (rather than
1278 in caller) with continuous retries */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001279 cFYI(1, "wp failed on reopen file");
Steve French9b22b0b2007-10-02 01:11:08 +00001280 read_lock(&GlobalSMBSeslock);
1281 /* can not use this handle, no write
1282 pending on this one after all */
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001283 cifsFileInfo_put(open_file);
Steve French8840dee2007-11-16 23:05:52 +00001284
Steve French9b22b0b2007-10-02 01:11:08 +00001285 if (open_file->closePend) /* list could have changed */
1286 goto refind_writable;
1287 /* else we simply continue to the next entry. Thus
1288 we do not loop on reopen errors. If we
1289 can not reopen the file, for example if we
1290 reconnected to a server with another client
1291 racing to delete or lock the file we would not
1292 make progress if we restarted before the beginning
1293 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001294 }
1295 }
Jeff Layton2846d382008-09-22 21:33:33 -04001296 /* couldn't find useable FH with same pid, try any available */
1297 if (!any_available) {
1298 any_available = true;
1299 goto refind_writable;
1300 }
Steve French6148a742005-10-05 12:23:19 -07001301 read_unlock(&GlobalSMBSeslock);
1302 return NULL;
1303}
1304
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1306{
1307 struct address_space *mapping = page->mapping;
1308 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1309 char *write_data;
1310 int rc = -EFAULT;
1311 int bytes_written = 0;
1312 struct cifs_sb_info *cifs_sb;
1313 struct cifsTconInfo *pTcon;
1314 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001315 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316
1317 if (!mapping || !mapping->host)
1318 return -EFAULT;
1319
1320 inode = page->mapping->host;
1321 cifs_sb = CIFS_SB(inode->i_sb);
1322 pTcon = cifs_sb->tcon;
1323
1324 offset += (loff_t)from;
1325 write_data = kmap(page);
1326 write_data += from;
1327
1328 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1329 kunmap(page);
1330 return -EIO;
1331 }
1332
1333 /* racing with truncate? */
1334 if (offset > mapping->host->i_size) {
1335 kunmap(page);
1336 return 0; /* don't care */
1337 }
1338
1339 /* check to make sure that we are not extending the file */
1340 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001341 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342
Steve French6148a742005-10-05 12:23:19 -07001343 open_file = find_writable_file(CIFS_I(mapping->host));
1344 if (open_file) {
1345 bytes_written = cifs_write(open_file->pfile, write_data,
1346 to-from, &offset);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001347 cifsFileInfo_put(open_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001349 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001350 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001351 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001352 else if (bytes_written < 0)
1353 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001354 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001355 cFYI(1, "No writeable filehandles for inode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 rc = -EIO;
1357 }
1358
1359 kunmap(page);
1360 return rc;
1361}
1362
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001364 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365{
Steve French37c0eb42005-10-05 14:50:29 -07001366 struct backing_dev_info *bdi = mapping->backing_dev_info;
1367 unsigned int bytes_to_write;
1368 unsigned int bytes_written;
1369 struct cifs_sb_info *cifs_sb;
1370 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001371 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001372 pgoff_t index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001373 int range_whole = 0;
1374 struct kvec *iov;
Steve French84d2f072005-10-12 15:32:05 -07001375 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001376 int n_iov = 0;
1377 pgoff_t next;
1378 int nr_pages;
1379 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001380 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001381 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
Steve French37c0eb42005-10-05 14:50:29 -07001382 struct page *page;
1383 struct pagevec pvec;
1384 int rc = 0;
1385 int scanned = 0;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001386 int xid, long_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387
Steve French37c0eb42005-10-05 14:50:29 -07001388 cifs_sb = CIFS_SB(mapping->host->i_sb);
Steve French50c2f752007-07-13 00:33:32 +00001389
Steve French37c0eb42005-10-05 14:50:29 -07001390 /*
1391 * If wsize is smaller that the page cache size, default to writing
1392 * one page at a time via cifs_writepage
1393 */
1394 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1395 return generic_writepages(mapping, wbc);
1396
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001397 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1398 if (cifs_sb->tcon->ses->server->secMode &
1399 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1400 if (!experimEnabled)
Steve French60808232006-04-22 15:53:05 +00001401 return generic_writepages(mapping, wbc);
Steve French4a771182005-10-05 15:14:33 -07001402
Steve French9a0c8232007-02-02 04:21:57 +00001403 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001404 if (iov == NULL)
Steve French9a0c8232007-02-02 04:21:57 +00001405 return generic_writepages(mapping, wbc);
1406
1407
Steve French37c0eb42005-10-05 14:50:29 -07001408 /*
1409 * BB: Is this meaningful for a non-block-device file system?
1410 * If it is, we should test it again after we do I/O
1411 */
1412 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1413 wbc->encountered_congestion = 1;
Steve French9a0c8232007-02-02 04:21:57 +00001414 kfree(iov);
Steve French37c0eb42005-10-05 14:50:29 -07001415 return 0;
1416 }
1417
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 xid = GetXid();
1419
Steve French37c0eb42005-10-05 14:50:29 -07001420 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001421 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001422 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001423 end = -1;
1424 } else {
1425 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1426 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1427 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1428 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001429 scanned = 1;
1430 }
1431retry:
1432 while (!done && (index <= end) &&
1433 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1434 PAGECACHE_TAG_DIRTY,
1435 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1436 int first;
1437 unsigned int i;
1438
Steve French37c0eb42005-10-05 14:50:29 -07001439 first = -1;
1440 next = 0;
1441 n_iov = 0;
1442 bytes_to_write = 0;
1443
1444 for (i = 0; i < nr_pages; i++) {
1445 page = pvec.pages[i];
1446 /*
1447 * At this point we hold neither mapping->tree_lock nor
1448 * lock on the page itself: the page may be truncated or
1449 * invalidated (changing page->mapping to NULL), or even
1450 * swizzled back from swapper_space to tmpfs file
1451 * mapping
1452 */
1453
1454 if (first < 0)
1455 lock_page(page);
Nick Piggin529ae9a2008-08-02 12:01:03 +02001456 else if (!trylock_page(page))
Steve French37c0eb42005-10-05 14:50:29 -07001457 break;
1458
1459 if (unlikely(page->mapping != mapping)) {
1460 unlock_page(page);
1461 break;
1462 }
1463
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001464 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001465 done = 1;
1466 unlock_page(page);
1467 break;
1468 }
1469
1470 if (next && (page->index != next)) {
1471 /* Not next consecutive page */
1472 unlock_page(page);
1473 break;
1474 }
1475
1476 if (wbc->sync_mode != WB_SYNC_NONE)
1477 wait_on_page_writeback(page);
1478
1479 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001480 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001481 unlock_page(page);
1482 break;
1483 }
Steve French84d2f072005-10-12 15:32:05 -07001484
Linus Torvaldscb876f42006-12-23 16:19:07 -08001485 /*
1486 * This actually clears the dirty bit in the radix tree.
1487 * See cifs_writepage() for more commentary.
1488 */
1489 set_page_writeback(page);
1490
Steve French84d2f072005-10-12 15:32:05 -07001491 if (page_offset(page) >= mapping->host->i_size) {
1492 done = 1;
1493 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001494 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001495 break;
1496 }
1497
Steve French37c0eb42005-10-05 14:50:29 -07001498 /*
1499 * BB can we get rid of this? pages are held by pvec
1500 */
1501 page_cache_get(page);
1502
Steve French84d2f072005-10-12 15:32:05 -07001503 len = min(mapping->host->i_size - page_offset(page),
1504 (loff_t)PAGE_CACHE_SIZE);
1505
Steve French37c0eb42005-10-05 14:50:29 -07001506 /* reserve iov[0] for the smb header */
1507 n_iov++;
1508 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001509 iov[n_iov].iov_len = len;
1510 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001511
1512 if (first < 0) {
1513 first = i;
1514 offset = page_offset(page);
1515 }
1516 next = page->index + 1;
1517 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1518 break;
1519 }
1520 if (n_iov) {
Steve French23e7dd72005-10-20 13:44:56 -07001521 /* Search for a writable handle every time we call
1522 * CIFSSMBWrite2. We can't rely on the last handle
1523 * we used to still be valid
1524 */
1525 open_file = find_writable_file(CIFS_I(mapping->host));
1526 if (!open_file) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001527 cERROR(1, "No writable handles for inode");
Steve French23e7dd72005-10-20 13:44:56 -07001528 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001529 } else {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001530 long_op = cifs_write_timeout(cifsi, offset);
Steve French23e7dd72005-10-20 13:44:56 -07001531 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1532 open_file->netfid,
1533 bytes_to_write, offset,
1534 &bytes_written, iov, n_iov,
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001535 long_op);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001536 cifsFileInfo_put(open_file);
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001537 cifs_update_eof(cifsi, offset, bytes_written);
1538
Steve French23e7dd72005-10-20 13:44:56 -07001539 if (rc || bytes_written < bytes_to_write) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001540 cERROR(1, "Write2 ret %d, wrote %d",
1541 rc, bytes_written);
Steve French23e7dd72005-10-20 13:44:56 -07001542 /* BB what if continued retry is
1543 requested via mount flags? */
Jeff Laytoncea21802007-11-20 23:19:03 +00001544 if (rc == -ENOSPC)
1545 set_bit(AS_ENOSPC, &mapping->flags);
1546 else
1547 set_bit(AS_EIO, &mapping->flags);
Steve French23e7dd72005-10-20 13:44:56 -07001548 } else {
1549 cifs_stats_bytes_written(cifs_sb->tcon,
1550 bytes_written);
1551 }
Steve French37c0eb42005-10-05 14:50:29 -07001552 }
1553 for (i = 0; i < n_iov; i++) {
1554 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001555 /* Should we also set page error on
1556 success rc but too little data written? */
1557 /* BB investigate retry logic on temporary
1558 server crash cases and how recovery works
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001559 when page marked as error */
1560 if (rc)
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001561 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001562 kunmap(page);
1563 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001564 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001565 page_cache_release(page);
1566 }
1567 if ((wbc->nr_to_write -= n_iov) <= 0)
1568 done = 1;
1569 index = next;
Dave Kleikampb066a482008-11-18 03:49:05 +00001570 } else
1571 /* Need to re-find the pages we skipped */
1572 index = pvec.pages[0]->index + 1;
1573
Steve French37c0eb42005-10-05 14:50:29 -07001574 pagevec_release(&pvec);
1575 }
1576 if (!scanned && !done) {
1577 /*
1578 * We hit the last page and there is more work to be done: wrap
1579 * back to the start of the file
1580 */
1581 scanned = 1;
1582 index = 0;
1583 goto retry;
1584 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001585 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001586 mapping->writeback_index = index;
1587
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001589 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 return rc;
1591}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001593static int cifs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594{
1595 int rc = -EFAULT;
1596 int xid;
1597
1598 xid = GetXid();
1599/* BB add check for wbc flags */
1600 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001601 if (!PageUptodate(page))
Joe Perchesb6b38f72010-04-21 03:50:45 +00001602 cFYI(1, "ppw - page not up to date");
Linus Torvaldscb876f42006-12-23 16:19:07 -08001603
1604 /*
1605 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1606 *
1607 * A writepage() implementation always needs to do either this,
1608 * or re-dirty the page with "redirty_page_for_writepage()" in
1609 * the case of a failure.
1610 *
1611 * Just unlocking the page will cause the radix tree tag-bits
1612 * to fail to update with the state of the page correctly.
1613 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001614 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1616 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1617 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001618 end_page_writeback(page);
1619 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 FreeXid(xid);
1621 return rc;
1622}
1623
Nick Piggind9414772008-09-24 11:32:59 -04001624static int cifs_write_end(struct file *file, struct address_space *mapping,
1625 loff_t pos, unsigned len, unsigned copied,
1626 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627{
Nick Piggind9414772008-09-24 11:32:59 -04001628 int rc;
1629 struct inode *inode = mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630
Joe Perchesb6b38f72010-04-21 03:50:45 +00001631 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1632 page, pos, copied);
Steve Frenchad7a2922008-02-07 23:25:02 +00001633
Jeff Laytona98ee8c2008-11-26 19:32:33 +00001634 if (PageChecked(page)) {
1635 if (copied == len)
1636 SetPageUptodate(page);
1637 ClearPageChecked(page);
1638 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04001639 SetPageUptodate(page);
1640
Linus Torvalds1da177e2005-04-16 15:20:36 -07001641 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04001642 char *page_data;
1643 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1644 int xid;
1645
1646 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 /* this is probably better than directly calling
1648 partialpage_write since in this function the file handle is
1649 known which we might as well leverage */
1650 /* BB check if anything else missing out of ppw
1651 such as updating last write time */
1652 page_data = kmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001653 rc = cifs_write(file, page_data + offset, copied, &pos);
1654 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001656
1657 FreeXid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001658 } else {
Nick Piggind9414772008-09-24 11:32:59 -04001659 rc = copied;
1660 pos += copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 set_page_dirty(page);
1662 }
1663
Nick Piggind9414772008-09-24 11:32:59 -04001664 if (rc > 0) {
1665 spin_lock(&inode->i_lock);
1666 if (pos > inode->i_size)
1667 i_size_write(inode, pos);
1668 spin_unlock(&inode->i_lock);
1669 }
1670
1671 unlock_page(page);
1672 page_cache_release(page);
1673
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 return rc;
1675}
1676
1677int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1678{
1679 int xid;
1680 int rc = 0;
Steve Frenchb298f222009-02-21 21:17:43 +00001681 struct cifsTconInfo *tcon;
1682 struct cifsFileInfo *smbfile =
1683 (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001684 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685
1686 xid = GetXid();
1687
Joe Perchesb6b38f72010-04-21 03:50:45 +00001688 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1689 dentry->d_name.name, datasync);
Steve French50c2f752007-07-13 00:33:32 +00001690
Jeff Laytoncea21802007-11-20 23:19:03 +00001691 rc = filemap_write_and_wait(inode->i_mapping);
1692 if (rc == 0) {
1693 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 CIFS_I(inode)->write_behind_rc = 0;
Steve Frenchb298f222009-02-21 21:17:43 +00001695 tcon = CIFS_SB(inode->i_sb)->tcon;
Steve Frenchbe652442009-02-23 15:21:59 +00001696 if (!rc && tcon && smbfile &&
Steve French4717bed2009-02-24 14:44:19 +00001697 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
Steve Frenchb298f222009-02-21 21:17:43 +00001698 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
Jeff Laytoncea21802007-11-20 23:19:03 +00001699 }
Steve Frenchb298f222009-02-21 21:17:43 +00001700
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 FreeXid(xid);
1702 return rc;
1703}
1704
NeilBrown3978d7172006-03-26 01:37:17 -08001705/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706{
1707 struct address_space *mapping;
1708 struct inode *inode;
1709 unsigned long index = page->index;
1710 unsigned int rpages = 0;
1711 int rc = 0;
1712
Steve Frenchf19159d2010-04-21 04:12:10 +00001713 cFYI(1, "sync page %p", page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 mapping = page->mapping;
1715 if (!mapping)
1716 return 0;
1717 inode = mapping->host;
1718 if (!inode)
NeilBrown3978d7172006-03-26 01:37:17 -08001719 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001721/* fill in rpages then
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1723
Joe Perchesb6b38f72010-04-21 03:50:45 +00001724/* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
NeilBrown3978d7172006-03-26 01:37:17 -08001726#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 if (rc < 0)
1728 return rc;
1729 return 0;
NeilBrown3978d7172006-03-26 01:37:17 -08001730#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731} */
1732
1733/*
1734 * As file closes, flush all cached write data for this inode checking
1735 * for write behind errors.
1736 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001737int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001739 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 int rc = 0;
1741
1742 /* Rather than do the steps manually:
1743 lock the inode for writing
1744 loop through pages looking for write behind data (dirty pages)
1745 coalesce into contiguous 16K (or smaller) chunks to write to server
1746 send to server (prefer in parallel)
1747 deal with writebehind errors
1748 unlock inode for writing
1749 filemapfdatawrite appears easier for the time being */
1750
1751 rc = filemap_fdatawrite(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +00001752 /* reset wb rc if we were able to write out dirty pages */
1753 if (!rc) {
1754 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001756 }
Steve French50c2f752007-07-13 00:33:32 +00001757
Joe Perchesb6b38f72010-04-21 03:50:45 +00001758 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759
1760 return rc;
1761}
1762
1763ssize_t cifs_user_read(struct file *file, char __user *read_data,
1764 size_t read_size, loff_t *poffset)
1765{
1766 int rc = -EACCES;
1767 unsigned int bytes_read = 0;
1768 unsigned int total_read = 0;
1769 unsigned int current_read_size;
1770 struct cifs_sb_info *cifs_sb;
1771 struct cifsTconInfo *pTcon;
1772 int xid;
1773 struct cifsFileInfo *open_file;
1774 char *smb_read_data;
1775 char __user *current_offset;
1776 struct smb_com_read_rsp *pSMBr;
1777
1778 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001779 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 pTcon = cifs_sb->tcon;
1781
1782 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301783 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301785 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 }
1787 open_file = (struct cifsFileInfo *)file->private_data;
1788
Steve Frenchad7a2922008-02-07 23:25:02 +00001789 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001790 cFYI(1, "attempting read on write only file instance");
Steve Frenchad7a2922008-02-07 23:25:02 +00001791
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 for (total_read = 0, current_offset = read_data;
1793 read_size > total_read;
1794 total_read += bytes_read, current_offset += bytes_read) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001795 current_read_size = min_t(const int, read_size - total_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 cifs_sb->rsize);
1797 rc = -EAGAIN;
1798 smb_read_data = NULL;
1799 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001800 int buf_type = CIFS_NO_BUFFER;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001801 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001803 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 if (rc != 0)
1805 break;
1806 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001807 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001808 open_file->netfid,
1809 current_read_size, *poffset,
1810 &bytes_read, &smb_read_data,
1811 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001814 if (copy_to_user(current_offset,
1815 smb_read_data +
1816 4 /* RFC1001 length field */ +
1817 le16_to_cpu(pSMBr->DataOffset),
Steve Frenchad7a2922008-02-07 23:25:02 +00001818 bytes_read))
Steve French93544cc2006-02-14 22:30:52 -06001819 rc = -EFAULT;
Steve French93544cc2006-02-14 22:30:52 -06001820
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001821 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001822 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001823 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001824 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 smb_read_data = NULL;
1826 }
1827 }
1828 if (rc || (bytes_read == 0)) {
1829 if (total_read) {
1830 break;
1831 } else {
1832 FreeXid(xid);
1833 return rc;
1834 }
1835 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001836 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 *poffset += bytes_read;
1838 }
1839 }
1840 FreeXid(xid);
1841 return total_read;
1842}
1843
1844
1845static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1846 loff_t *poffset)
1847{
1848 int rc = -EACCES;
1849 unsigned int bytes_read = 0;
1850 unsigned int total_read;
1851 unsigned int current_read_size;
1852 struct cifs_sb_info *cifs_sb;
1853 struct cifsTconInfo *pTcon;
1854 int xid;
1855 char *current_offset;
1856 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001857 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858
1859 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001860 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 pTcon = cifs_sb->tcon;
1862
1863 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301864 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301866 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 }
1868 open_file = (struct cifsFileInfo *)file->private_data;
1869
1870 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001871 cFYI(1, "attempting read on write only file instance");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001873 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 read_size > total_read;
1875 total_read += bytes_read, current_offset += bytes_read) {
1876 current_read_size = min_t(const int, read_size - total_read,
1877 cifs_sb->rsize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001878 /* For windows me and 9x we do not want to request more
1879 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001880 if ((pTcon->ses) &&
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001881 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1882 current_read_size = min_t(const int, current_read_size,
1883 pTcon->ses->server->maxBuf - 128);
1884 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 rc = -EAGAIN;
1886 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001887 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001889 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 if (rc != 0)
1891 break;
1892 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001893 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001894 open_file->netfid,
1895 current_read_size, *poffset,
1896 &bytes_read, &current_offset,
1897 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 }
1899 if (rc || (bytes_read == 0)) {
1900 if (total_read) {
1901 break;
1902 } else {
1903 FreeXid(xid);
1904 return rc;
1905 }
1906 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001907 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 *poffset += bytes_read;
1909 }
1910 }
1911 FreeXid(xid);
1912 return total_read;
1913}
1914
1915int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1916{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 int rc, xid;
1918
1919 xid = GetXid();
Jeff Laytonabab0952010-02-12 07:44:18 -05001920 rc = cifs_revalidate_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001922 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 FreeXid(xid);
1924 return rc;
1925 }
1926 rc = generic_file_mmap(file, vma);
1927 FreeXid(xid);
1928 return rc;
1929}
1930
1931
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001932static void cifs_copy_cache_pages(struct address_space *mapping,
Nick Piggin315e9952010-04-21 03:18:28 +00001933 struct list_head *pages, int bytes_read, char *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001934{
1935 struct page *page;
1936 char *target;
1937
1938 while (bytes_read > 0) {
1939 if (list_empty(pages))
1940 break;
1941
1942 page = list_entry(pages->prev, struct page, lru);
1943 list_del(&page->lru);
1944
Nick Piggin315e9952010-04-21 03:18:28 +00001945 if (add_to_page_cache_lru(page, mapping, page->index,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 GFP_KERNEL)) {
1947 page_cache_release(page);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001948 cFYI(1, "Add page cache failed");
Steve French3079ca62005-06-09 14:44:07 -07001949 data += PAGE_CACHE_SIZE;
1950 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 continue;
1952 }
1953
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001954 target = kmap_atomic(page, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955
1956 if (PAGE_CACHE_SIZE > bytes_read) {
1957 memcpy(target, data, bytes_read);
1958 /* zero the tail end of this partial page */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001959 memset(target + bytes_read, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 PAGE_CACHE_SIZE - bytes_read);
1961 bytes_read = 0;
1962 } else {
1963 memcpy(target, data, PAGE_CACHE_SIZE);
1964 bytes_read -= PAGE_CACHE_SIZE;
1965 }
1966 kunmap_atomic(target, KM_USER0);
1967
1968 flush_dcache_page(page);
1969 SetPageUptodate(page);
1970 unlock_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971 data += PAGE_CACHE_SIZE;
1972 }
1973 return;
1974}
1975
1976static int cifs_readpages(struct file *file, struct address_space *mapping,
1977 struct list_head *page_list, unsigned num_pages)
1978{
1979 int rc = -EACCES;
1980 int xid;
1981 loff_t offset;
1982 struct page *page;
1983 struct cifs_sb_info *cifs_sb;
1984 struct cifsTconInfo *pTcon;
Steve French2c2130e2007-10-12 19:10:28 +00001985 unsigned int bytes_read = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001986 unsigned int read_size, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 char *smb_read_data = NULL;
1988 struct smb_com_read_rsp *pSMBr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001990 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991
1992 xid = GetXid();
1993 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301994 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301996 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 }
1998 open_file = (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001999 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 pTcon = cifs_sb->tcon;
Steve Frenchbfa0d752005-08-31 21:50:37 -07002001
Steve Frenchf19159d2010-04-21 04:12:10 +00002002 cFYI(DBG2, "rpages: num pages %d", num_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003 for (i = 0; i < num_pages; ) {
2004 unsigned contig_pages;
2005 struct page *tmp_page;
2006 unsigned long expected_index;
2007
2008 if (list_empty(page_list))
2009 break;
2010
2011 page = list_entry(page_list->prev, struct page, lru);
2012 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2013
2014 /* count adjacent pages that we will read into */
2015 contig_pages = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002016 expected_index =
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 list_entry(page_list->prev, struct page, lru)->index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002018 list_for_each_entry_reverse(tmp_page, page_list, lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 if (tmp_page->index == expected_index) {
2020 contig_pages++;
2021 expected_index++;
2022 } else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002023 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 }
2025 if (contig_pages + i > num_pages)
2026 contig_pages = num_pages - i;
2027
2028 /* for reads over a certain size could initiate async
2029 read ahead */
2030
2031 read_size = contig_pages * PAGE_CACHE_SIZE;
2032 /* Read size needs to be in multiples of one page */
2033 read_size = min_t(const unsigned int, read_size,
2034 cifs_sb->rsize & PAGE_CACHE_MASK);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002035 cFYI(DBG2, "rpages: read size 0x%x contiguous pages %d",
2036 read_size, contig_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 rc = -EAGAIN;
2038 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002039 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00002041 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 if (rc != 0)
2043 break;
2044 }
2045
Steve Frenchbfa0d752005-08-31 21:50:37 -07002046 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08002047 open_file->netfid,
2048 read_size, offset,
2049 &bytes_read, &smb_read_data,
2050 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07002051 /* BB more RC checks ? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002052 if (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002054 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002055 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002056 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002057 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 smb_read_data = NULL;
2059 }
2060 }
2061 }
2062 if ((rc < 0) || (smb_read_data == NULL)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002063 cFYI(1, "Read error in readpages: %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 break;
2065 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08002066 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2068 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2069 smb_read_data + 4 /* RFC1001 hdr */ +
Nick Piggin315e9952010-04-21 03:18:28 +00002070 le16_to_cpu(pSMBr->DataOffset));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071
2072 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha4544342005-08-24 13:59:35 -07002073 cifs_stats_bytes_read(pTcon, bytes_read);
Steve French2c2130e2007-10-12 19:10:28 +00002074 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075 i++; /* account for partial page */
2076
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002077 /* server copy of file can have smaller size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 than client */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002079 /* BB do we need to verify this common case ?
2080 this case is ok - if we are at server EOF
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 we will hit it on next read */
2082
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08002083 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 }
2085 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002086 cFYI(1, "No bytes read (%d) at offset %lld . "
Steve Frenchf19159d2010-04-21 04:12:10 +00002087 "Cleaning remaining pages from readahead list",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002088 bytes_read, offset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002089 /* BB turn off caching and do new lookup on
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 break;
2092 }
2093 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002094 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002095 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002096 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002097 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098 smb_read_data = NULL;
2099 }
2100 bytes_read = 0;
2101 }
2102
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103/* need to free smb_read_data buf before exit */
2104 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002105 if (buf_type == CIFS_SMALL_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002106 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002107 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002108 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 smb_read_data = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002110 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111
2112 FreeXid(xid);
2113 return rc;
2114}
2115
2116static int cifs_readpage_worker(struct file *file, struct page *page,
2117 loff_t *poffset)
2118{
2119 char *read_data;
2120 int rc;
2121
2122 page_cache_get(page);
2123 read_data = kmap(page);
2124 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002125
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002127
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 if (rc < 0)
2129 goto io_error;
2130 else
Joe Perchesb6b38f72010-04-21 03:50:45 +00002131 cFYI(1, "Bytes read %d", rc);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002132
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002133 file->f_path.dentry->d_inode->i_atime =
2134 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002135
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 if (PAGE_CACHE_SIZE > rc)
2137 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2138
2139 flush_dcache_page(page);
2140 SetPageUptodate(page);
2141 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002142
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002144 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 page_cache_release(page);
2146 return rc;
2147}
2148
2149static int cifs_readpage(struct file *file, struct page *page)
2150{
2151 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2152 int rc = -EACCES;
2153 int xid;
2154
2155 xid = GetXid();
2156
2157 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302158 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302160 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161 }
2162
Joe Perchesb6b38f72010-04-21 03:50:45 +00002163 cFYI(1, "readpage %p at offset %d 0x%x\n",
2164 page, (int)offset, (int)offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002165
2166 rc = cifs_readpage_worker(file, page, &offset);
2167
2168 unlock_page(page);
2169
2170 FreeXid(xid);
2171 return rc;
2172}
2173
Steve Frencha403a0a2007-07-26 15:54:16 +00002174static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2175{
2176 struct cifsFileInfo *open_file;
2177
2178 read_lock(&GlobalSMBSeslock);
2179 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2180 if (open_file->closePend)
2181 continue;
2182 if (open_file->pfile &&
2183 ((open_file->pfile->f_flags & O_RDWR) ||
2184 (open_file->pfile->f_flags & O_WRONLY))) {
2185 read_unlock(&GlobalSMBSeslock);
2186 return 1;
2187 }
2188 }
2189 read_unlock(&GlobalSMBSeslock);
2190 return 0;
2191}
2192
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193/* We do not want to update the file size from server for inodes
2194 open for write - to avoid races with writepage extending
2195 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002196 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 but this is tricky to do without racing with writebehind
2198 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00002199bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200{
Steve Frencha403a0a2007-07-26 15:54:16 +00002201 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00002202 return true;
Steve French23e7dd72005-10-20 13:44:56 -07002203
Steve Frencha403a0a2007-07-26 15:54:16 +00002204 if (is_inode_writable(cifsInode)) {
2205 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08002206 struct cifs_sb_info *cifs_sb;
2207
Steve Frenchc32a0b62006-01-12 14:41:28 -08002208 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00002209 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002210 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08002211 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00002212 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08002213 }
2214
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002215 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00002216 return true;
Steve French7ba52632007-02-08 18:14:13 +00002217
Steve French4b18f2a2008-04-29 00:06:05 +00002218 return false;
Steve French23e7dd72005-10-20 13:44:56 -07002219 } else
Steve French4b18f2a2008-04-29 00:06:05 +00002220 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221}
2222
Nick Piggind9414772008-09-24 11:32:59 -04002223static int cifs_write_begin(struct file *file, struct address_space *mapping,
2224 loff_t pos, unsigned len, unsigned flags,
2225 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226{
Nick Piggind9414772008-09-24 11:32:59 -04002227 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2228 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002229 loff_t page_start = pos & PAGE_MASK;
2230 loff_t i_size;
2231 struct page *page;
2232 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233
Joe Perchesb6b38f72010-04-21 03:50:45 +00002234 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
Nick Piggind9414772008-09-24 11:32:59 -04002235
Nick Piggin54566b22009-01-04 12:00:53 -08002236 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002237 if (!page) {
2238 rc = -ENOMEM;
2239 goto out;
2240 }
Nick Piggind9414772008-09-24 11:32:59 -04002241
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002242 if (PageUptodate(page))
2243 goto out;
Steve French8a236262007-03-06 00:31:00 +00002244
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002245 /*
2246 * If we write a full page it will be up to date, no need to read from
2247 * the server. If the write is short, we'll end up doing a sync write
2248 * instead.
2249 */
2250 if (len == PAGE_CACHE_SIZE)
2251 goto out;
2252
2253 /*
2254 * optimize away the read when we have an oplock, and we're not
2255 * expecting to use any of the data we'd be reading in. That
2256 * is, when the page lies beyond the EOF, or straddles the EOF
2257 * and the write will cover all of the existing data.
2258 */
2259 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2260 i_size = i_size_read(mapping->host);
2261 if (page_start >= i_size ||
2262 (offset == 0 && (pos + len) >= i_size)) {
2263 zero_user_segments(page, 0, offset,
2264 offset + len,
2265 PAGE_CACHE_SIZE);
2266 /*
2267 * PageChecked means that the parts of the page
2268 * to which we're not writing are considered up
2269 * to date. Once the data is copied to the
2270 * page, it can be set uptodate.
2271 */
2272 SetPageChecked(page);
2273 goto out;
2274 }
2275 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276
Nick Piggind9414772008-09-24 11:32:59 -04002277 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002278 /*
2279 * might as well read a page, it is fast enough. If we get
2280 * an error, we don't need to return it. cifs_write_end will
2281 * do a sync write instead since PG_uptodate isn't set.
2282 */
2283 cifs_readpage_worker(file, page, &page_start);
Steve French8a236262007-03-06 00:31:00 +00002284 } else {
2285 /* we could try using another file handle if there is one -
2286 but how would we lock it to prevent close of that handle
2287 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04002288 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00002289 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002290out:
2291 *pagep = page;
2292 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293}
2294
Jeff Layton3bc303c2009-09-21 06:47:50 -04002295static void
2296cifs_oplock_break(struct slow_work *work)
2297{
2298 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2299 oplock_break);
2300 struct inode *inode = cfile->pInode;
2301 struct cifsInodeInfo *cinode = CIFS_I(inode);
2302 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->mnt->mnt_sb);
2303 int rc, waitrc = 0;
2304
2305 if (inode && S_ISREG(inode->i_mode)) {
2306#ifdef CONFIG_CIFS_EXPERIMENTAL
2307 if (cinode->clientCanCacheAll == 0)
Al Viro8737c932009-12-24 06:47:55 -05002308 break_lease(inode, O_RDONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002309 else if (cinode->clientCanCacheRead == 0)
Al Viro8737c932009-12-24 06:47:55 -05002310 break_lease(inode, O_WRONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002311#endif
2312 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};