blob: 3d8f8a96f5a350a96e732cc65f45bc843ab6f08e [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 *
6 * Copyright (C) International Business Machines Corp., 2002,2007
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <asm/div64.h>
35#include "cifsfs.h"
36#include "cifspdu.h"
37#include "cifsglob.h"
38#include "cifsproto.h"
39#include "cifs_unicode.h"
40#include "cifs_debug.h"
41#include "cifs_fs_sb.h"
42
Linus Torvalds1da177e2005-04-16 15:20:36 -070043static inline int cifs_convert_flags(unsigned int flags)
44{
45 if ((flags & O_ACCMODE) == O_RDONLY)
46 return GENERIC_READ;
47 else if ((flags & O_ACCMODE) == O_WRONLY)
48 return GENERIC_WRITE;
49 else if ((flags & O_ACCMODE) == O_RDWR) {
50 /* GENERIC_ALL is too much permission to request
51 can cause unnecessary access denied on create */
52 /* return GENERIC_ALL; */
53 return (GENERIC_READ | GENERIC_WRITE);
54 }
55
Jeff Laytone10f7b52008-05-14 10:21:33 -070056 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
57 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
58 FILE_READ_DATA);
Steve French7fc8f4e2009-02-23 20:43:11 +000059}
Jeff Laytone10f7b52008-05-14 10:21:33 -070060
Steve French7fc8f4e2009-02-23 20:43:11 +000061static inline fmode_t cifs_posix_convert_flags(unsigned int flags)
62{
63 fmode_t posix_flags = 0;
Jeff Laytone10f7b52008-05-14 10:21:33 -070064
Steve French7fc8f4e2009-02-23 20:43:11 +000065 if ((flags & O_ACCMODE) == O_RDONLY)
66 posix_flags = FMODE_READ;
67 else if ((flags & O_ACCMODE) == O_WRONLY)
68 posix_flags = FMODE_WRITE;
69 else if ((flags & O_ACCMODE) == O_RDWR) {
70 /* GENERIC_ALL is too much permission to request
71 can cause unnecessary access denied on create */
72 /* return GENERIC_ALL; */
73 posix_flags = FMODE_READ | FMODE_WRITE;
74 }
75 /* can not map O_CREAT or O_EXCL or O_TRUNC flags when
76 reopening a file. They had their effect on the original open */
77 if (flags & O_APPEND)
78 posix_flags |= (fmode_t)O_APPEND;
Christoph Hellwig6b2f3d12009-10-27 11:05:28 +010079 if (flags & O_DSYNC)
80 posix_flags |= (fmode_t)O_DSYNC;
81 if (flags & __O_SYNC)
82 posix_flags |= (fmode_t)__O_SYNC;
Steve French7fc8f4e2009-02-23 20:43:11 +000083 if (flags & O_DIRECTORY)
84 posix_flags |= (fmode_t)O_DIRECTORY;
85 if (flags & O_NOFOLLOW)
86 posix_flags |= (fmode_t)O_NOFOLLOW;
87 if (flags & O_DIRECT)
88 posix_flags |= (fmode_t)O_DIRECT;
89
90 return posix_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091}
92
93static inline int cifs_get_disposition(unsigned int flags)
94{
95 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
96 return FILE_CREATE;
97 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
98 return FILE_OVERWRITE_IF;
99 else if ((flags & O_CREAT) == O_CREAT)
100 return FILE_OPEN_IF;
Steve French55aa2e02006-05-30 18:09:31 +0000101 else if ((flags & O_TRUNC) == O_TRUNC)
102 return FILE_OVERWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 else
104 return FILE_OPEN;
105}
106
107/* all arguments to this function must be checked for validity in caller */
Jeff Layton590a3fe2009-09-12 11:54:28 -0400108static inline int
109cifs_posix_open_inode_helper(struct inode *inode, struct file *file,
110 struct cifsInodeInfo *pCifsInode,
111 struct cifsFileInfo *pCifsFile, __u32 oplock,
112 u16 netfid)
Steve French276a74a2009-03-03 18:00:34 +0000113{
Steve French276a74a2009-03-03 18:00:34 +0000114
Steve French276a74a2009-03-03 18:00:34 +0000115 write_lock(&GlobalSMBSeslock);
Steve French276a74a2009-03-03 18:00:34 +0000116
117 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
118 if (pCifsInode == NULL) {
119 write_unlock(&GlobalSMBSeslock);
120 return -EINVAL;
121 }
122
Steve French276a74a2009-03-03 18:00:34 +0000123 if (pCifsInode->clientCanCacheRead) {
124 /* we have the inode open somewhere else
125 no need to discard cache data */
126 goto psx_client_can_cache;
127 }
128
129 /* BB FIXME need to fix this check to move it earlier into posix_open
130 BB fIX following section BB FIXME */
131
132 /* if not oplocked, invalidate inode pages if mtime or file
133 size changed */
134/* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
135 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
136 (file->f_path.dentry->d_inode->i_size ==
137 (loff_t)le64_to_cpu(buf->EndOfFile))) {
138 cFYI(1, ("inode unchanged on server"));
139 } else {
140 if (file->f_path.dentry->d_inode->i_mapping) {
141 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
142 if (rc != 0)
143 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
144 }
145 cFYI(1, ("invalidating remote inode since open detected it "
146 "changed"));
147 invalidate_remote_inode(file->f_path.dentry->d_inode);
148 } */
149
150psx_client_can_cache:
151 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
152 pCifsInode->clientCanCacheAll = true;
153 pCifsInode->clientCanCacheRead = true;
154 cFYI(1, ("Exclusive Oplock granted on inode %p",
155 file->f_path.dentry->d_inode));
156 } else if ((oplock & 0xF) == OPLOCK_READ)
157 pCifsInode->clientCanCacheRead = true;
158
159 /* will have to change the unlock if we reenable the
160 filemap_fdatawrite (which does not seem necessary */
161 write_unlock(&GlobalSMBSeslock);
162 return 0;
163}
164
Steve French703a3b82009-05-21 22:21:53 +0000165static struct cifsFileInfo *
166cifs_fill_filedata(struct file *file)
167{
168 struct list_head *tmp;
169 struct cifsFileInfo *pCifsFile = NULL;
170 struct cifsInodeInfo *pCifsInode = NULL;
171
172 /* search inode for this file and fill in file->private_data */
173 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
174 read_lock(&GlobalSMBSeslock);
175 list_for_each(tmp, &pCifsInode->openFileList) {
176 pCifsFile = list_entry(tmp, struct cifsFileInfo, flist);
177 if ((pCifsFile->pfile == NULL) &&
178 (pCifsFile->pid == current->tgid)) {
179 /* mode set in cifs_create */
180
181 /* needed for writepage */
182 pCifsFile->pfile = file;
183 file->private_data = pCifsFile;
184 break;
185 }
186 }
187 read_unlock(&GlobalSMBSeslock);
188
189 if (file->private_data != NULL) {
190 return pCifsFile;
191 } else if ((file->f_flags & O_CREAT) && (file->f_flags & O_EXCL))
192 cERROR(1, ("could not find file instance for "
193 "new file %p", file));
194 return NULL;
195}
196
Steve French276a74a2009-03-03 18:00:34 +0000197/* all arguments to this function must be checked for validity in caller */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
199 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
200 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
201 char *full_path, int xid)
202{
203 struct timespec temp;
204 int rc;
205
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 if (pCifsInode->clientCanCacheRead) {
207 /* we have the inode open somewhere else
208 no need to discard cache data */
209 goto client_can_cache;
210 }
211
212 /* BB need same check in cifs_create too? */
213 /* if not oplocked, invalidate inode pages if mtime or file
214 size changed */
Jeff Layton07119a42009-05-27 09:37:33 -0400215 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800216 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
217 (file->f_path.dentry->d_inode->i_size ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 (loff_t)le64_to_cpu(buf->EndOfFile))) {
219 cFYI(1, ("inode unchanged on server"));
220 } else {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800221 if (file->f_path.dentry->d_inode->i_mapping) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 /* BB no need to lock inode until after invalidate
223 since namei code should already have it locked? */
Jeff Laytoncea21802007-11-20 23:19:03 +0000224 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
225 if (rc != 0)
226 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 }
228 cFYI(1, ("invalidating remote inode since open detected it "
229 "changed"));
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800230 invalidate_remote_inode(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 }
232
233client_can_cache:
Steve Frenchc18c8422007-07-18 23:21:09 +0000234 if (pTcon->unix_ext)
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800235 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 full_path, inode->i_sb, xid);
237 else
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800238 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
Steve French8b1327f2008-03-14 22:37:16 +0000239 full_path, buf, inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240
241 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000242 pCifsInode->clientCanCacheAll = true;
243 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800245 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 } else if ((*oplock & 0xF) == OPLOCK_READ)
Steve French4b18f2a2008-04-29 00:06:05 +0000247 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
249 return rc;
250}
251
252int cifs_open(struct inode *inode, struct file *file)
253{
254 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400255 int xid;
256 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 struct cifs_sb_info *cifs_sb;
Steve French276a74a2009-03-03 18:00:34 +0000258 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 struct cifsFileInfo *pCifsFile;
260 struct cifsInodeInfo *pCifsInode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 char *full_path = NULL;
262 int desiredAccess;
263 int disposition;
264 __u16 netfid;
265 FILE_ALL_INFO *buf = NULL;
266
267 xid = GetXid();
268
269 cifs_sb = CIFS_SB(inode->i_sb);
Steve French276a74a2009-03-03 18:00:34 +0000270 tcon = cifs_sb->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
Steve Frencha6ce4932009-04-09 01:14:32 +0000272 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Steve French703a3b82009-05-21 22:21:53 +0000273 pCifsFile = cifs_fill_filedata(file);
274 if (pCifsFile) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530275 rc = 0;
Steve Frencha6ce4932009-04-09 01:14:32 +0000276 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530277 return rc;
Steve French703a3b82009-05-21 22:21:53 +0000278 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800280 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530282 rc = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530284 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 }
286
Steve French7521a3c2007-07-11 18:30:34 +0000287 cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 inode, file->f_flags, full_path));
Steve French276a74a2009-03-03 18:00:34 +0000289
290 if (oplockEnabled)
291 oplock = REQ_OPLOCK;
292 else
293 oplock = 0;
294
Steve French64cc2c62009-03-04 19:54:08 +0000295 if (!tcon->broken_posix_open && tcon->unix_ext &&
296 (tcon->ses->capabilities & CAP_UNIX) &&
Steve French276a74a2009-03-03 18:00:34 +0000297 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
298 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
299 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
300 /* can not refresh inode info since size could be stale */
Jeff Layton3bc303c2009-09-21 06:47:50 -0400301 rc = cifs_posix_open(full_path, &inode, file->f_path.mnt,
Steve French276a74a2009-03-03 18:00:34 +0000302 cifs_sb->mnt_file_mode /* ignored */,
303 oflags, &oplock, &netfid, xid);
304 if (rc == 0) {
305 cFYI(1, ("posix open succeeded"));
306 /* no need for special case handling of setting mode
307 on read only files needed here */
308
Steve French703a3b82009-05-21 22:21:53 +0000309 pCifsFile = cifs_fill_filedata(file);
Steve French276a74a2009-03-03 18:00:34 +0000310 cifs_posix_open_inode_helper(inode, file, pCifsInode,
311 pCifsFile, oplock, netfid);
312 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000313 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
314 if (tcon->ses->serverNOS)
315 cERROR(1, ("server %s of type %s returned"
316 " unexpected error on SMB posix open"
317 ", disabling posix open support."
318 " Check if server update available.",
319 tcon->ses->serverName,
320 tcon->ses->serverNOS));
321 tcon->broken_posix_open = true;
Steve French276a74a2009-03-03 18:00:34 +0000322 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
323 (rc != -EOPNOTSUPP)) /* path not found or net err */
324 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000325 /* else fallthrough to retry open the old way on network i/o
326 or DFS errors */
Steve French276a74a2009-03-03 18:00:34 +0000327 }
328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 desiredAccess = cifs_convert_flags(file->f_flags);
330
331/*********************************************************************
332 * open flag mapping table:
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000333 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 * POSIX Flag CIFS Disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000335 * ---------- ----------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 * O_CREAT FILE_OPEN_IF
337 * O_CREAT | O_EXCL FILE_CREATE
338 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
339 * O_TRUNC FILE_OVERWRITE
340 * none of the above FILE_OPEN
341 *
342 * Note that there is not a direct match between disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000343 * FILE_SUPERSEDE (ie create whether or not file exists although
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 * O_CREAT | O_TRUNC is similar but truncates the existing
345 * file rather than creating a new file as FILE_SUPERSEDE does
346 * (which uses the attributes / metadata passed in on open call)
347 *?
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000348 *? O_SYNC is a reasonable match to CIFS writethrough flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 *? and the read write flags match reasonably. O_LARGEFILE
350 *? is irrelevant because largefile support is always used
351 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
352 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
353 *********************************************************************/
354
355 disposition = cifs_get_disposition(file->f_flags);
356
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 /* BB pass O_SYNC flag through on file attributes .. BB */
358
359 /* Also refresh inode by passing in file_info buf returned by SMBOpen
360 and calling get_inode_info with returned buf (at least helps
361 non-Unix server case) */
362
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000363 /* BB we can not do this if this is the second open of a file
364 and the first handle has writebehind data, we might be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
366 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
367 if (!buf) {
368 rc = -ENOMEM;
369 goto out;
370 }
Steve French5bafd762006-06-07 00:18:43 +0000371
372 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
Steve French276a74a2009-03-03 18:00:34 +0000373 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
Steve French5bafd762006-06-07 00:18:43 +0000374 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
Steve French737b7582005-04-28 22:41:06 -0700375 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
376 & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000377 else
378 rc = -EIO; /* no NT SMB support fall into legacy open below */
379
Steve Frencha9d02ad2005-08-24 23:06:05 -0700380 if (rc == -EIO) {
381 /* Old server, try legacy style OpenX */
Steve French276a74a2009-03-03 18:00:34 +0000382 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
Steve Frencha9d02ad2005-08-24 23:06:05 -0700383 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
384 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
385 & CIFS_MOUNT_MAP_SPECIAL_CHR);
386 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 if (rc) {
Steve French26a21b92006-05-31 18:05:34 +0000388 cFYI(1, ("cifs_open returned 0x%x", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 goto out;
390 }
Jeff Layton3321b792009-09-25 09:53:37 -0400391
Jeff Layton086f68b2009-09-21 14:08:18 -0400392 pCifsFile = cifs_new_fileinfo(inode, netfid, file, file->f_path.mnt,
393 file->f_flags);
394 file->private_data = pCifsFile;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 if (file->private_data == NULL) {
396 rc = -ENOMEM;
397 goto out;
398 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
Jeff Layton3321b792009-09-25 09:53:37 -0400400 rc = cifs_open_inode_helper(inode, file, pCifsInode, pCifsFile, tcon,
401 &oplock, buf, full_path, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000403 if (oplock & CIFS_CREATE_ACTION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 /* time to set mode which we can not set earlier due to
405 problems creating new read-only files */
Steve French276a74a2009-03-03 18:00:34 +0000406 if (tcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400407 struct cifs_unix_set_info_args args = {
408 .mode = inode->i_mode,
409 .uid = NO_CHANGE_64,
410 .gid = NO_CHANGE_64,
411 .ctime = NO_CHANGE_64,
412 .atime = NO_CHANGE_64,
413 .mtime = NO_CHANGE_64,
414 .device = 0,
415 };
Jeff Layton01ea95e2009-07-09 20:02:49 -0400416 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
417 cifs_sb->local_nls,
418 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700419 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 }
421 }
422
423out:
424 kfree(buf);
425 kfree(full_path);
426 FreeXid(xid);
427 return rc;
428}
429
Adrian Bunk04187262006-06-30 18:23:04 +0200430/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431/* to server was lost */
432static int cifs_relock_file(struct cifsFileInfo *cifsFile)
433{
434 int rc = 0;
435
436/* BB list all locks open on this file and relock */
437
438 return rc;
439}
440
Steve French4b18f2a2008-04-29 00:06:05 +0000441static int cifs_reopen_file(struct file *file, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442{
443 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400444 int xid;
445 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 struct cifs_sb_info *cifs_sb;
Steve French7fc8f4e2009-02-23 20:43:11 +0000447 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 struct cifsFileInfo *pCifsFile;
449 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000450 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 char *full_path = NULL;
452 int desiredAccess;
453 int disposition = FILE_OPEN;
454 __u16 netfid;
455
Steve Frenchad7a2922008-02-07 23:25:02 +0000456 if (file->private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 pCifsFile = (struct cifsFileInfo *)file->private_data;
Steve Frenchad7a2922008-02-07 23:25:02 +0000458 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 return -EBADF;
460
461 xid = GetXid();
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400462 mutex_lock(&pCifsFile->fh_mutex);
Steve French4b18f2a2008-04-29 00:06:05 +0000463 if (!pCifsFile->invalidHandle) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400464 mutex_unlock(&pCifsFile->fh_mutex);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530465 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530467 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 }
469
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800470 if (file->f_path.dentry == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000471 cERROR(1, ("no valid name if dentry freed"));
472 dump_stack();
473 rc = -EBADF;
474 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 }
Steve French3a9f4622007-04-04 17:10:24 +0000476
477 inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000478 if (inode == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000479 cERROR(1, ("inode not valid"));
480 dump_stack();
481 rc = -EBADF;
482 goto reopen_error_exit;
483 }
Steve French50c2f752007-07-13 00:33:32 +0000484
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 cifs_sb = CIFS_SB(inode->i_sb);
Steve French7fc8f4e2009-02-23 20:43:11 +0000486 tcon = cifs_sb->tcon;
Steve French3a9f4622007-04-04 17:10:24 +0000487
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488/* can not grab rename sem here because various ops, including
489 those that already have the rename sem can end up causing writepage
490 to get called and if the server was down that means we end up here,
491 and we can never tell if the caller already has the rename_sem */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800492 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000494 rc = -ENOMEM;
495reopen_error_exit:
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400496 mutex_unlock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000498 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 }
500
Steve French3a9f4622007-04-04 17:10:24 +0000501 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000502 inode, file->f_flags, full_path));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
504 if (oplockEnabled)
505 oplock = REQ_OPLOCK;
506 else
Steve French4b18f2a2008-04-29 00:06:05 +0000507 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Steve French7fc8f4e2009-02-23 20:43:11 +0000509 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
510 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
511 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
512 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
513 /* can not refresh inode info since size could be stale */
Jeff Layton3bc303c2009-09-21 06:47:50 -0400514 rc = cifs_posix_open(full_path, NULL, file->f_path.mnt,
Steve French7fc8f4e2009-02-23 20:43:11 +0000515 cifs_sb->mnt_file_mode /* ignored */,
516 oflags, &oplock, &netfid, xid);
517 if (rc == 0) {
518 cFYI(1, ("posix reopen succeeded"));
519 goto reopen_success;
520 }
521 /* fallthrough to retry open the old way on errors, especially
522 in the reconnect path it is important to retry hard */
523 }
524
525 desiredAccess = cifs_convert_flags(file->f_flags);
526
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000528 by SMBOpen and then calling get_inode_info with returned buf
529 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 and server version of file size can be stale. If we knew for sure
531 that inode was not dirty locally we could do this */
532
Steve French7fc8f4e2009-02-23 20:43:11 +0000533 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 CREATE_NOT_DIR, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000535 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700536 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 if (rc) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400538 mutex_unlock(&pCifsFile->fh_mutex);
Steve French26a21b92006-05-31 18:05:34 +0000539 cFYI(1, ("cifs_open returned 0x%x", rc));
540 cFYI(1, ("oplock: %d", oplock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 } else {
Steve French7fc8f4e2009-02-23 20:43:11 +0000542reopen_success:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 pCifsFile->netfid = netfid;
Steve French4b18f2a2008-04-29 00:06:05 +0000544 pCifsFile->invalidHandle = false;
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400545 mutex_unlock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 pCifsInode = CIFS_I(inode);
547 if (pCifsInode) {
548 if (can_flush) {
Jeff Laytoncea21802007-11-20 23:19:03 +0000549 rc = filemap_write_and_wait(inode->i_mapping);
550 if (rc != 0)
551 CIFS_I(inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 /* temporarily disable caching while we
553 go to server to get inode info */
Steve French4b18f2a2008-04-29 00:06:05 +0000554 pCifsInode->clientCanCacheAll = false;
555 pCifsInode->clientCanCacheRead = false;
Steve French7fc8f4e2009-02-23 20:43:11 +0000556 if (tcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 rc = cifs_get_inode_info_unix(&inode,
558 full_path, inode->i_sb, xid);
559 else
560 rc = cifs_get_inode_info(&inode,
561 full_path, NULL, inode->i_sb,
Steve French8b1327f2008-03-14 22:37:16 +0000562 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 } /* else we are writing out data to server already
564 and could deadlock if we tried to flush data, and
565 since we do not know if we have data that would
566 invalidate the current end of file on the server
567 we can not go to the server to get the new inod
568 info */
569 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000570 pCifsInode->clientCanCacheAll = true;
571 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800573 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 } else if ((oplock & 0xF) == OPLOCK_READ) {
Steve French4b18f2a2008-04-29 00:06:05 +0000575 pCifsInode->clientCanCacheRead = true;
576 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 } else {
Steve French4b18f2a2008-04-29 00:06:05 +0000578 pCifsInode->clientCanCacheRead = false;
579 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 }
581 cifs_relock_file(pCifsFile);
582 }
583 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 kfree(full_path);
585 FreeXid(xid);
586 return rc;
587}
588
589int cifs_close(struct inode *inode, struct file *file)
590{
591 int rc = 0;
Steve French15745322007-09-07 22:23:48 +0000592 int xid, timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 struct cifs_sb_info *cifs_sb;
594 struct cifsTconInfo *pTcon;
595 struct cifsFileInfo *pSMBFile =
596 (struct cifsFileInfo *)file->private_data;
597
598 xid = GetXid();
599
600 cifs_sb = CIFS_SB(inode->i_sb);
601 pTcon = cifs_sb->tcon;
602 if (pSMBFile) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000603 struct cifsLockInfo *li, *tmp;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000604 write_lock(&GlobalSMBSeslock);
Steve French4b18f2a2008-04-29 00:06:05 +0000605 pSMBFile->closePend = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 if (pTcon) {
607 /* no sense reconnecting to close a file that is
608 already closed */
Steve French3b795212008-11-13 19:45:32 +0000609 if (!pTcon->need_reconnect) {
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000610 write_unlock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +0000611 timeout = 2;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400612 while ((atomic_read(&pSMBFile->count) != 1)
Steve French15745322007-09-07 22:23:48 +0000613 && (timeout <= 2048)) {
Steve French23e7dd72005-10-20 13:44:56 -0700614 /* Give write a better chance to get to
615 server ahead of the close. We do not
616 want to add a wait_q here as it would
617 increase the memory utilization as
618 the struct would be in each open file,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000619 but this should give enough time to
Steve French23e7dd72005-10-20 13:44:56 -0700620 clear the socket */
Steve French90c81e02008-02-12 20:32:36 +0000621 cFYI(DBG2,
622 ("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))) {
655 cFYI(1, ("closing last open instance for inode %p", inode));
656 /* 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
Steve French26a21b92006-05-31 18:05:34 +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
687 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);
694 cFYI(1, ("Closing uncompleted readdir with rc %d",
695 rc));
696 /* 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) {
Steve Frenchec637e32005-12-12 20:53:18 -0800702 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
750 cFYI(1, ("Lock parm: 0x%x flockflags: "
751 "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,
753 pfLock->fl_end));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
755 if (pfLock->fl_flags & FL_POSIX)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000756 cFYI(1, ("Posix"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 if (pfLock->fl_flags & FL_FLOCK)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000758 cFYI(1, ("Flock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 if (pfLock->fl_flags & FL_SLEEP) {
Steve Frenchd47d7c12006-02-28 03:45:48 +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)
764 cFYI(1, ("Process suspended by mandatory locking - "
Steve French26a21b92006-05-31 18:05:34 +0000765 "not implemented yet"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766 if (pfLock->fl_flags & FL_LEASE)
767 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)))
770 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
771
772 if (pfLock->fl_type == F_WRLCK) {
773 cFYI(1, ("F_WRLCK "));
774 numLock = 1;
775 } else if (pfLock->fl_type == F_UNLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +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) {
Steve Frenchd47d7c12006-02-28 03:45:48 +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) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000785 cFYI(1, ("F_EXLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 numLock = 1;
787 } else if (pfLock->fl_type == F_SHLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000788 cFYI(1, ("F_SHLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 lockType |= LOCKING_ANDX_SHARED_LOCK;
790 numLock = 1;
791 } else
Steve Frenchd47d7c12006-02-28 03:45:48 +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)
835 cERROR(1, ("Error unlocking previously locked "
Steve French08547b02006-02-28 22:39:25 +0000836 "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 ? */
841 rc = 0; /* do not change lock type to unlock
842 since range in use */
843 }
844
845 FreeXid(xid);
846 return rc;
847 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000848
849 if (!numLock && !numUnlock) {
850 /* if no lock or unlock then nothing
851 to do since we do not know what it is */
852 FreeXid(xid);
853 return -EOPNOTSUPP;
854 }
855
856 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000857 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000858 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000859 posix_lock_type = CIFS_RDLCK;
860 else
861 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +0000862
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000863 if (numUnlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +0000864 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000865
Steve French13a6e422008-12-02 17:24:33 +0000866 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000867 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000868 posix_lock_type, wait_flag);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000869 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000870 struct cifsFileInfo *fid =
871 (struct cifsFileInfo *)file->private_data;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000872
873 if (numLock) {
Steve French13a6e422008-12-02 17:24:33 +0000874 rc = CIFSSMBLock(xid, tcon, netfid, length,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000875 pfLock->fl_start,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000876 0, numLock, lockType, wait_flag);
877
878 if (rc == 0) {
879 /* For Windows locks we must store them. */
880 rc = store_file_lock(fid, length,
881 pfLock->fl_start, lockType);
882 }
883 } else if (numUnlock) {
884 /* For each stored lock that this unlock overlaps
885 completely, unlock it. */
886 int stored_rc = 0;
887 struct cifsLockInfo *li, *tmp;
888
Steve French6b70c952006-09-21 07:35:29 +0000889 rc = 0;
Roland Dreier796e5662007-05-03 04:33:45 +0000890 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000891 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
892 if (pfLock->fl_start <= li->offset &&
Steve Frenchc19eb712007-08-24 03:22:48 +0000893 (pfLock->fl_start + length) >=
Jeff Layton39db8102007-08-24 03:16:51 +0000894 (li->offset + li->length)) {
Steve French13a6e422008-12-02 17:24:33 +0000895 stored_rc = CIFSSMBLock(xid, tcon,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000896 netfid,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000897 li->length, li->offset,
Steve French4b18f2a2008-04-29 00:06:05 +0000898 1, 0, li->type, false);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000899 if (stored_rc)
900 rc = stored_rc;
901
902 list_del(&li->llist);
903 kfree(li);
904 }
905 }
Roland Dreier796e5662007-05-03 04:33:45 +0000906 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000907 }
908 }
909
Steve Frenchd634cc12005-08-26 14:42:59 -0500910 if (pfLock->fl_flags & FL_POSIX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 posix_lock_file_wait(file, pfLock);
912 FreeXid(xid);
913 return rc;
914}
915
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400916/*
917 * Set the timeout on write requests past EOF. For some servers (Windows)
918 * these calls can be very long.
919 *
920 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
921 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
922 * The 10M cutoff is totally arbitrary. A better scheme for this would be
923 * welcome if someone wants to suggest one.
924 *
925 * We may be able to do a better job with this if there were some way to
926 * declare that a file should be sparse.
927 */
928static int
929cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
930{
931 if (offset <= cifsi->server_eof)
932 return CIFS_STD_OP;
933 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
934 return CIFS_VLONG_OP;
935 else
936 return CIFS_LONG_OP;
937}
938
939/* update the file size (if needed) after a write */
940static void
941cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
942 unsigned int bytes_written)
943{
944 loff_t end_of_write = offset + bytes_written;
945
946 if (end_of_write > cifsi->server_eof)
947 cifsi->server_eof = end_of_write;
948}
949
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950ssize_t cifs_user_write(struct file *file, const char __user *write_data,
951 size_t write_size, loff_t *poffset)
952{
953 int rc = 0;
954 unsigned int bytes_written = 0;
955 unsigned int total_written;
956 struct cifs_sb_info *cifs_sb;
957 struct cifsTconInfo *pTcon;
958 int xid, long_op;
959 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400960 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800962 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
964 pTcon = cifs_sb->tcon;
965
966 /* cFYI(1,
967 (" write %d bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800968 *poffset, file->f_path.dentry->d_name.name)); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969
970 if (file->private_data == NULL)
971 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000972 open_file = (struct cifsFileInfo *) file->private_data;
Steve French50c2f752007-07-13 00:33:32 +0000973
Jeff Layton838726c2008-08-28 07:54:59 -0400974 rc = generic_write_checks(file, poffset, &write_size, 0);
975 if (rc)
976 return rc;
977
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400980 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 for (total_written = 0; write_size > total_written;
982 total_written += bytes_written) {
983 rc = -EAGAIN;
984 while (rc == -EAGAIN) {
985 if (file->private_data == NULL) {
986 /* file has been closed on us */
987 FreeXid(xid);
988 /* if we have gotten here we have written some data
989 and blocked, and the file has been freed on us while
990 we blocked so return what we managed to write */
991 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000992 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 if (open_file->closePend) {
994 FreeXid(xid);
995 if (total_written)
996 return total_written;
997 else
998 return -EBADF;
999 }
1000 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 /* we could deadlock if we called
1002 filemap_fdatawait from here so tell
1003 reopen_file not to flush data to server
1004 now */
Steve French4b18f2a2008-04-29 00:06:05 +00001005 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 if (rc != 0)
1007 break;
1008 }
1009
1010 rc = CIFSSMBWrite(xid, pTcon,
1011 open_file->netfid,
1012 min_t(const int, cifs_sb->wsize,
1013 write_size - total_written),
1014 *poffset, &bytes_written,
1015 NULL, write_data + total_written, long_op);
1016 }
1017 if (rc || (bytes_written == 0)) {
1018 if (total_written)
1019 break;
1020 else {
1021 FreeXid(xid);
1022 return rc;
1023 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001024 } else {
1025 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001027 }
Steve French133672e2007-11-13 22:41:37 +00001028 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 15 seconds is plenty */
1030 }
1031
Steve Frencha45443472005-08-24 13:59:35 -07001032 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033
1034 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001035 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1036 struct inode *inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001037/* Do not update local mtime - server will set its actual value on write
1038 * inode->i_ctime = inode->i_mtime =
Steve French3677db12007-02-26 16:46:11 +00001039 * current_fs_time(inode->i_sb);*/
1040 if (total_written > 0) {
1041 spin_lock(&inode->i_lock);
1042 if (*poffset > file->f_path.dentry->d_inode->i_size)
1043 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 *poffset);
Steve French3677db12007-02-26 16:46:11 +00001045 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001047 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 }
1049 FreeXid(xid);
1050 return total_written;
1051}
1052
1053static ssize_t cifs_write(struct file *file, const char *write_data,
Nick Piggind9414772008-09-24 11:32:59 -04001054 size_t write_size, loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055{
1056 int rc = 0;
1057 unsigned int bytes_written = 0;
1058 unsigned int total_written;
1059 struct cifs_sb_info *cifs_sb;
1060 struct cifsTconInfo *pTcon;
1061 int xid, long_op;
1062 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001063 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001065 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066
1067 pTcon = cifs_sb->tcon;
1068
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001069 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001070 *poffset, file->f_path.dentry->d_name.name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071
1072 if (file->private_data == NULL)
1073 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +00001074 open_file = (struct cifsFileInfo *)file->private_data;
Steve French50c2f752007-07-13 00:33:32 +00001075
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001078 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 for (total_written = 0; write_size > total_written;
1080 total_written += bytes_written) {
1081 rc = -EAGAIN;
1082 while (rc == -EAGAIN) {
1083 if (file->private_data == NULL) {
1084 /* file has been closed on us */
1085 FreeXid(xid);
1086 /* if we have gotten here we have written some data
1087 and blocked, and the file has been freed on us
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001088 while we blocked so return what we managed to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 write */
1090 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001091 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 if (open_file->closePend) {
1093 FreeXid(xid);
1094 if (total_written)
1095 return total_written;
1096 else
1097 return -EBADF;
1098 }
1099 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 /* we could deadlock if we called
1101 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001102 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103 server now */
Steve French4b18f2a2008-04-29 00:06:05 +00001104 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 if (rc != 0)
1106 break;
1107 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001108 if (experimEnabled || (pTcon->ses->server &&
1109 ((pTcon->ses->server->secMode &
Steve French08775832006-05-30 18:08:26 +00001110 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +00001111 == 0))) {
Steve French3e844692005-10-03 13:37:24 -07001112 struct kvec iov[2];
1113 unsigned int len;
1114
Steve French0ae0efa2005-10-10 10:57:19 -07001115 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -07001116 write_size - total_written);
1117 /* iov[0] is reserved for smb header */
1118 iov[1].iov_base = (char *)write_data +
1119 total_written;
1120 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001121 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -07001122 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001123 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -07001124 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001125 } else
Steve French60808232006-04-22 15:53:05 +00001126 rc = CIFSSMBWrite(xid, pTcon,
1127 open_file->netfid,
1128 min_t(const int, cifs_sb->wsize,
1129 write_size - total_written),
1130 *poffset, &bytes_written,
1131 write_data + total_written,
1132 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 }
1134 if (rc || (bytes_written == 0)) {
1135 if (total_written)
1136 break;
1137 else {
1138 FreeXid(xid);
1139 return rc;
1140 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001141 } else {
1142 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001144 }
Steve French133672e2007-11-13 22:41:37 +00001145 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 15 seconds is plenty */
1147 }
1148
Steve Frencha45443472005-08-24 13:59:35 -07001149 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
1151 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001152 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
Steve French004c46b2007-02-17 04:34:13 +00001153/*BB We could make this contingent on superblock ATIME flag too */
Steve French3677db12007-02-26 16:46:11 +00001154/* file->f_path.dentry->d_inode->i_ctime =
1155 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1156 if (total_written > 0) {
1157 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1158 if (*poffset > file->f_path.dentry->d_inode->i_size)
1159 i_size_write(file->f_path.dentry->d_inode,
1160 *poffset);
1161 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 }
Steve French3677db12007-02-26 16:46:11 +00001163 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 }
1165 FreeXid(xid);
1166 return total_written;
1167}
1168
Steve French630f3f0c2007-10-25 21:17:17 +00001169#ifdef CONFIG_CIFS_EXPERIMENTAL
1170struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1171{
1172 struct cifsFileInfo *open_file = NULL;
1173
1174 read_lock(&GlobalSMBSeslock);
1175 /* we could simply get the first_list_entry since write-only entries
1176 are always at the end of the list but since the first entry might
1177 have a close pending, we go through the whole list */
1178 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1179 if (open_file->closePend)
1180 continue;
1181 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1182 (open_file->pfile->f_flags & O_RDONLY))) {
1183 if (!open_file->invalidHandle) {
1184 /* found a good file */
1185 /* lock it so it will not be closed on us */
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001186 cifsFileInfo_get(open_file);
Steve French630f3f0c2007-10-25 21:17:17 +00001187 read_unlock(&GlobalSMBSeslock);
1188 return open_file;
1189 } /* else might as well continue, and look for
1190 another, or simply have the caller reopen it
1191 again rather than trying to fix this handle */
1192 } else /* write only file */
1193 break; /* write only files are last so must be done */
1194 }
1195 read_unlock(&GlobalSMBSeslock);
1196 return NULL;
1197}
1198#endif
1199
Steve Frenchdd99cd82005-10-05 19:32:49 -07001200struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
Steve French6148a742005-10-05 12:23:19 -07001201{
1202 struct cifsFileInfo *open_file;
Jeff Layton2846d382008-09-22 21:33:33 -04001203 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001204 int rc;
Steve French6148a742005-10-05 12:23:19 -07001205
Steve French60808232006-04-22 15:53:05 +00001206 /* Having a null inode here (because mapping->host was set to zero by
1207 the VFS or MM) should not happen but we had reports of on oops (due to
1208 it being zero) during stress testcases so we need to check for it */
1209
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001210 if (cifs_inode == NULL) {
1211 cERROR(1, ("Null inode passed to cifs_writeable_file"));
Steve French60808232006-04-22 15:53:05 +00001212 dump_stack();
1213 return NULL;
1214 }
1215
Steve French6148a742005-10-05 12:23:19 -07001216 read_lock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001217refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001218 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2846d382008-09-22 21:33:33 -04001219 if (open_file->closePend ||
1220 (!any_available && open_file->pid != current->tgid))
Steve French6148a742005-10-05 12:23:19 -07001221 continue;
Jeff Layton2846d382008-09-22 21:33:33 -04001222
Steve French6148a742005-10-05 12:23:19 -07001223 if (open_file->pfile &&
1224 ((open_file->pfile->f_flags & O_RDWR) ||
1225 (open_file->pfile->f_flags & O_WRONLY))) {
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001226 cifsFileInfo_get(open_file);
Steve French9b22b0b2007-10-02 01:11:08 +00001227
1228 if (!open_file->invalidHandle) {
1229 /* found a good writable file */
1230 read_unlock(&GlobalSMBSeslock);
1231 return open_file;
1232 }
Steve French8840dee2007-11-16 23:05:52 +00001233
Steve French6148a742005-10-05 12:23:19 -07001234 read_unlock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001235 /* Had to unlock since following call can block */
Steve French4b18f2a2008-04-29 00:06:05 +00001236 rc = cifs_reopen_file(open_file->pfile, false);
Steve French8840dee2007-11-16 23:05:52 +00001237 if (!rc) {
Steve French9b22b0b2007-10-02 01:11:08 +00001238 if (!open_file->closePend)
1239 return open_file;
1240 else { /* start over in case this was deleted */
1241 /* since the list could be modified */
Steve French37c0eb42005-10-05 14:50:29 -07001242 read_lock(&GlobalSMBSeslock);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001243 cifsFileInfo_put(open_file);
Steve French9b22b0b2007-10-02 01:11:08 +00001244 goto refind_writable;
Steve French37c0eb42005-10-05 14:50:29 -07001245 }
1246 }
Steve French9b22b0b2007-10-02 01:11:08 +00001247
1248 /* if it fails, try another handle if possible -
1249 (we can not do this if closePending since
1250 loop could be modified - in which case we
1251 have to start at the beginning of the list
1252 again. Note that it would be bad
1253 to hold up writepages here (rather than
1254 in caller) with continuous retries */
1255 cFYI(1, ("wp failed on reopen file"));
1256 read_lock(&GlobalSMBSeslock);
1257 /* can not use this handle, no write
1258 pending on this one after all */
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001259 cifsFileInfo_put(open_file);
Steve French8840dee2007-11-16 23:05:52 +00001260
Steve French9b22b0b2007-10-02 01:11:08 +00001261 if (open_file->closePend) /* list could have changed */
1262 goto refind_writable;
1263 /* else we simply continue to the next entry. Thus
1264 we do not loop on reopen errors. If we
1265 can not reopen the file, for example if we
1266 reconnected to a server with another client
1267 racing to delete or lock the file we would not
1268 make progress if we restarted before the beginning
1269 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001270 }
1271 }
Jeff Layton2846d382008-09-22 21:33:33 -04001272 /* couldn't find useable FH with same pid, try any available */
1273 if (!any_available) {
1274 any_available = true;
1275 goto refind_writable;
1276 }
Steve French6148a742005-10-05 12:23:19 -07001277 read_unlock(&GlobalSMBSeslock);
1278 return NULL;
1279}
1280
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1282{
1283 struct address_space *mapping = page->mapping;
1284 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1285 char *write_data;
1286 int rc = -EFAULT;
1287 int bytes_written = 0;
1288 struct cifs_sb_info *cifs_sb;
1289 struct cifsTconInfo *pTcon;
1290 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001291 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292
1293 if (!mapping || !mapping->host)
1294 return -EFAULT;
1295
1296 inode = page->mapping->host;
1297 cifs_sb = CIFS_SB(inode->i_sb);
1298 pTcon = cifs_sb->tcon;
1299
1300 offset += (loff_t)from;
1301 write_data = kmap(page);
1302 write_data += from;
1303
1304 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1305 kunmap(page);
1306 return -EIO;
1307 }
1308
1309 /* racing with truncate? */
1310 if (offset > mapping->host->i_size) {
1311 kunmap(page);
1312 return 0; /* don't care */
1313 }
1314
1315 /* check to make sure that we are not extending the file */
1316 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001317 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318
Steve French6148a742005-10-05 12:23:19 -07001319 open_file = find_writable_file(CIFS_I(mapping->host));
1320 if (open_file) {
1321 bytes_written = cifs_write(open_file->pfile, write_data,
1322 to-from, &offset);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001323 cifsFileInfo_put(open_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001325 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001326 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001327 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001328 else if (bytes_written < 0)
1329 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001330 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 cFYI(1, ("No writeable filehandles for inode"));
1332 rc = -EIO;
1333 }
1334
1335 kunmap(page);
1336 return rc;
1337}
1338
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001340 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341{
Steve French37c0eb42005-10-05 14:50:29 -07001342 struct backing_dev_info *bdi = mapping->backing_dev_info;
1343 unsigned int bytes_to_write;
1344 unsigned int bytes_written;
1345 struct cifs_sb_info *cifs_sb;
1346 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001347 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001348 pgoff_t index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001349 int range_whole = 0;
1350 struct kvec *iov;
Steve French84d2f072005-10-12 15:32:05 -07001351 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001352 int n_iov = 0;
1353 pgoff_t next;
1354 int nr_pages;
1355 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001356 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001357 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
Steve French37c0eb42005-10-05 14:50:29 -07001358 struct page *page;
1359 struct pagevec pvec;
1360 int rc = 0;
1361 int scanned = 0;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001362 int xid, long_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363
Steve French37c0eb42005-10-05 14:50:29 -07001364 cifs_sb = CIFS_SB(mapping->host->i_sb);
Steve French50c2f752007-07-13 00:33:32 +00001365
Steve French37c0eb42005-10-05 14:50:29 -07001366 /*
1367 * If wsize is smaller that the page cache size, default to writing
1368 * one page at a time via cifs_writepage
1369 */
1370 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1371 return generic_writepages(mapping, wbc);
1372
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001373 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1374 if (cifs_sb->tcon->ses->server->secMode &
1375 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1376 if (!experimEnabled)
Steve French60808232006-04-22 15:53:05 +00001377 return generic_writepages(mapping, wbc);
Steve French4a771182005-10-05 15:14:33 -07001378
Steve French9a0c8232007-02-02 04:21:57 +00001379 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001380 if (iov == NULL)
Steve French9a0c8232007-02-02 04:21:57 +00001381 return generic_writepages(mapping, wbc);
1382
1383
Steve French37c0eb42005-10-05 14:50:29 -07001384 /*
1385 * BB: Is this meaningful for a non-block-device file system?
1386 * If it is, we should test it again after we do I/O
1387 */
1388 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1389 wbc->encountered_congestion = 1;
Steve French9a0c8232007-02-02 04:21:57 +00001390 kfree(iov);
Steve French37c0eb42005-10-05 14:50:29 -07001391 return 0;
1392 }
1393
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 xid = GetXid();
1395
Steve French37c0eb42005-10-05 14:50:29 -07001396 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001397 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001398 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001399 end = -1;
1400 } else {
1401 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1402 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1403 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1404 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001405 scanned = 1;
1406 }
1407retry:
1408 while (!done && (index <= end) &&
1409 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1410 PAGECACHE_TAG_DIRTY,
1411 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1412 int first;
1413 unsigned int i;
1414
Steve French37c0eb42005-10-05 14:50:29 -07001415 first = -1;
1416 next = 0;
1417 n_iov = 0;
1418 bytes_to_write = 0;
1419
1420 for (i = 0; i < nr_pages; i++) {
1421 page = pvec.pages[i];
1422 /*
1423 * At this point we hold neither mapping->tree_lock nor
1424 * lock on the page itself: the page may be truncated or
1425 * invalidated (changing page->mapping to NULL), or even
1426 * swizzled back from swapper_space to tmpfs file
1427 * mapping
1428 */
1429
1430 if (first < 0)
1431 lock_page(page);
Nick Piggin529ae9a2008-08-02 12:01:03 +02001432 else if (!trylock_page(page))
Steve French37c0eb42005-10-05 14:50:29 -07001433 break;
1434
1435 if (unlikely(page->mapping != mapping)) {
1436 unlock_page(page);
1437 break;
1438 }
1439
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001440 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001441 done = 1;
1442 unlock_page(page);
1443 break;
1444 }
1445
1446 if (next && (page->index != next)) {
1447 /* Not next consecutive page */
1448 unlock_page(page);
1449 break;
1450 }
1451
1452 if (wbc->sync_mode != WB_SYNC_NONE)
1453 wait_on_page_writeback(page);
1454
1455 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001456 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001457 unlock_page(page);
1458 break;
1459 }
Steve French84d2f072005-10-12 15:32:05 -07001460
Linus Torvaldscb876f42006-12-23 16:19:07 -08001461 /*
1462 * This actually clears the dirty bit in the radix tree.
1463 * See cifs_writepage() for more commentary.
1464 */
1465 set_page_writeback(page);
1466
Steve French84d2f072005-10-12 15:32:05 -07001467 if (page_offset(page) >= mapping->host->i_size) {
1468 done = 1;
1469 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001470 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001471 break;
1472 }
1473
Steve French37c0eb42005-10-05 14:50:29 -07001474 /*
1475 * BB can we get rid of this? pages are held by pvec
1476 */
1477 page_cache_get(page);
1478
Steve French84d2f072005-10-12 15:32:05 -07001479 len = min(mapping->host->i_size - page_offset(page),
1480 (loff_t)PAGE_CACHE_SIZE);
1481
Steve French37c0eb42005-10-05 14:50:29 -07001482 /* reserve iov[0] for the smb header */
1483 n_iov++;
1484 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001485 iov[n_iov].iov_len = len;
1486 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001487
1488 if (first < 0) {
1489 first = i;
1490 offset = page_offset(page);
1491 }
1492 next = page->index + 1;
1493 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1494 break;
1495 }
1496 if (n_iov) {
Steve French23e7dd72005-10-20 13:44:56 -07001497 /* Search for a writable handle every time we call
1498 * CIFSSMBWrite2. We can't rely on the last handle
1499 * we used to still be valid
1500 */
1501 open_file = find_writable_file(CIFS_I(mapping->host));
1502 if (!open_file) {
1503 cERROR(1, ("No writable handles for inode"));
1504 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001505 } else {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001506 long_op = cifs_write_timeout(cifsi, offset);
Steve French23e7dd72005-10-20 13:44:56 -07001507 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1508 open_file->netfid,
1509 bytes_to_write, offset,
1510 &bytes_written, iov, n_iov,
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001511 long_op);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001512 cifsFileInfo_put(open_file);
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001513 cifs_update_eof(cifsi, offset, bytes_written);
1514
Steve French23e7dd72005-10-20 13:44:56 -07001515 if (rc || bytes_written < bytes_to_write) {
Steve French63135e02007-07-17 17:34:02 +00001516 cERROR(1, ("Write2 ret %d, wrote %d",
Steve French23e7dd72005-10-20 13:44:56 -07001517 rc, bytes_written));
1518 /* BB what if continued retry is
1519 requested via mount flags? */
Jeff Laytoncea21802007-11-20 23:19:03 +00001520 if (rc == -ENOSPC)
1521 set_bit(AS_ENOSPC, &mapping->flags);
1522 else
1523 set_bit(AS_EIO, &mapping->flags);
Steve French23e7dd72005-10-20 13:44:56 -07001524 } else {
1525 cifs_stats_bytes_written(cifs_sb->tcon,
1526 bytes_written);
1527 }
Steve French37c0eb42005-10-05 14:50:29 -07001528 }
1529 for (i = 0; i < n_iov; i++) {
1530 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001531 /* Should we also set page error on
1532 success rc but too little data written? */
1533 /* BB investigate retry logic on temporary
1534 server crash cases and how recovery works
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001535 when page marked as error */
1536 if (rc)
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001537 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001538 kunmap(page);
1539 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001540 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001541 page_cache_release(page);
1542 }
1543 if ((wbc->nr_to_write -= n_iov) <= 0)
1544 done = 1;
1545 index = next;
Dave Kleikampb066a482008-11-18 03:49:05 +00001546 } else
1547 /* Need to re-find the pages we skipped */
1548 index = pvec.pages[0]->index + 1;
1549
Steve French37c0eb42005-10-05 14:50:29 -07001550 pagevec_release(&pvec);
1551 }
1552 if (!scanned && !done) {
1553 /*
1554 * We hit the last page and there is more work to be done: wrap
1555 * back to the start of the file
1556 */
1557 scanned = 1;
1558 index = 0;
1559 goto retry;
1560 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001561 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001562 mapping->writeback_index = index;
1563
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001565 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 return rc;
1567}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001569static int cifs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570{
1571 int rc = -EFAULT;
1572 int xid;
1573
1574 xid = GetXid();
1575/* BB add check for wbc flags */
1576 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001577 if (!PageUptodate(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578 cFYI(1, ("ppw - page not up to date"));
Linus Torvaldscb876f42006-12-23 16:19:07 -08001579
1580 /*
1581 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1582 *
1583 * A writepage() implementation always needs to do either this,
1584 * or re-dirty the page with "redirty_page_for_writepage()" in
1585 * the case of a failure.
1586 *
1587 * Just unlocking the page will cause the radix tree tag-bits
1588 * to fail to update with the state of the page correctly.
1589 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001590 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1592 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1593 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001594 end_page_writeback(page);
1595 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 FreeXid(xid);
1597 return rc;
1598}
1599
Nick Piggind9414772008-09-24 11:32:59 -04001600static int cifs_write_end(struct file *file, struct address_space *mapping,
1601 loff_t pos, unsigned len, unsigned copied,
1602 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603{
Nick Piggind9414772008-09-24 11:32:59 -04001604 int rc;
1605 struct inode *inode = mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606
Nick Piggind9414772008-09-24 11:32:59 -04001607 cFYI(1, ("write_end for page %p from pos %lld with %d bytes",
1608 page, pos, copied));
Steve Frenchad7a2922008-02-07 23:25:02 +00001609
Jeff Laytona98ee8c2008-11-26 19:32:33 +00001610 if (PageChecked(page)) {
1611 if (copied == len)
1612 SetPageUptodate(page);
1613 ClearPageChecked(page);
1614 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04001615 SetPageUptodate(page);
1616
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04001618 char *page_data;
1619 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1620 int xid;
1621
1622 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 /* this is probably better than directly calling
1624 partialpage_write since in this function the file handle is
1625 known which we might as well leverage */
1626 /* BB check if anything else missing out of ppw
1627 such as updating last write time */
1628 page_data = kmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001629 rc = cifs_write(file, page_data + offset, copied, &pos);
1630 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001632
1633 FreeXid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001634 } else {
Nick Piggind9414772008-09-24 11:32:59 -04001635 rc = copied;
1636 pos += copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637 set_page_dirty(page);
1638 }
1639
Nick Piggind9414772008-09-24 11:32:59 -04001640 if (rc > 0) {
1641 spin_lock(&inode->i_lock);
1642 if (pos > inode->i_size)
1643 i_size_write(inode, pos);
1644 spin_unlock(&inode->i_lock);
1645 }
1646
1647 unlock_page(page);
1648 page_cache_release(page);
1649
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 return rc;
1651}
1652
1653int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1654{
1655 int xid;
1656 int rc = 0;
Steve Frenchb298f222009-02-21 21:17:43 +00001657 struct cifsTconInfo *tcon;
1658 struct cifsFileInfo *smbfile =
1659 (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001660 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661
1662 xid = GetXid();
1663
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001664 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 dentry->d_name.name, datasync));
Steve French50c2f752007-07-13 00:33:32 +00001666
Jeff Laytoncea21802007-11-20 23:19:03 +00001667 rc = filemap_write_and_wait(inode->i_mapping);
1668 if (rc == 0) {
1669 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 CIFS_I(inode)->write_behind_rc = 0;
Steve Frenchb298f222009-02-21 21:17:43 +00001671 tcon = CIFS_SB(inode->i_sb)->tcon;
Steve Frenchbe652442009-02-23 15:21:59 +00001672 if (!rc && tcon && smbfile &&
Steve French4717bed2009-02-24 14:44:19 +00001673 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
Steve Frenchb298f222009-02-21 21:17:43 +00001674 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
Jeff Laytoncea21802007-11-20 23:19:03 +00001675 }
Steve Frenchb298f222009-02-21 21:17:43 +00001676
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 FreeXid(xid);
1678 return rc;
1679}
1680
NeilBrown3978d712006-03-26 01:37:17 -08001681/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682{
1683 struct address_space *mapping;
1684 struct inode *inode;
1685 unsigned long index = page->index;
1686 unsigned int rpages = 0;
1687 int rc = 0;
1688
1689 cFYI(1, ("sync page %p",page));
1690 mapping = page->mapping;
1691 if (!mapping)
1692 return 0;
1693 inode = mapping->host;
1694 if (!inode)
NeilBrown3978d712006-03-26 01:37:17 -08001695 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001697/* fill in rpages then
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1699
Steve French26a21b92006-05-31 18:05:34 +00001700/* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701
NeilBrown3978d712006-03-26 01:37:17 -08001702#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 if (rc < 0)
1704 return rc;
1705 return 0;
NeilBrown3978d712006-03-26 01:37:17 -08001706#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707} */
1708
1709/*
1710 * As file closes, flush all cached write data for this inode checking
1711 * for write behind errors.
1712 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001713int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001715 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 int rc = 0;
1717
1718 /* Rather than do the steps manually:
1719 lock the inode for writing
1720 loop through pages looking for write behind data (dirty pages)
1721 coalesce into contiguous 16K (or smaller) chunks to write to server
1722 send to server (prefer in parallel)
1723 deal with writebehind errors
1724 unlock inode for writing
1725 filemapfdatawrite appears easier for the time being */
1726
1727 rc = filemap_fdatawrite(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +00001728 /* reset wb rc if we were able to write out dirty pages */
1729 if (!rc) {
1730 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001732 }
Steve French50c2f752007-07-13 00:33:32 +00001733
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001734 cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735
1736 return rc;
1737}
1738
1739ssize_t cifs_user_read(struct file *file, char __user *read_data,
1740 size_t read_size, loff_t *poffset)
1741{
1742 int rc = -EACCES;
1743 unsigned int bytes_read = 0;
1744 unsigned int total_read = 0;
1745 unsigned int current_read_size;
1746 struct cifs_sb_info *cifs_sb;
1747 struct cifsTconInfo *pTcon;
1748 int xid;
1749 struct cifsFileInfo *open_file;
1750 char *smb_read_data;
1751 char __user *current_offset;
1752 struct smb_com_read_rsp *pSMBr;
1753
1754 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001755 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 pTcon = cifs_sb->tcon;
1757
1758 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301759 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301761 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 }
1763 open_file = (struct cifsFileInfo *)file->private_data;
1764
Steve Frenchad7a2922008-02-07 23:25:02 +00001765 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 cFYI(1, ("attempting read on write only file instance"));
Steve Frenchad7a2922008-02-07 23:25:02 +00001767
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 for (total_read = 0, current_offset = read_data;
1769 read_size > total_read;
1770 total_read += bytes_read, current_offset += bytes_read) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001771 current_read_size = min_t(const int, read_size - total_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 cifs_sb->rsize);
1773 rc = -EAGAIN;
1774 smb_read_data = NULL;
1775 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001776 int buf_type = CIFS_NO_BUFFER;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001777 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001778 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001779 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 if (rc != 0)
1781 break;
1782 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001783 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001784 open_file->netfid,
1785 current_read_size, *poffset,
1786 &bytes_read, &smb_read_data,
1787 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001790 if (copy_to_user(current_offset,
1791 smb_read_data +
1792 4 /* RFC1001 length field */ +
1793 le16_to_cpu(pSMBr->DataOffset),
Steve Frenchad7a2922008-02-07 23:25:02 +00001794 bytes_read))
Steve French93544cc2006-02-14 22:30:52 -06001795 rc = -EFAULT;
Steve French93544cc2006-02-14 22:30:52 -06001796
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001797 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001798 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001799 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001800 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 smb_read_data = NULL;
1802 }
1803 }
1804 if (rc || (bytes_read == 0)) {
1805 if (total_read) {
1806 break;
1807 } else {
1808 FreeXid(xid);
1809 return rc;
1810 }
1811 } else {
Steve Frencha45443472005-08-24 13:59:35 -07001812 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 *poffset += bytes_read;
1814 }
1815 }
1816 FreeXid(xid);
1817 return total_read;
1818}
1819
1820
1821static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1822 loff_t *poffset)
1823{
1824 int rc = -EACCES;
1825 unsigned int bytes_read = 0;
1826 unsigned int total_read;
1827 unsigned int current_read_size;
1828 struct cifs_sb_info *cifs_sb;
1829 struct cifsTconInfo *pTcon;
1830 int xid;
1831 char *current_offset;
1832 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001833 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834
1835 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001836 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 pTcon = cifs_sb->tcon;
1838
1839 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301840 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301842 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 }
1844 open_file = (struct cifsFileInfo *)file->private_data;
1845
1846 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1847 cFYI(1, ("attempting read on write only file instance"));
1848
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001849 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 read_size > total_read;
1851 total_read += bytes_read, current_offset += bytes_read) {
1852 current_read_size = min_t(const int, read_size - total_read,
1853 cifs_sb->rsize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001854 /* For windows me and 9x we do not want to request more
1855 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001856 if ((pTcon->ses) &&
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001857 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1858 current_read_size = min_t(const int, current_read_size,
1859 pTcon->ses->server->maxBuf - 128);
1860 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 rc = -EAGAIN;
1862 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001863 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001865 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 if (rc != 0)
1867 break;
1868 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001869 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001870 open_file->netfid,
1871 current_read_size, *poffset,
1872 &bytes_read, &current_offset,
1873 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 }
1875 if (rc || (bytes_read == 0)) {
1876 if (total_read) {
1877 break;
1878 } else {
1879 FreeXid(xid);
1880 return rc;
1881 }
1882 } else {
Steve Frencha45443472005-08-24 13:59:35 -07001883 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 *poffset += bytes_read;
1885 }
1886 }
1887 FreeXid(xid);
1888 return total_read;
1889}
1890
1891int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1892{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001893 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 int rc, xid;
1895
1896 xid = GetXid();
1897 rc = cifs_revalidate(dentry);
1898 if (rc) {
1899 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1900 FreeXid(xid);
1901 return rc;
1902 }
1903 rc = generic_file_mmap(file, vma);
1904 FreeXid(xid);
1905 return rc;
1906}
1907
1908
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001909static void cifs_copy_cache_pages(struct address_space *mapping,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 struct list_head *pages, int bytes_read, char *data,
1911 struct pagevec *plru_pvec)
1912{
1913 struct page *page;
1914 char *target;
1915
1916 while (bytes_read > 0) {
1917 if (list_empty(pages))
1918 break;
1919
1920 page = list_entry(pages->prev, struct page, lru);
1921 list_del(&page->lru);
1922
1923 if (add_to_page_cache(page, mapping, page->index,
1924 GFP_KERNEL)) {
1925 page_cache_release(page);
1926 cFYI(1, ("Add page cache failed"));
Steve French3079ca62005-06-09 14:44:07 -07001927 data += PAGE_CACHE_SIZE;
1928 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 continue;
1930 }
1931
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001932 target = kmap_atomic(page, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933
1934 if (PAGE_CACHE_SIZE > bytes_read) {
1935 memcpy(target, data, bytes_read);
1936 /* zero the tail end of this partial page */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001937 memset(target + bytes_read, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 PAGE_CACHE_SIZE - bytes_read);
1939 bytes_read = 0;
1940 } else {
1941 memcpy(target, data, PAGE_CACHE_SIZE);
1942 bytes_read -= PAGE_CACHE_SIZE;
1943 }
1944 kunmap_atomic(target, KM_USER0);
1945
1946 flush_dcache_page(page);
1947 SetPageUptodate(page);
1948 unlock_page(page);
1949 if (!pagevec_add(plru_pvec, page))
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001950 __pagevec_lru_add_file(plru_pvec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 data += PAGE_CACHE_SIZE;
1952 }
1953 return;
1954}
1955
1956static int cifs_readpages(struct file *file, struct address_space *mapping,
1957 struct list_head *page_list, unsigned num_pages)
1958{
1959 int rc = -EACCES;
1960 int xid;
1961 loff_t offset;
1962 struct page *page;
1963 struct cifs_sb_info *cifs_sb;
1964 struct cifsTconInfo *pTcon;
Steve French2c2130e2007-10-12 19:10:28 +00001965 unsigned int bytes_read = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001966 unsigned int read_size, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 char *smb_read_data = NULL;
1968 struct smb_com_read_rsp *pSMBr;
1969 struct pagevec lru_pvec;
1970 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001971 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
1973 xid = GetXid();
1974 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301975 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301977 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 }
1979 open_file = (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001980 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 pTcon = cifs_sb->tcon;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001982
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 pagevec_init(&lru_pvec, 0);
Steve French61de8002008-10-30 20:15:22 +00001984 cFYI(DBG2, ("rpages: num pages %d", num_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 for (i = 0; i < num_pages; ) {
1986 unsigned contig_pages;
1987 struct page *tmp_page;
1988 unsigned long expected_index;
1989
1990 if (list_empty(page_list))
1991 break;
1992
1993 page = list_entry(page_list->prev, struct page, lru);
1994 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1995
1996 /* count adjacent pages that we will read into */
1997 contig_pages = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001998 expected_index =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001999 list_entry(page_list->prev, struct page, lru)->index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002000 list_for_each_entry_reverse(tmp_page, page_list, lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 if (tmp_page->index == expected_index) {
2002 contig_pages++;
2003 expected_index++;
2004 } else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002005 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 }
2007 if (contig_pages + i > num_pages)
2008 contig_pages = num_pages - i;
2009
2010 /* for reads over a certain size could initiate async
2011 read ahead */
2012
2013 read_size = contig_pages * PAGE_CACHE_SIZE;
2014 /* Read size needs to be in multiples of one page */
2015 read_size = min_t(const unsigned int, read_size,
2016 cifs_sb->rsize & PAGE_CACHE_MASK);
Steve French90c81e02008-02-12 20:32:36 +00002017 cFYI(DBG2, ("rpages: read size 0x%x contiguous pages %d",
Steve French75865f8c2007-06-24 18:30:48 +00002018 read_size, contig_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019 rc = -EAGAIN;
2020 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002021 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00002023 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 if (rc != 0)
2025 break;
2026 }
2027
Steve Frenchbfa0d752005-08-31 21:50:37 -07002028 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08002029 open_file->netfid,
2030 read_size, offset,
2031 &bytes_read, &smb_read_data,
2032 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07002033 /* BB more RC checks ? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002034 if (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002036 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002037 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002038 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002039 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 smb_read_data = NULL;
2041 }
2042 }
2043 }
2044 if ((rc < 0) || (smb_read_data == NULL)) {
2045 cFYI(1, ("Read error in readpages: %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046 break;
2047 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08002048 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2050 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2051 smb_read_data + 4 /* RFC1001 hdr */ +
2052 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
2053
2054 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha45443472005-08-24 13:59:35 -07002055 cifs_stats_bytes_read(pTcon, bytes_read);
Steve French2c2130e2007-10-12 19:10:28 +00002056 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057 i++; /* account for partial page */
2058
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002059 /* server copy of file can have smaller size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002060 than client */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002061 /* BB do we need to verify this common case ?
2062 this case is ok - if we are at server EOF
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 we will hit it on next read */
2064
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08002065 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066 }
2067 } else {
2068 cFYI(1, ("No bytes read (%d) at offset %lld . "
2069 "Cleaning remaining pages from readahead list",
2070 bytes_read, offset));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002071 /* BB turn off caching and do new lookup on
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 break;
2074 }
2075 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002076 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002077 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002078 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002079 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 smb_read_data = NULL;
2081 }
2082 bytes_read = 0;
2083 }
2084
Rik van Riel4f98a2f2008-10-18 20:26:32 -07002085 pagevec_lru_add_file(&lru_pvec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086
2087/* need to free smb_read_data buf before exit */
2088 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002089 if (buf_type == CIFS_SMALL_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002090 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002091 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002092 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093 smb_read_data = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002094 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095
2096 FreeXid(xid);
2097 return rc;
2098}
2099
2100static int cifs_readpage_worker(struct file *file, struct page *page,
2101 loff_t *poffset)
2102{
2103 char *read_data;
2104 int rc;
2105
2106 page_cache_get(page);
2107 read_data = kmap(page);
2108 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002109
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002111
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 if (rc < 0)
2113 goto io_error;
2114 else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002115 cFYI(1, ("Bytes read %d", rc));
2116
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002117 file->f_path.dentry->d_inode->i_atime =
2118 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002119
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 if (PAGE_CACHE_SIZE > rc)
2121 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2122
2123 flush_dcache_page(page);
2124 SetPageUptodate(page);
2125 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002126
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002128 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129 page_cache_release(page);
2130 return rc;
2131}
2132
2133static int cifs_readpage(struct file *file, struct page *page)
2134{
2135 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2136 int rc = -EACCES;
2137 int xid;
2138
2139 xid = GetXid();
2140
2141 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302142 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002143 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302144 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 }
2146
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002147 cFYI(1, ("readpage %p at offset %d 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 page, (int)offset, (int)offset));
2149
2150 rc = cifs_readpage_worker(file, page, &offset);
2151
2152 unlock_page(page);
2153
2154 FreeXid(xid);
2155 return rc;
2156}
2157
Steve Frencha403a0a2007-07-26 15:54:16 +00002158static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2159{
2160 struct cifsFileInfo *open_file;
2161
2162 read_lock(&GlobalSMBSeslock);
2163 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2164 if (open_file->closePend)
2165 continue;
2166 if (open_file->pfile &&
2167 ((open_file->pfile->f_flags & O_RDWR) ||
2168 (open_file->pfile->f_flags & O_WRONLY))) {
2169 read_unlock(&GlobalSMBSeslock);
2170 return 1;
2171 }
2172 }
2173 read_unlock(&GlobalSMBSeslock);
2174 return 0;
2175}
2176
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177/* We do not want to update the file size from server for inodes
2178 open for write - to avoid races with writepage extending
2179 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002180 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181 but this is tricky to do without racing with writebehind
2182 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00002183bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184{
Steve Frencha403a0a2007-07-26 15:54:16 +00002185 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00002186 return true;
Steve French23e7dd72005-10-20 13:44:56 -07002187
Steve Frencha403a0a2007-07-26 15:54:16 +00002188 if (is_inode_writable(cifsInode)) {
2189 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08002190 struct cifs_sb_info *cifs_sb;
2191
Steve Frenchc32a0b62006-01-12 14:41:28 -08002192 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00002193 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002194 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08002195 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00002196 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08002197 }
2198
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002199 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00002200 return true;
Steve French7ba52632007-02-08 18:14:13 +00002201
Steve French4b18f2a2008-04-29 00:06:05 +00002202 return false;
Steve French23e7dd72005-10-20 13:44:56 -07002203 } else
Steve French4b18f2a2008-04-29 00:06:05 +00002204 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205}
2206
Nick Piggind9414772008-09-24 11:32:59 -04002207static int cifs_write_begin(struct file *file, struct address_space *mapping,
2208 loff_t pos, unsigned len, unsigned flags,
2209 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210{
Nick Piggind9414772008-09-24 11:32:59 -04002211 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2212 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002213 loff_t page_start = pos & PAGE_MASK;
2214 loff_t i_size;
2215 struct page *page;
2216 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217
Nick Piggind9414772008-09-24 11:32:59 -04002218 cFYI(1, ("write_begin from %lld len %d", (long long)pos, len));
2219
Nick Piggin54566b22009-01-04 12:00:53 -08002220 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002221 if (!page) {
2222 rc = -ENOMEM;
2223 goto out;
2224 }
Nick Piggind9414772008-09-24 11:32:59 -04002225
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002226 if (PageUptodate(page))
2227 goto out;
Steve French8a236262007-03-06 00:31:00 +00002228
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002229 /*
2230 * If we write a full page it will be up to date, no need to read from
2231 * the server. If the write is short, we'll end up doing a sync write
2232 * instead.
2233 */
2234 if (len == PAGE_CACHE_SIZE)
2235 goto out;
2236
2237 /*
2238 * optimize away the read when we have an oplock, and we're not
2239 * expecting to use any of the data we'd be reading in. That
2240 * is, when the page lies beyond the EOF, or straddles the EOF
2241 * and the write will cover all of the existing data.
2242 */
2243 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2244 i_size = i_size_read(mapping->host);
2245 if (page_start >= i_size ||
2246 (offset == 0 && (pos + len) >= i_size)) {
2247 zero_user_segments(page, 0, offset,
2248 offset + len,
2249 PAGE_CACHE_SIZE);
2250 /*
2251 * PageChecked means that the parts of the page
2252 * to which we're not writing are considered up
2253 * to date. Once the data is copied to the
2254 * page, it can be set uptodate.
2255 */
2256 SetPageChecked(page);
2257 goto out;
2258 }
2259 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260
Nick Piggind9414772008-09-24 11:32:59 -04002261 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002262 /*
2263 * might as well read a page, it is fast enough. If we get
2264 * an error, we don't need to return it. cifs_write_end will
2265 * do a sync write instead since PG_uptodate isn't set.
2266 */
2267 cifs_readpage_worker(file, page, &page_start);
Steve French8a236262007-03-06 00:31:00 +00002268 } else {
2269 /* we could try using another file handle if there is one -
2270 but how would we lock it to prevent close of that handle
2271 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04002272 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00002273 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002274out:
2275 *pagep = page;
2276 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002277}
2278
Jeff Layton3bc303c2009-09-21 06:47:50 -04002279static void
2280cifs_oplock_break(struct slow_work *work)
2281{
2282 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2283 oplock_break);
2284 struct inode *inode = cfile->pInode;
2285 struct cifsInodeInfo *cinode = CIFS_I(inode);
2286 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->mnt->mnt_sb);
2287 int rc, waitrc = 0;
2288
2289 if (inode && S_ISREG(inode->i_mode)) {
2290#ifdef CONFIG_CIFS_EXPERIMENTAL
2291 if (cinode->clientCanCacheAll == 0)
Al Viro8737c932009-12-24 06:47:55 -05002292 break_lease(inode, O_RDONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002293 else if (cinode->clientCanCacheRead == 0)
Al Viro8737c932009-12-24 06:47:55 -05002294 break_lease(inode, O_WRONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002295#endif
2296 rc = filemap_fdatawrite(inode->i_mapping);
2297 if (cinode->clientCanCacheRead == 0) {
2298 waitrc = filemap_fdatawait(inode->i_mapping);
2299 invalidate_remote_inode(inode);
2300 }
2301 if (!rc)
2302 rc = waitrc;
2303 if (rc)
2304 cinode->write_behind_rc = rc;
2305 cFYI(1, ("Oplock flush inode %p rc %d", inode, rc));
2306 }
2307
2308 /*
2309 * releasing stale oplock after recent reconnect of smb session using
2310 * a now incorrect file handle is not a data integrity issue but do
2311 * not bother sending an oplock release if session to server still is
2312 * disconnected since oplock already released by the server
2313 */
2314 if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2315 rc = CIFSSMBLock(0, cifs_sb->tcon, cfile->netfid, 0, 0, 0, 0,
2316 LOCKING_ANDX_OPLOCK_RELEASE, false);
2317 cFYI(1, ("Oplock release rc = %d", rc));
2318 }
2319}
2320
2321static int
2322cifs_oplock_break_get(struct slow_work *work)
2323{
2324 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2325 oplock_break);
2326 mntget(cfile->mnt);
2327 cifsFileInfo_get(cfile);
2328 return 0;
2329}
2330
2331static void
2332cifs_oplock_break_put(struct slow_work *work)
2333{
2334 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2335 oplock_break);
2336 mntput(cfile->mnt);
2337 cifsFileInfo_put(cfile);
2338}
2339
2340const struct slow_work_ops cifs_oplock_break_ops = {
2341 .get_ref = cifs_oplock_break_get,
2342 .put_ref = cifs_oplock_break_put,
2343 .execute = cifs_oplock_break,
2344};
2345
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002346const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 .readpage = cifs_readpage,
2348 .readpages = cifs_readpages,
2349 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002350 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002351 .write_begin = cifs_write_begin,
2352 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353 .set_page_dirty = __set_page_dirty_nobuffers,
2354 /* .sync_page = cifs_sync_page, */
2355 /* .direct_IO = */
2356};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002357
2358/*
2359 * cifs_readpages requires the server to support a buffer large enough to
2360 * contain the header plus one complete page of data. Otherwise, we need
2361 * to leave cifs_readpages out of the address space operations.
2362 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002363const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002364 .readpage = cifs_readpage,
2365 .writepage = cifs_writepage,
2366 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002367 .write_begin = cifs_write_begin,
2368 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002369 .set_page_dirty = __set_page_dirty_nobuffers,
2370 /* .sync_page = cifs_sync_page, */
2371 /* .direct_IO = */
2372};