blob: 40b690073fc1432f165c1c0dfb208b22a1863bde [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <asm/div64.h>
34#include "cifsfs.h"
35#include "cifspdu.h"
36#include "cifsglob.h"
37#include "cifsproto.h"
38#include "cifs_unicode.h"
39#include "cifs_debug.h"
40#include "cifs_fs_sb.h"
41
42static inline struct cifsFileInfo *cifs_init_private(
43 struct cifsFileInfo *private_data, struct inode *inode,
44 struct file *file, __u16 netfid)
45{
46 memset(private_data, 0, sizeof(struct cifsFileInfo));
47 private_data->netfid = netfid;
Steve Frenchfb8c4b12007-07-10 01:16:18 +000048 private_data->pid = current->tgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 init_MUTEX(&private_data->fh_sem);
Roland Dreier796e5662007-05-03 04:33:45 +000050 mutex_init(&private_data->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +000051 INIT_LIST_HEAD(&private_data->llist);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 private_data->pfile = file; /* needed for writepage */
53 private_data->pInode = inode;
54 private_data->invalidHandle = FALSE;
55 private_data->closePend = FALSE;
Steve French23e7dd72005-10-20 13:44:56 -070056 /* we have to track num writers to the inode, since writepages
57 does not tell us which handle the write is for so there can
58 be a close (overlapping with write) of the filehandle that
59 cifs_writepages chose to use */
Steve Frenchfb8c4b12007-07-10 01:16:18 +000060 atomic_set(&private_data->wrtPending, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62 return private_data;
63}
64
65static inline int cifs_convert_flags(unsigned int flags)
66{
67 if ((flags & O_ACCMODE) == O_RDONLY)
68 return GENERIC_READ;
69 else if ((flags & O_ACCMODE) == O_WRONLY)
70 return GENERIC_WRITE;
71 else if ((flags & O_ACCMODE) == O_RDWR) {
72 /* GENERIC_ALL is too much permission to request
73 can cause unnecessary access denied on create */
74 /* return GENERIC_ALL; */
75 return (GENERIC_READ | GENERIC_WRITE);
76 }
77
78 return 0x20197;
79}
80
81static inline int cifs_get_disposition(unsigned int flags)
82{
83 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
84 return FILE_CREATE;
85 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
86 return FILE_OVERWRITE_IF;
87 else if ((flags & O_CREAT) == O_CREAT)
88 return FILE_OPEN_IF;
Steve French55aa2e02006-05-30 18:09:31 +000089 else if ((flags & O_TRUNC) == O_TRUNC)
90 return FILE_OVERWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 else
92 return FILE_OPEN;
93}
94
95/* all arguments to this function must be checked for validity in caller */
96static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
97 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
98 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
99 char *full_path, int xid)
100{
101 struct timespec temp;
102 int rc;
103
104 /* want handles we can use to read with first
105 in the list so we do not have to walk the
106 list to search for one in prepare_write */
107 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000108 list_add_tail(&pCifsFile->flist,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 &pCifsInode->openFileList);
110 } else {
111 list_add(&pCifsFile->flist,
112 &pCifsInode->openFileList);
113 }
114 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 if (pCifsInode->clientCanCacheRead) {
116 /* we have the inode open somewhere else
117 no need to discard cache data */
118 goto client_can_cache;
119 }
120
121 /* BB need same check in cifs_create too? */
122 /* if not oplocked, invalidate inode pages if mtime or file
123 size changed */
124 temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800125 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
126 (file->f_path.dentry->d_inode->i_size ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 (loff_t)le64_to_cpu(buf->EndOfFile))) {
128 cFYI(1, ("inode unchanged on server"));
129 } else {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800130 if (file->f_path.dentry->d_inode->i_mapping) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 /* BB no need to lock inode until after invalidate
132 since namei code should already have it locked? */
Jeff Laytoncea21802007-11-20 23:19:03 +0000133 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
134 if (rc != 0)
135 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 }
137 cFYI(1, ("invalidating remote inode since open detected it "
138 "changed"));
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800139 invalidate_remote_inode(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 }
141
142client_can_cache:
Steve Frenchc18c8422007-07-18 23:21:09 +0000143 if (pTcon->unix_ext)
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800144 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 full_path, inode->i_sb, xid);
146 else
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800147 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
Steve French8b1327f2008-03-14 22:37:16 +0000148 full_path, buf, inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
150 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
151 pCifsInode->clientCanCacheAll = TRUE;
152 pCifsInode->clientCanCacheRead = TRUE;
153 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800154 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 } else if ((*oplock & 0xF) == OPLOCK_READ)
156 pCifsInode->clientCanCacheRead = TRUE;
157
158 return rc;
159}
160
161int cifs_open(struct inode *inode, struct file *file)
162{
163 int rc = -EACCES;
164 int xid, oplock;
165 struct cifs_sb_info *cifs_sb;
166 struct cifsTconInfo *pTcon;
167 struct cifsFileInfo *pCifsFile;
168 struct cifsInodeInfo *pCifsInode;
169 struct list_head *tmp;
170 char *full_path = NULL;
171 int desiredAccess;
172 int disposition;
173 __u16 netfid;
174 FILE_ALL_INFO *buf = NULL;
175
176 xid = GetXid();
177
178 cifs_sb = CIFS_SB(inode->i_sb);
179 pTcon = cifs_sb->tcon;
180
181 if (file->f_flags & O_CREAT) {
182 /* search inode for this file and fill in file->private_data */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800183 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 read_lock(&GlobalSMBSeslock);
185 list_for_each(tmp, &pCifsInode->openFileList) {
186 pCifsFile = list_entry(tmp, struct cifsFileInfo,
187 flist);
188 if ((pCifsFile->pfile == NULL) &&
189 (pCifsFile->pid == current->tgid)) {
190 /* mode set in cifs_create */
191
192 /* needed for writepage */
193 pCifsFile->pfile = file;
Steve French50c2f752007-07-13 00:33:32 +0000194
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 file->private_data = pCifsFile;
196 break;
197 }
198 }
199 read_unlock(&GlobalSMBSeslock);
200 if (file->private_data != NULL) {
201 rc = 0;
202 FreeXid(xid);
203 return rc;
204 } else {
205 if (file->f_flags & O_EXCL)
206 cERROR(1, ("could not find file instance for "
Steve French26a21b92006-05-31 18:05:34 +0000207 "new file %p", file));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 }
209 }
210
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800211 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 if (full_path == NULL) {
213 FreeXid(xid);
214 return -ENOMEM;
215 }
216
Steve French7521a3c2007-07-11 18:30:34 +0000217 cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 inode, file->f_flags, full_path));
219 desiredAccess = cifs_convert_flags(file->f_flags);
220
221/*********************************************************************
222 * open flag mapping table:
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000223 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 * POSIX Flag CIFS Disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000225 * ---------- ----------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700226 * O_CREAT FILE_OPEN_IF
227 * O_CREAT | O_EXCL FILE_CREATE
228 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
229 * O_TRUNC FILE_OVERWRITE
230 * none of the above FILE_OPEN
231 *
232 * Note that there is not a direct match between disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000233 * FILE_SUPERSEDE (ie create whether or not file exists although
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 * O_CREAT | O_TRUNC is similar but truncates the existing
235 * file rather than creating a new file as FILE_SUPERSEDE does
236 * (which uses the attributes / metadata passed in on open call)
237 *?
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000238 *? O_SYNC is a reasonable match to CIFS writethrough flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239 *? and the read write flags match reasonably. O_LARGEFILE
240 *? is irrelevant because largefile support is always used
241 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
242 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
243 *********************************************************************/
244
245 disposition = cifs_get_disposition(file->f_flags);
246
247 if (oplockEnabled)
248 oplock = REQ_OPLOCK;
249 else
250 oplock = FALSE;
251
252 /* BB pass O_SYNC flag through on file attributes .. BB */
253
254 /* Also refresh inode by passing in file_info buf returned by SMBOpen
255 and calling get_inode_info with returned buf (at least helps
256 non-Unix server case) */
257
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000258 /* BB we can not do this if this is the second open of a file
259 and the first handle has writebehind data, we might be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
261 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
262 if (!buf) {
263 rc = -ENOMEM;
264 goto out;
265 }
Steve French5bafd762006-06-07 00:18:43 +0000266
267 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000268 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
Steve French5bafd762006-06-07 00:18:43 +0000269 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
Steve French737b7582005-04-28 22:41:06 -0700270 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
271 & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000272 else
273 rc = -EIO; /* no NT SMB support fall into legacy open below */
274
Steve Frencha9d02ad2005-08-24 23:06:05 -0700275 if (rc == -EIO) {
276 /* Old server, try legacy style OpenX */
277 rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
278 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
279 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
280 & CIFS_MOUNT_MAP_SPECIAL_CHR);
281 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282 if (rc) {
Steve French26a21b92006-05-31 18:05:34 +0000283 cFYI(1, ("cifs_open returned 0x%x", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 goto out;
285 }
286 file->private_data =
287 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
288 if (file->private_data == NULL) {
289 rc = -ENOMEM;
290 goto out;
291 }
292 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 write_lock(&GlobalSMBSeslock);
294 list_add(&pCifsFile->tlist, &pTcon->openFileList);
295
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800296 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 if (pCifsInode) {
298 rc = cifs_open_inode_helper(inode, file, pCifsInode,
299 pCifsFile, pTcon,
300 &oplock, buf, full_path, xid);
301 } else {
302 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 }
304
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000305 if (oplock & CIFS_CREATE_ACTION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 /* time to set mode which we can not set earlier due to
307 problems creating new read-only files */
Steve Frenchc18c8422007-07-18 23:21:09 +0000308 if (pTcon->unix_ext) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
310 inode->i_mode,
311 (__u64)-1, (__u64)-1, 0 /* dev */,
Steve French737b7582005-04-28 22:41:06 -0700312 cifs_sb->local_nls,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000313 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700314 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 } else {
316 /* BB implement via Windows security descriptors eg
317 CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
318 -1, -1, local_nls);
319 in the meantime could set r/o dos attribute when
320 perms are eg: mode & 0222 == 0 */
321 }
322 }
323
324out:
325 kfree(buf);
326 kfree(full_path);
327 FreeXid(xid);
328 return rc;
329}
330
Adrian Bunk04187262006-06-30 18:23:04 +0200331/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332/* to server was lost */
333static int cifs_relock_file(struct cifsFileInfo *cifsFile)
334{
335 int rc = 0;
336
337/* BB list all locks open on this file and relock */
338
339 return rc;
340}
341
Steve French3a9f4622007-04-04 17:10:24 +0000342static int cifs_reopen_file(struct file *file, int can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
344 int rc = -EACCES;
345 int xid, oplock;
346 struct cifs_sb_info *cifs_sb;
347 struct cifsTconInfo *pTcon;
348 struct cifsFileInfo *pCifsFile;
349 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000350 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 char *full_path = NULL;
352 int desiredAccess;
353 int disposition = FILE_OPEN;
354 __u16 netfid;
355
Steve Frenchad7a2922008-02-07 23:25:02 +0000356 if (file->private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 pCifsFile = (struct cifsFileInfo *)file->private_data;
Steve Frenchad7a2922008-02-07 23:25:02 +0000358 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 return -EBADF;
360
361 xid = GetXid();
362 down(&pCifsFile->fh_sem);
363 if (pCifsFile->invalidHandle == FALSE) {
364 up(&pCifsFile->fh_sem);
365 FreeXid(xid);
366 return 0;
367 }
368
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800369 if (file->f_path.dentry == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000370 cERROR(1, ("no valid name if dentry freed"));
371 dump_stack();
372 rc = -EBADF;
373 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 }
Steve French3a9f4622007-04-04 17:10:24 +0000375
376 inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000377 if (inode == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000378 cERROR(1, ("inode not valid"));
379 dump_stack();
380 rc = -EBADF;
381 goto reopen_error_exit;
382 }
Steve French50c2f752007-07-13 00:33:32 +0000383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384 cifs_sb = CIFS_SB(inode->i_sb);
385 pTcon = cifs_sb->tcon;
Steve French3a9f4622007-04-04 17:10:24 +0000386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387/* can not grab rename sem here because various ops, including
388 those that already have the rename sem can end up causing writepage
389 to get called and if the server was down that means we end up here,
390 and we can never tell if the caller already has the rename_sem */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800391 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000393 rc = -ENOMEM;
394reopen_error_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 up(&pCifsFile->fh_sem);
396 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000397 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 }
399
Steve French3a9f4622007-04-04 17:10:24 +0000400 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000401 inode, file->f_flags, full_path));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 desiredAccess = cifs_convert_flags(file->f_flags);
403
404 if (oplockEnabled)
405 oplock = REQ_OPLOCK;
406 else
407 oplock = FALSE;
408
409 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000410 by SMBOpen and then calling get_inode_info with returned buf
411 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 and server version of file size can be stale. If we knew for sure
413 that inode was not dirty locally we could do this */
414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
416 CREATE_NOT_DIR, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000417 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700418 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 if (rc) {
420 up(&pCifsFile->fh_sem);
Steve French26a21b92006-05-31 18:05:34 +0000421 cFYI(1, ("cifs_open returned 0x%x", rc));
422 cFYI(1, ("oplock: %d", oplock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 } else {
424 pCifsFile->netfid = netfid;
425 pCifsFile->invalidHandle = FALSE;
426 up(&pCifsFile->fh_sem);
427 pCifsInode = CIFS_I(inode);
428 if (pCifsInode) {
429 if (can_flush) {
Jeff Laytoncea21802007-11-20 23:19:03 +0000430 rc = filemap_write_and_wait(inode->i_mapping);
431 if (rc != 0)
432 CIFS_I(inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 /* temporarily disable caching while we
434 go to server to get inode info */
435 pCifsInode->clientCanCacheAll = FALSE;
436 pCifsInode->clientCanCacheRead = FALSE;
Steve Frenchc18c8422007-07-18 23:21:09 +0000437 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 rc = cifs_get_inode_info_unix(&inode,
439 full_path, inode->i_sb, xid);
440 else
441 rc = cifs_get_inode_info(&inode,
442 full_path, NULL, inode->i_sb,
Steve French8b1327f2008-03-14 22:37:16 +0000443 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 } /* else we are writing out data to server already
445 and could deadlock if we tried to flush data, and
446 since we do not know if we have data that would
447 invalidate the current end of file on the server
448 we can not go to the server to get the new inod
449 info */
450 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
451 pCifsInode->clientCanCacheAll = TRUE;
452 pCifsInode->clientCanCacheRead = TRUE;
453 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800454 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 } else if ((oplock & 0xF) == OPLOCK_READ) {
456 pCifsInode->clientCanCacheRead = TRUE;
457 pCifsInode->clientCanCacheAll = FALSE;
458 } else {
459 pCifsInode->clientCanCacheRead = FALSE;
460 pCifsInode->clientCanCacheAll = FALSE;
461 }
462 cifs_relock_file(pCifsFile);
463 }
464 }
465
466 kfree(full_path);
467 FreeXid(xid);
468 return rc;
469}
470
471int cifs_close(struct inode *inode, struct file *file)
472{
473 int rc = 0;
Steve French15745322007-09-07 22:23:48 +0000474 int xid, timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 struct cifs_sb_info *cifs_sb;
476 struct cifsTconInfo *pTcon;
477 struct cifsFileInfo *pSMBFile =
478 (struct cifsFileInfo *)file->private_data;
479
480 xid = GetXid();
481
482 cifs_sb = CIFS_SB(inode->i_sb);
483 pTcon = cifs_sb->tcon;
484 if (pSMBFile) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000485 struct cifsLockInfo *li, *tmp;
486
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 pSMBFile->closePend = TRUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 if (pTcon) {
489 /* no sense reconnecting to close a file that is
490 already closed */
491 if (pTcon->tidStatus != CifsNeedReconnect) {
Steve French15745322007-09-07 22:23:48 +0000492 timeout = 2;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000493 while ((atomic_read(&pSMBFile->wrtPending) != 0)
Steve French15745322007-09-07 22:23:48 +0000494 && (timeout <= 2048)) {
Steve French23e7dd72005-10-20 13:44:56 -0700495 /* Give write a better chance to get to
496 server ahead of the close. We do not
497 want to add a wait_q here as it would
498 increase the memory utilization as
499 the struct would be in each open file,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000500 but this should give enough time to
Steve French23e7dd72005-10-20 13:44:56 -0700501 clear the socket */
Steve French90c81e02008-02-12 20:32:36 +0000502 cFYI(DBG2,
503 ("close delay, write pending"));
Steve French23e7dd72005-10-20 13:44:56 -0700504 msleep(timeout);
505 timeout *= 4;
Steve French4891d532006-11-07 16:31:16 +0000506 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000507 if (atomic_read(&pSMBFile->wrtPending))
Steve French63135e02007-07-17 17:34:02 +0000508 cERROR(1,
509 ("close with pending writes"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 rc = CIFSSMBClose(xid, pTcon,
511 pSMBFile->netfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 }
513 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000514
515 /* Delete any outstanding lock records.
516 We'll lose them when the file is closed anyway. */
Roland Dreier796e5662007-05-03 04:33:45 +0000517 mutex_lock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000518 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
519 list_del(&li->llist);
520 kfree(li);
521 }
Roland Dreier796e5662007-05-03 04:33:45 +0000522 mutex_unlock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000523
Steve Frenchcbe04762005-04-28 22:41:05 -0700524 write_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 list_del(&pSMBFile->flist);
526 list_del(&pSMBFile->tlist);
Steve Frenchcbe04762005-04-28 22:41:05 -0700527 write_unlock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +0000528 timeout = 10;
529 /* We waited above to give the SMBWrite a chance to issue
530 on the wire (so we do not get SMBWrite returning EBADF
531 if writepages is racing with close. Note that writepages
532 does not specify a file handle, so it is possible for a file
533 to be opened twice, and the application close the "wrong"
534 file handle - in these cases we delay long enough to allow
535 the SMBWrite to get on the wire before the SMB Close.
536 We allow total wait here over 45 seconds, more than
537 oplock break time, and more than enough to allow any write
538 to complete on the server, or to time out on the client */
539 while ((atomic_read(&pSMBFile->wrtPending) != 0)
540 && (timeout <= 50000)) {
541 cERROR(1, ("writes pending, delay free of handle"));
542 msleep(timeout);
543 timeout *= 8;
544 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 kfree(pSMBFile->search_resume_name);
546 kfree(file->private_data);
547 file->private_data = NULL;
548 } else
549 rc = -EBADF;
550
Steve French4efa53f2007-09-11 05:50:53 +0000551 read_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 if (list_empty(&(CIFS_I(inode)->openFileList))) {
553 cFYI(1, ("closing last open instance for inode %p", inode));
554 /* if the file is not open we do not know if we can cache info
555 on this inode, much less write behind and read ahead */
556 CIFS_I(inode)->clientCanCacheRead = FALSE;
557 CIFS_I(inode)->clientCanCacheAll = FALSE;
558 }
Steve French4efa53f2007-09-11 05:50:53 +0000559 read_unlock(&GlobalSMBSeslock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000560 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 rc = CIFS_I(inode)->write_behind_rc;
562 FreeXid(xid);
563 return rc;
564}
565
566int cifs_closedir(struct inode *inode, struct file *file)
567{
568 int rc = 0;
569 int xid;
570 struct cifsFileInfo *pCFileStruct =
571 (struct cifsFileInfo *)file->private_data;
572 char *ptmp;
573
Steve French26a21b92006-05-31 18:05:34 +0000574 cFYI(1, ("Closedir inode = 0x%p", inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
576 xid = GetXid();
577
578 if (pCFileStruct) {
579 struct cifsTconInfo *pTcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000580 struct cifs_sb_info *cifs_sb =
581 CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
583 pTcon = cifs_sb->tcon;
584
585 cFYI(1, ("Freeing private data in close dir"));
Steve French31ca3bc2005-04-28 22:41:11 -0700586 if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
587 (pCFileStruct->invalidHandle == FALSE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 pCFileStruct->invalidHandle = TRUE;
589 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
590 cFYI(1, ("Closing uncompleted readdir with rc %d",
591 rc));
592 /* not much we can do if it fails anyway, ignore rc */
593 rc = 0;
594 }
595 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
596 if (ptmp) {
Steve Frenchec637e32005-12-12 20:53:18 -0800597 cFYI(1, ("closedir free smb buf in srch struct"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000599 if (pCFileStruct->srch_inf.smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000600 cifs_small_buf_release(ptmp);
601 else
602 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 }
604 ptmp = pCFileStruct->search_resume_name;
605 if (ptmp) {
Steve Frenchec637e32005-12-12 20:53:18 -0800606 cFYI(1, ("closedir free resume name"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 pCFileStruct->search_resume_name = NULL;
608 kfree(ptmp);
609 }
610 kfree(file->private_data);
611 file->private_data = NULL;
612 }
613 /* BB can we lock the filestruct while this is going on? */
614 FreeXid(xid);
615 return rc;
616}
617
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000618static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
619 __u64 offset, __u8 lockType)
620{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000621 struct cifsLockInfo *li =
622 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000623 if (li == NULL)
624 return -ENOMEM;
625 li->offset = offset;
626 li->length = len;
627 li->type = lockType;
Roland Dreier796e5662007-05-03 04:33:45 +0000628 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000629 list_add(&li->llist, &fid->llist);
Roland Dreier796e5662007-05-03 04:33:45 +0000630 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000631 return 0;
632}
633
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
635{
636 int rc, xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 __u32 numLock = 0;
638 __u32 numUnlock = 0;
639 __u64 length;
640 int wait_flag = FALSE;
641 struct cifs_sb_info *cifs_sb;
642 struct cifsTconInfo *pTcon;
Steve French08547b02006-02-28 22:39:25 +0000643 __u16 netfid;
644 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000645 int posix_locking;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646
647 length = 1 + pfLock->fl_end - pfLock->fl_start;
648 rc = -EACCES;
649 xid = GetXid();
650
651 cFYI(1, ("Lock parm: 0x%x flockflags: "
652 "0x%x flocktype: 0x%x start: %lld end: %lld",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000653 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
654 pfLock->fl_end));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655
656 if (pfLock->fl_flags & FL_POSIX)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000657 cFYI(1, ("Posix"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 if (pfLock->fl_flags & FL_FLOCK)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000659 cFYI(1, ("Flock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 if (pfLock->fl_flags & FL_SLEEP) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000661 cFYI(1, ("Blocking lock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 wait_flag = TRUE;
663 }
664 if (pfLock->fl_flags & FL_ACCESS)
665 cFYI(1, ("Process suspended by mandatory locking - "
Steve French26a21b92006-05-31 18:05:34 +0000666 "not implemented yet"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 if (pfLock->fl_flags & FL_LEASE)
668 cFYI(1, ("Lease on file - not implemented yet"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000669 if (pfLock->fl_flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
671 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
672
673 if (pfLock->fl_type == F_WRLCK) {
674 cFYI(1, ("F_WRLCK "));
675 numLock = 1;
676 } else if (pfLock->fl_type == F_UNLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000677 cFYI(1, ("F_UNLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 numUnlock = 1;
Steve Frenchd47d7c12006-02-28 03:45:48 +0000679 /* Check if unlock includes more than
680 one lock range */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 } else if (pfLock->fl_type == F_RDLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000682 cFYI(1, ("F_RDLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 lockType |= LOCKING_ANDX_SHARED_LOCK;
684 numLock = 1;
685 } else if (pfLock->fl_type == F_EXLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000686 cFYI(1, ("F_EXLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 numLock = 1;
688 } else if (pfLock->fl_type == F_SHLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000689 cFYI(1, ("F_SHLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 lockType |= LOCKING_ANDX_SHARED_LOCK;
691 numLock = 1;
692 } else
Steve Frenchd47d7c12006-02-28 03:45:48 +0000693 cFYI(1, ("Unknown type of lock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800695 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 pTcon = cifs_sb->tcon;
697
698 if (file->private_data == NULL) {
699 FreeXid(xid);
700 return -EBADF;
701 }
Steve French08547b02006-02-28 22:39:25 +0000702 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000704 posix_locking = (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
705 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability));
Steve French08547b02006-02-28 22:39:25 +0000706
707 /* BB add code here to normalize offset and length to
708 account for negative length which we can not accept over the
709 wire */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 if (IS_GETLK(cmd)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000711 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000712 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000713 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000714 posix_lock_type = CIFS_RDLCK;
715 else
716 posix_lock_type = CIFS_WRLCK;
717 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 1 /* get */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000718 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000719 posix_lock_type, wait_flag);
720 FreeXid(xid);
721 return rc;
722 }
723
724 /* BB we could chain these into one lock request BB */
725 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
726 0, 1, lockType, 0 /* wait flag */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 if (rc == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000728 rc = CIFSSMBLock(xid, pTcon, netfid, length,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 pfLock->fl_start, 1 /* numUnlock */ ,
730 0 /* numLock */ , lockType,
731 0 /* wait flag */ );
732 pfLock->fl_type = F_UNLCK;
733 if (rc != 0)
734 cERROR(1, ("Error unlocking previously locked "
Steve French08547b02006-02-28 22:39:25 +0000735 "range %d during test of lock", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 rc = 0;
737
738 } else {
739 /* if rc == ERR_SHARING_VIOLATION ? */
740 rc = 0; /* do not change lock type to unlock
741 since range in use */
742 }
743
744 FreeXid(xid);
745 return rc;
746 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000747
748 if (!numLock && !numUnlock) {
749 /* if no lock or unlock then nothing
750 to do since we do not know what it is */
751 FreeXid(xid);
752 return -EOPNOTSUPP;
753 }
754
755 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000756 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000757 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000758 posix_lock_type = CIFS_RDLCK;
759 else
760 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +0000761
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000762 if (numUnlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +0000763 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000764
Steve French08547b02006-02-28 22:39:25 +0000765 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000766 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000767 posix_lock_type, wait_flag);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000768 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000769 struct cifsFileInfo *fid =
770 (struct cifsFileInfo *)file->private_data;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000771
772 if (numLock) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000773 rc = CIFSSMBLock(xid, pTcon, netfid, length,
774 pfLock->fl_start,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000775 0, numLock, lockType, wait_flag);
776
777 if (rc == 0) {
778 /* For Windows locks we must store them. */
779 rc = store_file_lock(fid, length,
780 pfLock->fl_start, lockType);
781 }
782 } else if (numUnlock) {
783 /* For each stored lock that this unlock overlaps
784 completely, unlock it. */
785 int stored_rc = 0;
786 struct cifsLockInfo *li, *tmp;
787
Steve French6b70c952006-09-21 07:35:29 +0000788 rc = 0;
Roland Dreier796e5662007-05-03 04:33:45 +0000789 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000790 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
791 if (pfLock->fl_start <= li->offset &&
Steve Frenchc19eb712007-08-24 03:22:48 +0000792 (pfLock->fl_start + length) >=
Jeff Layton39db8102007-08-24 03:16:51 +0000793 (li->offset + li->length)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000794 stored_rc = CIFSSMBLock(xid, pTcon,
795 netfid,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000796 li->length, li->offset,
797 1, 0, li->type, FALSE);
798 if (stored_rc)
799 rc = stored_rc;
800
801 list_del(&li->llist);
802 kfree(li);
803 }
804 }
Roland Dreier796e5662007-05-03 04:33:45 +0000805 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000806 }
807 }
808
Steve Frenchd634cc12005-08-26 14:42:59 -0500809 if (pfLock->fl_flags & FL_POSIX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 posix_lock_file_wait(file, pfLock);
811 FreeXid(xid);
812 return rc;
813}
814
815ssize_t cifs_user_write(struct file *file, const char __user *write_data,
816 size_t write_size, loff_t *poffset)
817{
818 int rc = 0;
819 unsigned int bytes_written = 0;
820 unsigned int total_written;
821 struct cifs_sb_info *cifs_sb;
822 struct cifsTconInfo *pTcon;
823 int xid, long_op;
824 struct cifsFileInfo *open_file;
825
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800826 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827
828 pTcon = cifs_sb->tcon;
829
830 /* cFYI(1,
831 (" write %d bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800832 *poffset, file->f_path.dentry->d_name.name)); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833
834 if (file->private_data == NULL)
835 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000836 open_file = (struct cifsFileInfo *) file->private_data;
Steve French50c2f752007-07-13 00:33:32 +0000837
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800840 if (*poffset > file->f_path.dentry->d_inode->i_size)
Steve French133672e2007-11-13 22:41:37 +0000841 long_op = CIFS_VLONG_OP; /* writes past EOF take long time */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842 else
Steve French133672e2007-11-13 22:41:37 +0000843 long_op = CIFS_LONG_OP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844
845 for (total_written = 0; write_size > total_written;
846 total_written += bytes_written) {
847 rc = -EAGAIN;
848 while (rc == -EAGAIN) {
849 if (file->private_data == NULL) {
850 /* file has been closed on us */
851 FreeXid(xid);
852 /* if we have gotten here we have written some data
853 and blocked, and the file has been freed on us while
854 we blocked so return what we managed to write */
855 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000856 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 if (open_file->closePend) {
858 FreeXid(xid);
859 if (total_written)
860 return total_written;
861 else
862 return -EBADF;
863 }
864 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 /* we could deadlock if we called
866 filemap_fdatawait from here so tell
867 reopen_file not to flush data to server
868 now */
Steve French3a9f4622007-04-04 17:10:24 +0000869 rc = cifs_reopen_file(file, FALSE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 if (rc != 0)
871 break;
872 }
873
874 rc = CIFSSMBWrite(xid, pTcon,
875 open_file->netfid,
876 min_t(const int, cifs_sb->wsize,
877 write_size - total_written),
878 *poffset, &bytes_written,
879 NULL, write_data + total_written, long_op);
880 }
881 if (rc || (bytes_written == 0)) {
882 if (total_written)
883 break;
884 else {
885 FreeXid(xid);
886 return rc;
887 }
888 } else
889 *poffset += bytes_written;
Steve French133672e2007-11-13 22:41:37 +0000890 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 15 seconds is plenty */
892 }
893
Steve Frencha4544342005-08-24 13:59:35 -0700894 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
896 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +0000897 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
898 struct inode *inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000899/* Do not update local mtime - server will set its actual value on write
900 * inode->i_ctime = inode->i_mtime =
Steve French3677db12007-02-26 16:46:11 +0000901 * current_fs_time(inode->i_sb);*/
902 if (total_written > 0) {
903 spin_lock(&inode->i_lock);
904 if (*poffset > file->f_path.dentry->d_inode->i_size)
905 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 *poffset);
Steve French3677db12007-02-26 16:46:11 +0000907 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000909 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 }
911 FreeXid(xid);
912 return total_written;
913}
914
915static ssize_t cifs_write(struct file *file, const char *write_data,
916 size_t write_size, loff_t *poffset)
917{
918 int rc = 0;
919 unsigned int bytes_written = 0;
920 unsigned int total_written;
921 struct cifs_sb_info *cifs_sb;
922 struct cifsTconInfo *pTcon;
923 int xid, long_op;
924 struct cifsFileInfo *open_file;
925
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800926 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927
928 pTcon = cifs_sb->tcon;
929
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000930 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800931 *poffset, file->f_path.dentry->d_name.name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700932
933 if (file->private_data == NULL)
934 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000935 open_file = (struct cifsFileInfo *)file->private_data;
Steve French50c2f752007-07-13 00:33:32 +0000936
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800939 if (*poffset > file->f_path.dentry->d_inode->i_size)
Steve French133672e2007-11-13 22:41:37 +0000940 long_op = CIFS_VLONG_OP; /* writes past EOF can be slow */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 else
Steve French133672e2007-11-13 22:41:37 +0000942 long_op = CIFS_LONG_OP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943
944 for (total_written = 0; write_size > total_written;
945 total_written += bytes_written) {
946 rc = -EAGAIN;
947 while (rc == -EAGAIN) {
948 if (file->private_data == NULL) {
949 /* file has been closed on us */
950 FreeXid(xid);
951 /* if we have gotten here we have written some data
952 and blocked, and the file has been freed on us
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000953 while we blocked so return what we managed to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 write */
955 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000956 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 if (open_file->closePend) {
958 FreeXid(xid);
959 if (total_written)
960 return total_written;
961 else
962 return -EBADF;
963 }
964 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 /* we could deadlock if we called
966 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000967 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 server now */
Steve French3a9f4622007-04-04 17:10:24 +0000969 rc = cifs_reopen_file(file, FALSE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 if (rc != 0)
971 break;
972 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000973 if (experimEnabled || (pTcon->ses->server &&
974 ((pTcon->ses->server->secMode &
Steve French08775832006-05-30 18:08:26 +0000975 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +0000976 == 0))) {
Steve French3e844692005-10-03 13:37:24 -0700977 struct kvec iov[2];
978 unsigned int len;
979
Steve French0ae0efa2005-10-10 10:57:19 -0700980 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -0700981 write_size - total_written);
982 /* iov[0] is reserved for smb header */
983 iov[1].iov_base = (char *)write_data +
984 total_written;
985 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500986 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -0700987 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500988 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -0700989 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500990 } else
Steve French60808232006-04-22 15:53:05 +0000991 rc = CIFSSMBWrite(xid, pTcon,
992 open_file->netfid,
993 min_t(const int, cifs_sb->wsize,
994 write_size - total_written),
995 *poffset, &bytes_written,
996 write_data + total_written,
997 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 }
999 if (rc || (bytes_written == 0)) {
1000 if (total_written)
1001 break;
1002 else {
1003 FreeXid(xid);
1004 return rc;
1005 }
1006 } else
1007 *poffset += bytes_written;
Steve French133672e2007-11-13 22:41:37 +00001008 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 15 seconds is plenty */
1010 }
1011
Steve Frencha4544342005-08-24 13:59:35 -07001012 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013
1014 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001015 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
Steve French004c46b2007-02-17 04:34:13 +00001016/*BB We could make this contingent on superblock ATIME flag too */
Steve French3677db12007-02-26 16:46:11 +00001017/* file->f_path.dentry->d_inode->i_ctime =
1018 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1019 if (total_written > 0) {
1020 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1021 if (*poffset > file->f_path.dentry->d_inode->i_size)
1022 i_size_write(file->f_path.dentry->d_inode,
1023 *poffset);
1024 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 }
Steve French3677db12007-02-26 16:46:11 +00001026 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 }
1028 FreeXid(xid);
1029 return total_written;
1030}
1031
Steve French630f3f0c2007-10-25 21:17:17 +00001032#ifdef CONFIG_CIFS_EXPERIMENTAL
1033struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1034{
1035 struct cifsFileInfo *open_file = NULL;
1036
1037 read_lock(&GlobalSMBSeslock);
1038 /* we could simply get the first_list_entry since write-only entries
1039 are always at the end of the list but since the first entry might
1040 have a close pending, we go through the whole list */
1041 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1042 if (open_file->closePend)
1043 continue;
1044 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1045 (open_file->pfile->f_flags & O_RDONLY))) {
1046 if (!open_file->invalidHandle) {
1047 /* found a good file */
1048 /* lock it so it will not be closed on us */
1049 atomic_inc(&open_file->wrtPending);
1050 read_unlock(&GlobalSMBSeslock);
1051 return open_file;
1052 } /* else might as well continue, and look for
1053 another, or simply have the caller reopen it
1054 again rather than trying to fix this handle */
1055 } else /* write only file */
1056 break; /* write only files are last so must be done */
1057 }
1058 read_unlock(&GlobalSMBSeslock);
1059 return NULL;
1060}
1061#endif
1062
Steve Frenchdd99cd82005-10-05 19:32:49 -07001063struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
Steve French6148a742005-10-05 12:23:19 -07001064{
1065 struct cifsFileInfo *open_file;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001066 int rc;
Steve French6148a742005-10-05 12:23:19 -07001067
Steve French60808232006-04-22 15:53:05 +00001068 /* Having a null inode here (because mapping->host was set to zero by
1069 the VFS or MM) should not happen but we had reports of on oops (due to
1070 it being zero) during stress testcases so we need to check for it */
1071
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001072 if (cifs_inode == NULL) {
1073 cERROR(1, ("Null inode passed to cifs_writeable_file"));
Steve French60808232006-04-22 15:53:05 +00001074 dump_stack();
1075 return NULL;
1076 }
1077
Steve French6148a742005-10-05 12:23:19 -07001078 read_lock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001079refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001080 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1081 if (open_file->closePend)
1082 continue;
1083 if (open_file->pfile &&
1084 ((open_file->pfile->f_flags & O_RDWR) ||
1085 (open_file->pfile->f_flags & O_WRONLY))) {
Steve French23e7dd72005-10-20 13:44:56 -07001086 atomic_inc(&open_file->wrtPending);
Steve French9b22b0b2007-10-02 01:11:08 +00001087
1088 if (!open_file->invalidHandle) {
1089 /* found a good writable file */
1090 read_unlock(&GlobalSMBSeslock);
1091 return open_file;
1092 }
Steve French8840dee2007-11-16 23:05:52 +00001093
Steve French6148a742005-10-05 12:23:19 -07001094 read_unlock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001095 /* Had to unlock since following call can block */
1096 rc = cifs_reopen_file(open_file->pfile, FALSE);
Steve French8840dee2007-11-16 23:05:52 +00001097 if (!rc) {
Steve French9b22b0b2007-10-02 01:11:08 +00001098 if (!open_file->closePend)
1099 return open_file;
1100 else { /* start over in case this was deleted */
1101 /* since the list could be modified */
Steve French37c0eb42005-10-05 14:50:29 -07001102 read_lock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +00001103 atomic_dec(&open_file->wrtPending);
Steve French9b22b0b2007-10-02 01:11:08 +00001104 goto refind_writable;
Steve French37c0eb42005-10-05 14:50:29 -07001105 }
1106 }
Steve French9b22b0b2007-10-02 01:11:08 +00001107
1108 /* if it fails, try another handle if possible -
1109 (we can not do this if closePending since
1110 loop could be modified - in which case we
1111 have to start at the beginning of the list
1112 again. Note that it would be bad
1113 to hold up writepages here (rather than
1114 in caller) with continuous retries */
1115 cFYI(1, ("wp failed on reopen file"));
1116 read_lock(&GlobalSMBSeslock);
1117 /* can not use this handle, no write
1118 pending on this one after all */
1119 atomic_dec(&open_file->wrtPending);
Steve French8840dee2007-11-16 23:05:52 +00001120
Steve French9b22b0b2007-10-02 01:11:08 +00001121 if (open_file->closePend) /* list could have changed */
1122 goto refind_writable;
1123 /* else we simply continue to the next entry. Thus
1124 we do not loop on reopen errors. If we
1125 can not reopen the file, for example if we
1126 reconnected to a server with another client
1127 racing to delete or lock the file we would not
1128 make progress if we restarted before the beginning
1129 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001130 }
1131 }
1132 read_unlock(&GlobalSMBSeslock);
1133 return NULL;
1134}
1135
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1137{
1138 struct address_space *mapping = page->mapping;
1139 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1140 char *write_data;
1141 int rc = -EFAULT;
1142 int bytes_written = 0;
1143 struct cifs_sb_info *cifs_sb;
1144 struct cifsTconInfo *pTcon;
1145 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001146 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147
1148 if (!mapping || !mapping->host)
1149 return -EFAULT;
1150
1151 inode = page->mapping->host;
1152 cifs_sb = CIFS_SB(inode->i_sb);
1153 pTcon = cifs_sb->tcon;
1154
1155 offset += (loff_t)from;
1156 write_data = kmap(page);
1157 write_data += from;
1158
1159 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1160 kunmap(page);
1161 return -EIO;
1162 }
1163
1164 /* racing with truncate? */
1165 if (offset > mapping->host->i_size) {
1166 kunmap(page);
1167 return 0; /* don't care */
1168 }
1169
1170 /* check to make sure that we are not extending the file */
1171 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001172 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
Steve French6148a742005-10-05 12:23:19 -07001174 open_file = find_writable_file(CIFS_I(mapping->host));
1175 if (open_file) {
1176 bytes_written = cifs_write(open_file->pfile, write_data,
1177 to-from, &offset);
Steve French23e7dd72005-10-20 13:44:56 -07001178 atomic_dec(&open_file->wrtPending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001180 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001181 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001182 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001183 else if (bytes_written < 0)
1184 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001185 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 cFYI(1, ("No writeable filehandles for inode"));
1187 rc = -EIO;
1188 }
1189
1190 kunmap(page);
1191 return rc;
1192}
1193
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001195 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196{
Steve French37c0eb42005-10-05 14:50:29 -07001197 struct backing_dev_info *bdi = mapping->backing_dev_info;
1198 unsigned int bytes_to_write;
1199 unsigned int bytes_written;
1200 struct cifs_sb_info *cifs_sb;
1201 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001202 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001203 pgoff_t index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001204 int range_whole = 0;
1205 struct kvec *iov;
Steve French84d2f072005-10-12 15:32:05 -07001206 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001207 int n_iov = 0;
1208 pgoff_t next;
1209 int nr_pages;
1210 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001211 struct cifsFileInfo *open_file;
Steve French37c0eb42005-10-05 14:50:29 -07001212 struct page *page;
1213 struct pagevec pvec;
1214 int rc = 0;
1215 int scanned = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001216 int xid;
1217
Steve French37c0eb42005-10-05 14:50:29 -07001218 cifs_sb = CIFS_SB(mapping->host->i_sb);
Steve French50c2f752007-07-13 00:33:32 +00001219
Steve French37c0eb42005-10-05 14:50:29 -07001220 /*
1221 * If wsize is smaller that the page cache size, default to writing
1222 * one page at a time via cifs_writepage
1223 */
1224 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1225 return generic_writepages(mapping, wbc);
1226
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001227 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1228 if (cifs_sb->tcon->ses->server->secMode &
1229 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1230 if (!experimEnabled)
Steve French60808232006-04-22 15:53:05 +00001231 return generic_writepages(mapping, wbc);
Steve French4a771182005-10-05 15:14:33 -07001232
Steve French9a0c8232007-02-02 04:21:57 +00001233 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001234 if (iov == NULL)
Steve French9a0c8232007-02-02 04:21:57 +00001235 return generic_writepages(mapping, wbc);
1236
1237
Steve French37c0eb42005-10-05 14:50:29 -07001238 /*
1239 * BB: Is this meaningful for a non-block-device file system?
1240 * If it is, we should test it again after we do I/O
1241 */
1242 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1243 wbc->encountered_congestion = 1;
Steve French9a0c8232007-02-02 04:21:57 +00001244 kfree(iov);
Steve French37c0eb42005-10-05 14:50:29 -07001245 return 0;
1246 }
1247
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248 xid = GetXid();
1249
Steve French37c0eb42005-10-05 14:50:29 -07001250 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001251 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001252 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001253 end = -1;
1254 } else {
1255 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1256 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1257 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1258 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001259 scanned = 1;
1260 }
1261retry:
1262 while (!done && (index <= end) &&
1263 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1264 PAGECACHE_TAG_DIRTY,
1265 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1266 int first;
1267 unsigned int i;
1268
Steve French37c0eb42005-10-05 14:50:29 -07001269 first = -1;
1270 next = 0;
1271 n_iov = 0;
1272 bytes_to_write = 0;
1273
1274 for (i = 0; i < nr_pages; i++) {
1275 page = pvec.pages[i];
1276 /*
1277 * At this point we hold neither mapping->tree_lock nor
1278 * lock on the page itself: the page may be truncated or
1279 * invalidated (changing page->mapping to NULL), or even
1280 * swizzled back from swapper_space to tmpfs file
1281 * mapping
1282 */
1283
1284 if (first < 0)
1285 lock_page(page);
1286 else if (TestSetPageLocked(page))
1287 break;
1288
1289 if (unlikely(page->mapping != mapping)) {
1290 unlock_page(page);
1291 break;
1292 }
1293
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001294 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001295 done = 1;
1296 unlock_page(page);
1297 break;
1298 }
1299
1300 if (next && (page->index != next)) {
1301 /* Not next consecutive page */
1302 unlock_page(page);
1303 break;
1304 }
1305
1306 if (wbc->sync_mode != WB_SYNC_NONE)
1307 wait_on_page_writeback(page);
1308
1309 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001310 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001311 unlock_page(page);
1312 break;
1313 }
Steve French84d2f072005-10-12 15:32:05 -07001314
Linus Torvaldscb876f42006-12-23 16:19:07 -08001315 /*
1316 * This actually clears the dirty bit in the radix tree.
1317 * See cifs_writepage() for more commentary.
1318 */
1319 set_page_writeback(page);
1320
Steve French84d2f072005-10-12 15:32:05 -07001321 if (page_offset(page) >= mapping->host->i_size) {
1322 done = 1;
1323 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001324 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001325 break;
1326 }
1327
Steve French37c0eb42005-10-05 14:50:29 -07001328 /*
1329 * BB can we get rid of this? pages are held by pvec
1330 */
1331 page_cache_get(page);
1332
Steve French84d2f072005-10-12 15:32:05 -07001333 len = min(mapping->host->i_size - page_offset(page),
1334 (loff_t)PAGE_CACHE_SIZE);
1335
Steve French37c0eb42005-10-05 14:50:29 -07001336 /* reserve iov[0] for the smb header */
1337 n_iov++;
1338 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001339 iov[n_iov].iov_len = len;
1340 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001341
1342 if (first < 0) {
1343 first = i;
1344 offset = page_offset(page);
1345 }
1346 next = page->index + 1;
1347 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1348 break;
1349 }
1350 if (n_iov) {
Steve French23e7dd72005-10-20 13:44:56 -07001351 /* Search for a writable handle every time we call
1352 * CIFSSMBWrite2. We can't rely on the last handle
1353 * we used to still be valid
1354 */
1355 open_file = find_writable_file(CIFS_I(mapping->host));
1356 if (!open_file) {
1357 cERROR(1, ("No writable handles for inode"));
1358 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001359 } else {
Steve French23e7dd72005-10-20 13:44:56 -07001360 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1361 open_file->netfid,
1362 bytes_to_write, offset,
1363 &bytes_written, iov, n_iov,
Steve French133672e2007-11-13 22:41:37 +00001364 CIFS_LONG_OP);
Steve French23e7dd72005-10-20 13:44:56 -07001365 atomic_dec(&open_file->wrtPending);
1366 if (rc || bytes_written < bytes_to_write) {
Steve French63135e02007-07-17 17:34:02 +00001367 cERROR(1, ("Write2 ret %d, wrote %d",
Steve French23e7dd72005-10-20 13:44:56 -07001368 rc, bytes_written));
1369 /* BB what if continued retry is
1370 requested via mount flags? */
Jeff Laytoncea21802007-11-20 23:19:03 +00001371 if (rc == -ENOSPC)
1372 set_bit(AS_ENOSPC, &mapping->flags);
1373 else
1374 set_bit(AS_EIO, &mapping->flags);
Steve French23e7dd72005-10-20 13:44:56 -07001375 } else {
1376 cifs_stats_bytes_written(cifs_sb->tcon,
1377 bytes_written);
1378 }
Steve French37c0eb42005-10-05 14:50:29 -07001379 }
1380 for (i = 0; i < n_iov; i++) {
1381 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001382 /* Should we also set page error on
1383 success rc but too little data written? */
1384 /* BB investigate retry logic on temporary
1385 server crash cases and how recovery works
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001386 when page marked as error */
1387 if (rc)
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001388 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001389 kunmap(page);
1390 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001391 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001392 page_cache_release(page);
1393 }
1394 if ((wbc->nr_to_write -= n_iov) <= 0)
1395 done = 1;
1396 index = next;
1397 }
1398 pagevec_release(&pvec);
1399 }
1400 if (!scanned && !done) {
1401 /*
1402 * We hit the last page and there is more work to be done: wrap
1403 * back to the start of the file
1404 */
1405 scanned = 1;
1406 index = 0;
1407 goto retry;
1408 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001409 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001410 mapping->writeback_index = index;
1411
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001413 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 return rc;
1415}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001417static int cifs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418{
1419 int rc = -EFAULT;
1420 int xid;
1421
1422 xid = GetXid();
1423/* BB add check for wbc flags */
1424 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001425 if (!PageUptodate(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 cFYI(1, ("ppw - page not up to date"));
Linus Torvaldscb876f42006-12-23 16:19:07 -08001427
1428 /*
1429 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1430 *
1431 * A writepage() implementation always needs to do either this,
1432 * or re-dirty the page with "redirty_page_for_writepage()" in
1433 * the case of a failure.
1434 *
1435 * Just unlocking the page will cause the radix tree tag-bits
1436 * to fail to update with the state of the page correctly.
1437 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001438 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1440 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1441 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001442 end_page_writeback(page);
1443 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 FreeXid(xid);
1445 return rc;
1446}
1447
1448static int cifs_commit_write(struct file *file, struct page *page,
1449 unsigned offset, unsigned to)
1450{
1451 int xid;
1452 int rc = 0;
1453 struct inode *inode = page->mapping->host;
1454 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1455 char *page_data;
1456
1457 xid = GetXid();
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001458 cFYI(1, ("commit write for page %p up to position %lld for %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 page, position, to));
Steve French3677db12007-02-26 16:46:11 +00001460 spin_lock(&inode->i_lock);
Steve Frenchad7a2922008-02-07 23:25:02 +00001461 if (position > inode->i_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 i_size_write(inode, position);
Steve Frenchad7a2922008-02-07 23:25:02 +00001463
Steve French3677db12007-02-26 16:46:11 +00001464 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 if (!PageUptodate(page)) {
1466 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1467 /* can not rely on (or let) writepage write this data */
1468 if (to < offset) {
1469 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1470 offset, to));
1471 FreeXid(xid);
1472 return rc;
1473 }
1474 /* this is probably better than directly calling
1475 partialpage_write since in this function the file handle is
1476 known which we might as well leverage */
1477 /* BB check if anything else missing out of ppw
1478 such as updating last write time */
1479 page_data = kmap(page);
1480 rc = cifs_write(file, page_data + offset, to-offset,
1481 &position);
1482 if (rc > 0)
1483 rc = 0;
1484 /* else if (rc < 0) should we set writebehind rc? */
1485 kunmap(page);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001486 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 set_page_dirty(page);
1488 }
1489
1490 FreeXid(xid);
1491 return rc;
1492}
1493
1494int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1495{
1496 int xid;
1497 int rc = 0;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001498 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499
1500 xid = GetXid();
1501
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001502 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503 dentry->d_name.name, datasync));
Steve French50c2f752007-07-13 00:33:32 +00001504
Jeff Laytoncea21802007-11-20 23:19:03 +00001505 rc = filemap_write_and_wait(inode->i_mapping);
1506 if (rc == 0) {
1507 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001509 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 FreeXid(xid);
1511 return rc;
1512}
1513
NeilBrown3978d7172006-03-26 01:37:17 -08001514/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515{
1516 struct address_space *mapping;
1517 struct inode *inode;
1518 unsigned long index = page->index;
1519 unsigned int rpages = 0;
1520 int rc = 0;
1521
1522 cFYI(1, ("sync page %p",page));
1523 mapping = page->mapping;
1524 if (!mapping)
1525 return 0;
1526 inode = mapping->host;
1527 if (!inode)
NeilBrown3978d7172006-03-26 01:37:17 -08001528 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001530/* fill in rpages then
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1532
Steve French26a21b92006-05-31 18:05:34 +00001533/* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534
NeilBrown3978d7172006-03-26 01:37:17 -08001535#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 if (rc < 0)
1537 return rc;
1538 return 0;
NeilBrown3978d7172006-03-26 01:37:17 -08001539#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540} */
1541
1542/*
1543 * As file closes, flush all cached write data for this inode checking
1544 * for write behind errors.
1545 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001546int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001548 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 int rc = 0;
1550
1551 /* Rather than do the steps manually:
1552 lock the inode for writing
1553 loop through pages looking for write behind data (dirty pages)
1554 coalesce into contiguous 16K (or smaller) chunks to write to server
1555 send to server (prefer in parallel)
1556 deal with writebehind errors
1557 unlock inode for writing
1558 filemapfdatawrite appears easier for the time being */
1559
1560 rc = filemap_fdatawrite(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +00001561 /* reset wb rc if we were able to write out dirty pages */
1562 if (!rc) {
1563 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001565 }
Steve French50c2f752007-07-13 00:33:32 +00001566
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001567 cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001568
1569 return rc;
1570}
1571
1572ssize_t cifs_user_read(struct file *file, char __user *read_data,
1573 size_t read_size, loff_t *poffset)
1574{
1575 int rc = -EACCES;
1576 unsigned int bytes_read = 0;
1577 unsigned int total_read = 0;
1578 unsigned int current_read_size;
1579 struct cifs_sb_info *cifs_sb;
1580 struct cifsTconInfo *pTcon;
1581 int xid;
1582 struct cifsFileInfo *open_file;
1583 char *smb_read_data;
1584 char __user *current_offset;
1585 struct smb_com_read_rsp *pSMBr;
1586
1587 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001588 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 pTcon = cifs_sb->tcon;
1590
1591 if (file->private_data == NULL) {
1592 FreeXid(xid);
1593 return -EBADF;
1594 }
1595 open_file = (struct cifsFileInfo *)file->private_data;
1596
Steve Frenchad7a2922008-02-07 23:25:02 +00001597 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001598 cFYI(1, ("attempting read on write only file instance"));
Steve Frenchad7a2922008-02-07 23:25:02 +00001599
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 for (total_read = 0, current_offset = read_data;
1601 read_size > total_read;
1602 total_read += bytes_read, current_offset += bytes_read) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001603 current_read_size = min_t(const int, read_size - total_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 cifs_sb->rsize);
1605 rc = -EAGAIN;
1606 smb_read_data = NULL;
1607 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001608 int buf_type = CIFS_NO_BUFFER;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001609 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 (!open_file->closePend)) {
Steve French3a9f4622007-04-04 17:10:24 +00001611 rc = cifs_reopen_file(file, TRUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 if (rc != 0)
1613 break;
1614 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001615 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001616 open_file->netfid,
1617 current_read_size, *poffset,
1618 &bytes_read, &smb_read_data,
1619 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001622 if (copy_to_user(current_offset,
1623 smb_read_data +
1624 4 /* RFC1001 length field */ +
1625 le16_to_cpu(pSMBr->DataOffset),
Steve Frenchad7a2922008-02-07 23:25:02 +00001626 bytes_read))
Steve French93544cc2006-02-14 22:30:52 -06001627 rc = -EFAULT;
Steve French93544cc2006-02-14 22:30:52 -06001628
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001629 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001630 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001631 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001632 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 smb_read_data = NULL;
1634 }
1635 }
1636 if (rc || (bytes_read == 0)) {
1637 if (total_read) {
1638 break;
1639 } else {
1640 FreeXid(xid);
1641 return rc;
1642 }
1643 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001644 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 *poffset += bytes_read;
1646 }
1647 }
1648 FreeXid(xid);
1649 return total_read;
1650}
1651
1652
1653static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1654 loff_t *poffset)
1655{
1656 int rc = -EACCES;
1657 unsigned int bytes_read = 0;
1658 unsigned int total_read;
1659 unsigned int current_read_size;
1660 struct cifs_sb_info *cifs_sb;
1661 struct cifsTconInfo *pTcon;
1662 int xid;
1663 char *current_offset;
1664 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001665 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666
1667 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001668 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 pTcon = cifs_sb->tcon;
1670
1671 if (file->private_data == NULL) {
1672 FreeXid(xid);
1673 return -EBADF;
1674 }
1675 open_file = (struct cifsFileInfo *)file->private_data;
1676
1677 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1678 cFYI(1, ("attempting read on write only file instance"));
1679
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001680 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 read_size > total_read;
1682 total_read += bytes_read, current_offset += bytes_read) {
1683 current_read_size = min_t(const int, read_size - total_read,
1684 cifs_sb->rsize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001685 /* For windows me and 9x we do not want to request more
1686 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001687 if ((pTcon->ses) &&
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001688 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1689 current_read_size = min_t(const int, current_read_size,
1690 pTcon->ses->server->maxBuf - 128);
1691 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 rc = -EAGAIN;
1693 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001694 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 (!open_file->closePend)) {
Steve French3a9f4622007-04-04 17:10:24 +00001696 rc = cifs_reopen_file(file, TRUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 if (rc != 0)
1698 break;
1699 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001700 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001701 open_file->netfid,
1702 current_read_size, *poffset,
1703 &bytes_read, &current_offset,
1704 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 }
1706 if (rc || (bytes_read == 0)) {
1707 if (total_read) {
1708 break;
1709 } else {
1710 FreeXid(xid);
1711 return rc;
1712 }
1713 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001714 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 *poffset += bytes_read;
1716 }
1717 }
1718 FreeXid(xid);
1719 return total_read;
1720}
1721
1722int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1723{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001724 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 int rc, xid;
1726
1727 xid = GetXid();
1728 rc = cifs_revalidate(dentry);
1729 if (rc) {
1730 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1731 FreeXid(xid);
1732 return rc;
1733 }
1734 rc = generic_file_mmap(file, vma);
1735 FreeXid(xid);
1736 return rc;
1737}
1738
1739
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001740static void cifs_copy_cache_pages(struct address_space *mapping,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 struct list_head *pages, int bytes_read, char *data,
1742 struct pagevec *plru_pvec)
1743{
1744 struct page *page;
1745 char *target;
1746
1747 while (bytes_read > 0) {
1748 if (list_empty(pages))
1749 break;
1750
1751 page = list_entry(pages->prev, struct page, lru);
1752 list_del(&page->lru);
1753
1754 if (add_to_page_cache(page, mapping, page->index,
1755 GFP_KERNEL)) {
1756 page_cache_release(page);
1757 cFYI(1, ("Add page cache failed"));
Steve French3079ca62005-06-09 14:44:07 -07001758 data += PAGE_CACHE_SIZE;
1759 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 continue;
1761 }
1762
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001763 target = kmap_atomic(page, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764
1765 if (PAGE_CACHE_SIZE > bytes_read) {
1766 memcpy(target, data, bytes_read);
1767 /* zero the tail end of this partial page */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001768 memset(target + bytes_read, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 PAGE_CACHE_SIZE - bytes_read);
1770 bytes_read = 0;
1771 } else {
1772 memcpy(target, data, PAGE_CACHE_SIZE);
1773 bytes_read -= PAGE_CACHE_SIZE;
1774 }
1775 kunmap_atomic(target, KM_USER0);
1776
1777 flush_dcache_page(page);
1778 SetPageUptodate(page);
1779 unlock_page(page);
1780 if (!pagevec_add(plru_pvec, page))
1781 __pagevec_lru_add(plru_pvec);
1782 data += PAGE_CACHE_SIZE;
1783 }
1784 return;
1785}
1786
1787static int cifs_readpages(struct file *file, struct address_space *mapping,
1788 struct list_head *page_list, unsigned num_pages)
1789{
1790 int rc = -EACCES;
1791 int xid;
1792 loff_t offset;
1793 struct page *page;
1794 struct cifs_sb_info *cifs_sb;
1795 struct cifsTconInfo *pTcon;
Steve French2c2130e2007-10-12 19:10:28 +00001796 unsigned int bytes_read = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001797 unsigned int read_size, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 char *smb_read_data = NULL;
1799 struct smb_com_read_rsp *pSMBr;
1800 struct pagevec lru_pvec;
1801 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001802 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803
1804 xid = GetXid();
1805 if (file->private_data == NULL) {
1806 FreeXid(xid);
1807 return -EBADF;
1808 }
1809 open_file = (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001810 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 pTcon = cifs_sb->tcon;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001812
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 pagevec_init(&lru_pvec, 0);
Steve French90c81e02008-02-12 20:32:36 +00001814 cFYI(DBG2, ("rpages: num pages %d", num_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 for (i = 0; i < num_pages; ) {
1816 unsigned contig_pages;
1817 struct page *tmp_page;
1818 unsigned long expected_index;
1819
1820 if (list_empty(page_list))
1821 break;
1822
1823 page = list_entry(page_list->prev, struct page, lru);
1824 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1825
1826 /* count adjacent pages that we will read into */
1827 contig_pages = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001828 expected_index =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 list_entry(page_list->prev, struct page, lru)->index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001830 list_for_each_entry_reverse(tmp_page, page_list, lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 if (tmp_page->index == expected_index) {
1832 contig_pages++;
1833 expected_index++;
1834 } else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001835 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 }
1837 if (contig_pages + i > num_pages)
1838 contig_pages = num_pages - i;
1839
1840 /* for reads over a certain size could initiate async
1841 read ahead */
1842
1843 read_size = contig_pages * PAGE_CACHE_SIZE;
1844 /* Read size needs to be in multiples of one page */
1845 read_size = min_t(const unsigned int, read_size,
1846 cifs_sb->rsize & PAGE_CACHE_MASK);
Steve French90c81e02008-02-12 20:32:36 +00001847 cFYI(DBG2, ("rpages: read size 0x%x contiguous pages %d",
Steve French75865f8c2007-06-24 18:30:48 +00001848 read_size, contig_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 rc = -EAGAIN;
1850 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001851 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 (!open_file->closePend)) {
Steve French3a9f4622007-04-04 17:10:24 +00001853 rc = cifs_reopen_file(file, TRUE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 if (rc != 0)
1855 break;
1856 }
1857
Steve Frenchbfa0d752005-08-31 21:50:37 -07001858 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001859 open_file->netfid,
1860 read_size, offset,
1861 &bytes_read, &smb_read_data,
1862 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001863 /* BB more RC checks ? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001864 if (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001866 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001867 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001868 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001869 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870 smb_read_data = NULL;
1871 }
1872 }
1873 }
1874 if ((rc < 0) || (smb_read_data == NULL)) {
1875 cFYI(1, ("Read error in readpages: %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 break;
1877 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08001878 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1880 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1881 smb_read_data + 4 /* RFC1001 hdr */ +
1882 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1883
1884 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha4544342005-08-24 13:59:35 -07001885 cifs_stats_bytes_read(pTcon, bytes_read);
Steve French2c2130e2007-10-12 19:10:28 +00001886 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 i++; /* account for partial page */
1888
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001889 /* server copy of file can have smaller size
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 than client */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001891 /* BB do we need to verify this common case ?
1892 this case is ok - if we are at server EOF
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 we will hit it on next read */
1894
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08001895 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 }
1897 } else {
1898 cFYI(1, ("No bytes read (%d) at offset %lld . "
1899 "Cleaning remaining pages from readahead list",
1900 bytes_read, offset));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001901 /* BB turn off caching and do new lookup on
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 break;
1904 }
1905 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001906 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001907 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001908 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001909 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 smb_read_data = NULL;
1911 }
1912 bytes_read = 0;
1913 }
1914
1915 pagevec_lru_add(&lru_pvec);
1916
1917/* need to free smb_read_data buf before exit */
1918 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001919 if (buf_type == CIFS_SMALL_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08001920 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001921 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08001922 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 smb_read_data = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001924 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925
1926 FreeXid(xid);
1927 return rc;
1928}
1929
1930static int cifs_readpage_worker(struct file *file, struct page *page,
1931 loff_t *poffset)
1932{
1933 char *read_data;
1934 int rc;
1935
1936 page_cache_get(page);
1937 read_data = kmap(page);
1938 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001939
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001941
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 if (rc < 0)
1943 goto io_error;
1944 else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001945 cFYI(1, ("Bytes read %d", rc));
1946
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001947 file->f_path.dentry->d_inode->i_atime =
1948 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001949
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 if (PAGE_CACHE_SIZE > rc)
1951 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1952
1953 flush_dcache_page(page);
1954 SetPageUptodate(page);
1955 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001956
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001958 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 page_cache_release(page);
1960 return rc;
1961}
1962
1963static int cifs_readpage(struct file *file, struct page *page)
1964{
1965 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1966 int rc = -EACCES;
1967 int xid;
1968
1969 xid = GetXid();
1970
1971 if (file->private_data == NULL) {
1972 FreeXid(xid);
1973 return -EBADF;
1974 }
1975
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001976 cFYI(1, ("readpage %p at offset %d 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 page, (int)offset, (int)offset));
1978
1979 rc = cifs_readpage_worker(file, page, &offset);
1980
1981 unlock_page(page);
1982
1983 FreeXid(xid);
1984 return rc;
1985}
1986
Steve Frencha403a0a2007-07-26 15:54:16 +00001987static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
1988{
1989 struct cifsFileInfo *open_file;
1990
1991 read_lock(&GlobalSMBSeslock);
1992 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1993 if (open_file->closePend)
1994 continue;
1995 if (open_file->pfile &&
1996 ((open_file->pfile->f_flags & O_RDWR) ||
1997 (open_file->pfile->f_flags & O_WRONLY))) {
1998 read_unlock(&GlobalSMBSeslock);
1999 return 1;
2000 }
2001 }
2002 read_unlock(&GlobalSMBSeslock);
2003 return 0;
2004}
2005
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006/* We do not want to update the file size from server for inodes
2007 open for write - to avoid races with writepage extending
2008 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002009 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010 but this is tricky to do without racing with writebehind
2011 page caching in the current Linux kernel design */
Steve French7ba52632007-02-08 18:14:13 +00002012int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013{
Steve Frencha403a0a2007-07-26 15:54:16 +00002014 if (!cifsInode)
2015 return 1;
Steve French23e7dd72005-10-20 13:44:56 -07002016
Steve Frencha403a0a2007-07-26 15:54:16 +00002017 if (is_inode_writable(cifsInode)) {
2018 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08002019 struct cifs_sb_info *cifs_sb;
2020
Steve Frenchc32a0b62006-01-12 14:41:28 -08002021 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00002022 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002023 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08002024 we can change size safely */
2025 return 1;
2026 }
2027
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002028 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French7ba52632007-02-08 18:14:13 +00002029 return 1;
2030
Steve French6148a742005-10-05 12:23:19 -07002031 return 0;
Steve French23e7dd72005-10-20 13:44:56 -07002032 } else
Steve French6148a742005-10-05 12:23:19 -07002033 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002034}
2035
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036static int cifs_prepare_write(struct file *file, struct page *page,
2037 unsigned from, unsigned to)
2038{
2039 int rc = 0;
Steve French8a236262007-03-06 00:31:00 +00002040 loff_t i_size;
2041 loff_t offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002043 cFYI(1, ("prepare write for page %p from %d to %d", page, from, to));
Steve French8a236262007-03-06 00:31:00 +00002044 if (PageUptodate(page))
2045 return 0;
2046
2047 /* If we are writing a full page it will be up to date,
2048 no need to read from the server */
2049 if ((to == PAGE_CACHE_SIZE) && (from == 0)) {
2050 SetPageUptodate(page);
2051 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052 }
2053
Steve French8a236262007-03-06 00:31:00 +00002054 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2055 i_size = i_size_read(page->mapping->host);
2056
2057 if ((offset >= i_size) ||
2058 ((from == 0) && (offset + to) >= i_size)) {
2059 /*
2060 * We don't need to read data beyond the end of the file.
2061 * zero it, and set the page uptodate
2062 */
Nate88038632007-07-16 15:45:13 +00002063 simple_prepare_write(file, page, from, to);
Steve French8a236262007-03-06 00:31:00 +00002064 SetPageUptodate(page);
2065 } else if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2066 /* might as well read a page, it is fast enough */
2067 rc = cifs_readpage_worker(file, page, &offset);
2068 } else {
2069 /* we could try using another file handle if there is one -
2070 but how would we lock it to prevent close of that handle
2071 racing with this read? In any case
2072 this will be written out by commit_write so is fine */
2073 }
2074
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002075 /* we do not need to pass errors back
2076 e.g. if we do not have read access to the file
Steve French8a236262007-03-06 00:31:00 +00002077 because cifs_commit_write will do the right thing. -- shaggy */
2078
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079 return 0;
2080}
2081
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002082const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 .readpage = cifs_readpage,
2084 .readpages = cifs_readpages,
2085 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002086 .writepages = cifs_writepages,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 .prepare_write = cifs_prepare_write,
2088 .commit_write = cifs_commit_write,
2089 .set_page_dirty = __set_page_dirty_nobuffers,
2090 /* .sync_page = cifs_sync_page, */
2091 /* .direct_IO = */
2092};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002093
2094/*
2095 * cifs_readpages requires the server to support a buffer large enough to
2096 * contain the header plus one complete page of data. Otherwise, we need
2097 * to leave cifs_readpages out of the address space operations.
2098 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002099const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002100 .readpage = cifs_readpage,
2101 .writepage = cifs_writepage,
2102 .writepages = cifs_writepages,
2103 .prepare_write = cifs_prepare_write,
2104 .commit_write = cifs_commit_write,
2105 .set_page_dirty = __set_page_dirty_nobuffers,
2106 /* .sync_page = cifs_sync_page, */
2107 /* .direct_IO = */
2108};