blob: cbefe1f1f9fe2c4c92e97e8b4999039ba5c15b99 [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;
Steve French4b18f2a2008-04-29 00:06:05 +000054 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
Jeff Laytone10f7b52008-05-14 10:21:33 -070078 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
79 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
80 FILE_READ_DATA);
81
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083}
84
85static inline int cifs_get_disposition(unsigned int flags)
86{
87 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
88 return FILE_CREATE;
89 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
90 return FILE_OVERWRITE_IF;
91 else if ((flags & O_CREAT) == O_CREAT)
92 return FILE_OPEN_IF;
Steve French55aa2e02006-05-30 18:09:31 +000093 else if ((flags & O_TRUNC) == O_TRUNC)
94 return FILE_OVERWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 else
96 return FILE_OPEN;
97}
98
99/* all arguments to this function must be checked for validity in caller */
100static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
101 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
102 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
103 char *full_path, int xid)
104{
105 struct timespec temp;
106 int rc;
107
108 /* want handles we can use to read with first
109 in the list so we do not have to walk the
110 list to search for one in prepare_write */
111 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000112 list_add_tail(&pCifsFile->flist,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 &pCifsInode->openFileList);
114 } else {
115 list_add(&pCifsFile->flist,
116 &pCifsInode->openFileList);
117 }
118 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 if (pCifsInode->clientCanCacheRead) {
120 /* we have the inode open somewhere else
121 no need to discard cache data */
122 goto client_can_cache;
123 }
124
125 /* BB need same check in cifs_create too? */
126 /* if not oplocked, invalidate inode pages if mtime or file
127 size changed */
128 temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800129 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
130 (file->f_path.dentry->d_inode->i_size ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 (loff_t)le64_to_cpu(buf->EndOfFile))) {
132 cFYI(1, ("inode unchanged on server"));
133 } else {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800134 if (file->f_path.dentry->d_inode->i_mapping) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 /* BB no need to lock inode until after invalidate
136 since namei code should already have it locked? */
Jeff Laytoncea21802007-11-20 23:19:03 +0000137 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
138 if (rc != 0)
139 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 }
141 cFYI(1, ("invalidating remote inode since open detected it "
142 "changed"));
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800143 invalidate_remote_inode(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 }
145
146client_can_cache:
Steve Frenchc18c8422007-07-18 23:21:09 +0000147 if (pTcon->unix_ext)
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800148 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 full_path, inode->i_sb, xid);
150 else
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800151 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
Steve French8b1327f2008-03-14 22:37:16 +0000152 full_path, buf, inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000155 pCifsInode->clientCanCacheAll = true;
156 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800158 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 } else if ((*oplock & 0xF) == OPLOCK_READ)
Steve French4b18f2a2008-04-29 00:06:05 +0000160 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
162 return rc;
163}
164
165int cifs_open(struct inode *inode, struct file *file)
166{
167 int rc = -EACCES;
168 int xid, oplock;
169 struct cifs_sb_info *cifs_sb;
170 struct cifsTconInfo *pTcon;
171 struct cifsFileInfo *pCifsFile;
172 struct cifsInodeInfo *pCifsInode;
173 struct list_head *tmp;
174 char *full_path = NULL;
175 int desiredAccess;
176 int disposition;
177 __u16 netfid;
178 FILE_ALL_INFO *buf = NULL;
179
180 xid = GetXid();
181
182 cifs_sb = CIFS_SB(inode->i_sb);
183 pTcon = cifs_sb->tcon;
184
185 if (file->f_flags & O_CREAT) {
186 /* search inode for this file and fill in file->private_data */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800187 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 read_lock(&GlobalSMBSeslock);
189 list_for_each(tmp, &pCifsInode->openFileList) {
190 pCifsFile = list_entry(tmp, struct cifsFileInfo,
191 flist);
192 if ((pCifsFile->pfile == NULL) &&
193 (pCifsFile->pid == current->tgid)) {
194 /* mode set in cifs_create */
195
196 /* needed for writepage */
197 pCifsFile->pfile = file;
Steve French50c2f752007-07-13 00:33:32 +0000198
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 file->private_data = pCifsFile;
200 break;
201 }
202 }
203 read_unlock(&GlobalSMBSeslock);
204 if (file->private_data != NULL) {
205 rc = 0;
206 FreeXid(xid);
207 return rc;
208 } else {
209 if (file->f_flags & O_EXCL)
210 cERROR(1, ("could not find file instance for "
Steve French26a21b92006-05-31 18:05:34 +0000211 "new file %p", file));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 }
213 }
214
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800215 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 if (full_path == NULL) {
217 FreeXid(xid);
218 return -ENOMEM;
219 }
220
Steve French7521a3c2007-07-11 18:30:34 +0000221 cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 inode, file->f_flags, full_path));
223 desiredAccess = cifs_convert_flags(file->f_flags);
224
225/*********************************************************************
226 * open flag mapping table:
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000227 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 * POSIX Flag CIFS Disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000229 * ---------- ----------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 * O_CREAT FILE_OPEN_IF
231 * O_CREAT | O_EXCL FILE_CREATE
232 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
233 * O_TRUNC FILE_OVERWRITE
234 * none of the above FILE_OPEN
235 *
236 * Note that there is not a direct match between disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000237 * FILE_SUPERSEDE (ie create whether or not file exists although
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 * O_CREAT | O_TRUNC is similar but truncates the existing
239 * file rather than creating a new file as FILE_SUPERSEDE does
240 * (which uses the attributes / metadata passed in on open call)
241 *?
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000242 *? O_SYNC is a reasonable match to CIFS writethrough flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 *? and the read write flags match reasonably. O_LARGEFILE
244 *? is irrelevant because largefile support is always used
245 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
246 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
247 *********************************************************************/
248
249 disposition = cifs_get_disposition(file->f_flags);
250
251 if (oplockEnabled)
252 oplock = REQ_OPLOCK;
253 else
Steve French4b18f2a2008-04-29 00:06:05 +0000254 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256 /* BB pass O_SYNC flag through on file attributes .. BB */
257
258 /* Also refresh inode by passing in file_info buf returned by SMBOpen
259 and calling get_inode_info with returned buf (at least helps
260 non-Unix server case) */
261
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000262 /* BB we can not do this if this is the second open of a file
263 and the first handle has writebehind data, we might be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
265 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
266 if (!buf) {
267 rc = -ENOMEM;
268 goto out;
269 }
Steve French5bafd762006-06-07 00:18:43 +0000270
271 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000272 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
Steve French5bafd762006-06-07 00:18:43 +0000273 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
Steve French737b7582005-04-28 22:41:06 -0700274 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
275 & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000276 else
277 rc = -EIO; /* no NT SMB support fall into legacy open below */
278
Steve Frencha9d02ad2005-08-24 23:06:05 -0700279 if (rc == -EIO) {
280 /* Old server, try legacy style OpenX */
281 rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
282 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
283 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
284 & CIFS_MOUNT_MAP_SPECIAL_CHR);
285 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 if (rc) {
Steve French26a21b92006-05-31 18:05:34 +0000287 cFYI(1, ("cifs_open returned 0x%x", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 goto out;
289 }
290 file->private_data =
291 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
292 if (file->private_data == NULL) {
293 rc = -ENOMEM;
294 goto out;
295 }
296 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 write_lock(&GlobalSMBSeslock);
298 list_add(&pCifsFile->tlist, &pTcon->openFileList);
299
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800300 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 if (pCifsInode) {
302 rc = cifs_open_inode_helper(inode, file, pCifsInode,
303 pCifsFile, pTcon,
304 &oplock, buf, full_path, xid);
305 } else {
306 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 }
308
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000309 if (oplock & CIFS_CREATE_ACTION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 /* time to set mode which we can not set earlier due to
311 problems creating new read-only files */
Steve Frenchc18c8422007-07-18 23:21:09 +0000312 if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400313 struct cifs_unix_set_info_args args = {
314 .mode = inode->i_mode,
315 .uid = NO_CHANGE_64,
316 .gid = NO_CHANGE_64,
317 .ctime = NO_CHANGE_64,
318 .atime = NO_CHANGE_64,
319 .mtime = NO_CHANGE_64,
320 .device = 0,
321 };
322 CIFSSMBUnixSetInfo(xid, pTcon, full_path, &args,
Steve French737b7582005-04-28 22:41:06 -0700323 cifs_sb->local_nls,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000324 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700325 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 }
327 }
328
329out:
330 kfree(buf);
331 kfree(full_path);
332 FreeXid(xid);
333 return rc;
334}
335
Adrian Bunk04187262006-06-30 18:23:04 +0200336/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337/* to server was lost */
338static int cifs_relock_file(struct cifsFileInfo *cifsFile)
339{
340 int rc = 0;
341
342/* BB list all locks open on this file and relock */
343
344 return rc;
345}
346
Steve French4b18f2a2008-04-29 00:06:05 +0000347static int cifs_reopen_file(struct file *file, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348{
349 int rc = -EACCES;
350 int xid, oplock;
351 struct cifs_sb_info *cifs_sb;
352 struct cifsTconInfo *pTcon;
353 struct cifsFileInfo *pCifsFile;
354 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000355 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 char *full_path = NULL;
357 int desiredAccess;
358 int disposition = FILE_OPEN;
359 __u16 netfid;
360
Steve Frenchad7a2922008-02-07 23:25:02 +0000361 if (file->private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 pCifsFile = (struct cifsFileInfo *)file->private_data;
Steve Frenchad7a2922008-02-07 23:25:02 +0000363 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 return -EBADF;
365
366 xid = GetXid();
367 down(&pCifsFile->fh_sem);
Steve French4b18f2a2008-04-29 00:06:05 +0000368 if (!pCifsFile->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 up(&pCifsFile->fh_sem);
370 FreeXid(xid);
371 return 0;
372 }
373
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800374 if (file->f_path.dentry == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000375 cERROR(1, ("no valid name if dentry freed"));
376 dump_stack();
377 rc = -EBADF;
378 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 }
Steve French3a9f4622007-04-04 17:10:24 +0000380
381 inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000382 if (inode == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000383 cERROR(1, ("inode not valid"));
384 dump_stack();
385 rc = -EBADF;
386 goto reopen_error_exit;
387 }
Steve French50c2f752007-07-13 00:33:32 +0000388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 cifs_sb = CIFS_SB(inode->i_sb);
390 pTcon = cifs_sb->tcon;
Steve French3a9f4622007-04-04 17:10:24 +0000391
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392/* can not grab rename sem here because various ops, including
393 those that already have the rename sem can end up causing writepage
394 to get called and if the server was down that means we end up here,
395 and we can never tell if the caller already has the rename_sem */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800396 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000398 rc = -ENOMEM;
399reopen_error_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 up(&pCifsFile->fh_sem);
401 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000402 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 }
404
Steve French3a9f4622007-04-04 17:10:24 +0000405 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000406 inode, file->f_flags, full_path));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 desiredAccess = cifs_convert_flags(file->f_flags);
408
409 if (oplockEnabled)
410 oplock = REQ_OPLOCK;
411 else
Steve French4b18f2a2008-04-29 00:06:05 +0000412 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
414 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000415 by SMBOpen and then calling get_inode_info with returned buf
416 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 and server version of file size can be stale. If we knew for sure
418 that inode was not dirty locally we could do this */
419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
421 CREATE_NOT_DIR, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000422 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700423 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 if (rc) {
425 up(&pCifsFile->fh_sem);
Steve French26a21b92006-05-31 18:05:34 +0000426 cFYI(1, ("cifs_open returned 0x%x", rc));
427 cFYI(1, ("oplock: %d", oplock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 } else {
429 pCifsFile->netfid = netfid;
Steve French4b18f2a2008-04-29 00:06:05 +0000430 pCifsFile->invalidHandle = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 up(&pCifsFile->fh_sem);
432 pCifsInode = CIFS_I(inode);
433 if (pCifsInode) {
434 if (can_flush) {
Jeff Laytoncea21802007-11-20 23:19:03 +0000435 rc = filemap_write_and_wait(inode->i_mapping);
436 if (rc != 0)
437 CIFS_I(inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 /* temporarily disable caching while we
439 go to server to get inode info */
Steve French4b18f2a2008-04-29 00:06:05 +0000440 pCifsInode->clientCanCacheAll = false;
441 pCifsInode->clientCanCacheRead = false;
Steve Frenchc18c8422007-07-18 23:21:09 +0000442 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 rc = cifs_get_inode_info_unix(&inode,
444 full_path, inode->i_sb, xid);
445 else
446 rc = cifs_get_inode_info(&inode,
447 full_path, NULL, inode->i_sb,
Steve French8b1327f2008-03-14 22:37:16 +0000448 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 } /* else we are writing out data to server already
450 and could deadlock if we tried to flush data, and
451 since we do not know if we have data that would
452 invalidate the current end of file on the server
453 we can not go to the server to get the new inod
454 info */
455 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000456 pCifsInode->clientCanCacheAll = true;
457 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800459 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 } else if ((oplock & 0xF) == OPLOCK_READ) {
Steve French4b18f2a2008-04-29 00:06:05 +0000461 pCifsInode->clientCanCacheRead = true;
462 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 } else {
Steve French4b18f2a2008-04-29 00:06:05 +0000464 pCifsInode->clientCanCacheRead = false;
465 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 }
467 cifs_relock_file(pCifsFile);
468 }
469 }
470
471 kfree(full_path);
472 FreeXid(xid);
473 return rc;
474}
475
476int cifs_close(struct inode *inode, struct file *file)
477{
478 int rc = 0;
Steve French15745322007-09-07 22:23:48 +0000479 int xid, timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 struct cifs_sb_info *cifs_sb;
481 struct cifsTconInfo *pTcon;
482 struct cifsFileInfo *pSMBFile =
483 (struct cifsFileInfo *)file->private_data;
484
485 xid = GetXid();
486
487 cifs_sb = CIFS_SB(inode->i_sb);
488 pTcon = cifs_sb->tcon;
489 if (pSMBFile) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000490 struct cifsLockInfo *li, *tmp;
491
Steve French4b18f2a2008-04-29 00:06:05 +0000492 pSMBFile->closePend = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 if (pTcon) {
494 /* no sense reconnecting to close a file that is
495 already closed */
496 if (pTcon->tidStatus != CifsNeedReconnect) {
Steve French15745322007-09-07 22:23:48 +0000497 timeout = 2;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000498 while ((atomic_read(&pSMBFile->wrtPending) != 0)
Steve French15745322007-09-07 22:23:48 +0000499 && (timeout <= 2048)) {
Steve French23e7dd72005-10-20 13:44:56 -0700500 /* Give write a better chance to get to
501 server ahead of the close. We do not
502 want to add a wait_q here as it would
503 increase the memory utilization as
504 the struct would be in each open file,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000505 but this should give enough time to
Steve French23e7dd72005-10-20 13:44:56 -0700506 clear the socket */
Steve French90c81e02008-02-12 20:32:36 +0000507 cFYI(DBG2,
508 ("close delay, write pending"));
Steve French23e7dd72005-10-20 13:44:56 -0700509 msleep(timeout);
510 timeout *= 4;
Steve French4891d532006-11-07 16:31:16 +0000511 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000512 if (atomic_read(&pSMBFile->wrtPending))
Steve French63135e02007-07-17 17:34:02 +0000513 cERROR(1,
514 ("close with pending writes"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 rc = CIFSSMBClose(xid, pTcon,
516 pSMBFile->netfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 }
518 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000519
520 /* Delete any outstanding lock records.
521 We'll lose them when the file is closed anyway. */
Roland Dreier796e5662007-05-03 04:33:45 +0000522 mutex_lock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000523 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
524 list_del(&li->llist);
525 kfree(li);
526 }
Roland Dreier796e5662007-05-03 04:33:45 +0000527 mutex_unlock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000528
Steve Frenchcbe04762005-04-28 22:41:05 -0700529 write_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 list_del(&pSMBFile->flist);
531 list_del(&pSMBFile->tlist);
Steve Frenchcbe04762005-04-28 22:41:05 -0700532 write_unlock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +0000533 timeout = 10;
534 /* We waited above to give the SMBWrite a chance to issue
535 on the wire (so we do not get SMBWrite returning EBADF
536 if writepages is racing with close. Note that writepages
537 does not specify a file handle, so it is possible for a file
538 to be opened twice, and the application close the "wrong"
539 file handle - in these cases we delay long enough to allow
540 the SMBWrite to get on the wire before the SMB Close.
541 We allow total wait here over 45 seconds, more than
542 oplock break time, and more than enough to allow any write
543 to complete on the server, or to time out on the client */
544 while ((atomic_read(&pSMBFile->wrtPending) != 0)
545 && (timeout <= 50000)) {
546 cERROR(1, ("writes pending, delay free of handle"));
547 msleep(timeout);
548 timeout *= 8;
549 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 kfree(file->private_data);
551 file->private_data = NULL;
552 } else
553 rc = -EBADF;
554
Steve French4efa53f2007-09-11 05:50:53 +0000555 read_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 if (list_empty(&(CIFS_I(inode)->openFileList))) {
557 cFYI(1, ("closing last open instance for inode %p", inode));
558 /* if the file is not open we do not know if we can cache info
559 on this inode, much less write behind and read ahead */
Steve French4b18f2a2008-04-29 00:06:05 +0000560 CIFS_I(inode)->clientCanCacheRead = false;
561 CIFS_I(inode)->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 }
Steve French4efa53f2007-09-11 05:50:53 +0000563 read_unlock(&GlobalSMBSeslock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000564 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 rc = CIFS_I(inode)->write_behind_rc;
566 FreeXid(xid);
567 return rc;
568}
569
570int cifs_closedir(struct inode *inode, struct file *file)
571{
572 int rc = 0;
573 int xid;
574 struct cifsFileInfo *pCFileStruct =
575 (struct cifsFileInfo *)file->private_data;
576 char *ptmp;
577
Steve French26a21b92006-05-31 18:05:34 +0000578 cFYI(1, ("Closedir inode = 0x%p", inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579
580 xid = GetXid();
581
582 if (pCFileStruct) {
583 struct cifsTconInfo *pTcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000584 struct cifs_sb_info *cifs_sb =
585 CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586
587 pTcon = cifs_sb->tcon;
588
589 cFYI(1, ("Freeing private data in close dir"));
Steve French4b18f2a2008-04-29 00:06:05 +0000590 if (!pCFileStruct->srch_inf.endOfSearch &&
591 !pCFileStruct->invalidHandle) {
592 pCFileStruct->invalidHandle = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
594 cFYI(1, ("Closing uncompleted readdir with rc %d",
595 rc));
596 /* not much we can do if it fails anyway, ignore rc */
597 rc = 0;
598 }
599 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
600 if (ptmp) {
Steve Frenchec637e32005-12-12 20:53:18 -0800601 cFYI(1, ("closedir free smb buf in srch struct"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000603 if (pCFileStruct->srch_inf.smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000604 cifs_small_buf_release(ptmp);
605 else
606 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 kfree(file->private_data);
609 file->private_data = NULL;
610 }
611 /* BB can we lock the filestruct while this is going on? */
612 FreeXid(xid);
613 return rc;
614}
615
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000616static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
617 __u64 offset, __u8 lockType)
618{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000619 struct cifsLockInfo *li =
620 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000621 if (li == NULL)
622 return -ENOMEM;
623 li->offset = offset;
624 li->length = len;
625 li->type = lockType;
Roland Dreier796e5662007-05-03 04:33:45 +0000626 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000627 list_add(&li->llist, &fid->llist);
Roland Dreier796e5662007-05-03 04:33:45 +0000628 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000629 return 0;
630}
631
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
633{
634 int rc, xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 __u32 numLock = 0;
636 __u32 numUnlock = 0;
637 __u64 length;
Steve French4b18f2a2008-04-29 00:06:05 +0000638 bool wait_flag = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 struct cifs_sb_info *cifs_sb;
640 struct cifsTconInfo *pTcon;
Steve French08547b02006-02-28 22:39:25 +0000641 __u16 netfid;
642 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
Steve French4b18f2a2008-04-29 00:06:05 +0000643 bool posix_locking;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
645 length = 1 + pfLock->fl_end - pfLock->fl_start;
646 rc = -EACCES;
647 xid = GetXid();
648
649 cFYI(1, ("Lock parm: 0x%x flockflags: "
650 "0x%x flocktype: 0x%x start: %lld end: %lld",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000651 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
652 pfLock->fl_end));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
654 if (pfLock->fl_flags & FL_POSIX)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000655 cFYI(1, ("Posix"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 if (pfLock->fl_flags & FL_FLOCK)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000657 cFYI(1, ("Flock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658 if (pfLock->fl_flags & FL_SLEEP) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000659 cFYI(1, ("Blocking lock"));
Steve French4b18f2a2008-04-29 00:06:05 +0000660 wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661 }
662 if (pfLock->fl_flags & FL_ACCESS)
663 cFYI(1, ("Process suspended by mandatory locking - "
Steve French26a21b92006-05-31 18:05:34 +0000664 "not implemented yet"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 if (pfLock->fl_flags & FL_LEASE)
666 cFYI(1, ("Lease on file - not implemented yet"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000667 if (pfLock->fl_flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
669 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
670
671 if (pfLock->fl_type == F_WRLCK) {
672 cFYI(1, ("F_WRLCK "));
673 numLock = 1;
674 } else if (pfLock->fl_type == F_UNLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000675 cFYI(1, ("F_UNLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 numUnlock = 1;
Steve Frenchd47d7c12006-02-28 03:45:48 +0000677 /* Check if unlock includes more than
678 one lock range */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679 } else if (pfLock->fl_type == F_RDLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000680 cFYI(1, ("F_RDLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 lockType |= LOCKING_ANDX_SHARED_LOCK;
682 numLock = 1;
683 } else if (pfLock->fl_type == F_EXLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000684 cFYI(1, ("F_EXLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 numLock = 1;
686 } else if (pfLock->fl_type == F_SHLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000687 cFYI(1, ("F_SHLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 lockType |= LOCKING_ANDX_SHARED_LOCK;
689 numLock = 1;
690 } else
Steve Frenchd47d7c12006-02-28 03:45:48 +0000691 cFYI(1, ("Unknown type of lock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800693 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 pTcon = cifs_sb->tcon;
695
696 if (file->private_data == NULL) {
697 FreeXid(xid);
698 return -EBADF;
699 }
Steve French08547b02006-02-28 22:39:25 +0000700 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000702 posix_locking = (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
703 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability));
Steve French08547b02006-02-28 22:39:25 +0000704
705 /* BB add code here to normalize offset and length to
706 account for negative length which we can not accept over the
707 wire */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 if (IS_GETLK(cmd)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000709 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000710 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000711 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000712 posix_lock_type = CIFS_RDLCK;
713 else
714 posix_lock_type = CIFS_WRLCK;
715 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 1 /* get */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000716 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000717 posix_lock_type, wait_flag);
718 FreeXid(xid);
719 return rc;
720 }
721
722 /* BB we could chain these into one lock request BB */
723 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
724 0, 1, lockType, 0 /* wait flag */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 if (rc == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000726 rc = CIFSSMBLock(xid, pTcon, netfid, length,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 pfLock->fl_start, 1 /* numUnlock */ ,
728 0 /* numLock */ , lockType,
729 0 /* wait flag */ );
730 pfLock->fl_type = F_UNLCK;
731 if (rc != 0)
732 cERROR(1, ("Error unlocking previously locked "
Steve French08547b02006-02-28 22:39:25 +0000733 "range %d during test of lock", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 rc = 0;
735
736 } else {
737 /* if rc == ERR_SHARING_VIOLATION ? */
738 rc = 0; /* do not change lock type to unlock
739 since range in use */
740 }
741
742 FreeXid(xid);
743 return rc;
744 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000745
746 if (!numLock && !numUnlock) {
747 /* if no lock or unlock then nothing
748 to do since we do not know what it is */
749 FreeXid(xid);
750 return -EOPNOTSUPP;
751 }
752
753 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000754 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000755 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000756 posix_lock_type = CIFS_RDLCK;
757 else
758 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +0000759
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000760 if (numUnlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +0000761 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000762
Steve French08547b02006-02-28 22:39:25 +0000763 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000764 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000765 posix_lock_type, wait_flag);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000766 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000767 struct cifsFileInfo *fid =
768 (struct cifsFileInfo *)file->private_data;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000769
770 if (numLock) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000771 rc = CIFSSMBLock(xid, pTcon, netfid, length,
772 pfLock->fl_start,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000773 0, numLock, lockType, wait_flag);
774
775 if (rc == 0) {
776 /* For Windows locks we must store them. */
777 rc = store_file_lock(fid, length,
778 pfLock->fl_start, lockType);
779 }
780 } else if (numUnlock) {
781 /* For each stored lock that this unlock overlaps
782 completely, unlock it. */
783 int stored_rc = 0;
784 struct cifsLockInfo *li, *tmp;
785
Steve French6b70c952006-09-21 07:35:29 +0000786 rc = 0;
Roland Dreier796e5662007-05-03 04:33:45 +0000787 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000788 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
789 if (pfLock->fl_start <= li->offset &&
Steve Frenchc19eb712007-08-24 03:22:48 +0000790 (pfLock->fl_start + length) >=
Jeff Layton39db8102007-08-24 03:16:51 +0000791 (li->offset + li->length)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000792 stored_rc = CIFSSMBLock(xid, pTcon,
793 netfid,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000794 li->length, li->offset,
Steve French4b18f2a2008-04-29 00:06:05 +0000795 1, 0, li->type, false);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000796 if (stored_rc)
797 rc = stored_rc;
798
799 list_del(&li->llist);
800 kfree(li);
801 }
802 }
Roland Dreier796e5662007-05-03 04:33:45 +0000803 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000804 }
805 }
806
Steve Frenchd634cc12005-08-26 14:42:59 -0500807 if (pfLock->fl_flags & FL_POSIX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 posix_lock_file_wait(file, pfLock);
809 FreeXid(xid);
810 return rc;
811}
812
813ssize_t cifs_user_write(struct file *file, const char __user *write_data,
814 size_t write_size, loff_t *poffset)
815{
816 int rc = 0;
817 unsigned int bytes_written = 0;
818 unsigned int total_written;
819 struct cifs_sb_info *cifs_sb;
820 struct cifsTconInfo *pTcon;
821 int xid, long_op;
822 struct cifsFileInfo *open_file;
823
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800824 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
826 pTcon = cifs_sb->tcon;
827
828 /* cFYI(1,
829 (" write %d bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800830 *poffset, file->f_path.dentry->d_name.name)); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831
832 if (file->private_data == NULL)
833 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000834 open_file = (struct cifsFileInfo *) file->private_data;
Steve French50c2f752007-07-13 00:33:32 +0000835
Jeff Layton838726c2008-08-28 07:54:59 -0400836 rc = generic_write_checks(file, poffset, &write_size, 0);
837 if (rc)
838 return rc;
839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800842 if (*poffset > file->f_path.dentry->d_inode->i_size)
Steve French133672e2007-11-13 22:41:37 +0000843 long_op = CIFS_VLONG_OP; /* writes past EOF take long time */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 else
Steve French133672e2007-11-13 22:41:37 +0000845 long_op = CIFS_LONG_OP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846
847 for (total_written = 0; write_size > total_written;
848 total_written += bytes_written) {
849 rc = -EAGAIN;
850 while (rc == -EAGAIN) {
851 if (file->private_data == NULL) {
852 /* file has been closed on us */
853 FreeXid(xid);
854 /* if we have gotten here we have written some data
855 and blocked, and the file has been freed on us while
856 we blocked so return what we managed to write */
857 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000858 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 if (open_file->closePend) {
860 FreeXid(xid);
861 if (total_written)
862 return total_written;
863 else
864 return -EBADF;
865 }
866 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 /* we could deadlock if we called
868 filemap_fdatawait from here so tell
869 reopen_file not to flush data to server
870 now */
Steve French4b18f2a2008-04-29 00:06:05 +0000871 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872 if (rc != 0)
873 break;
874 }
875
876 rc = CIFSSMBWrite(xid, pTcon,
877 open_file->netfid,
878 min_t(const int, cifs_sb->wsize,
879 write_size - total_written),
880 *poffset, &bytes_written,
881 NULL, write_data + total_written, long_op);
882 }
883 if (rc || (bytes_written == 0)) {
884 if (total_written)
885 break;
886 else {
887 FreeXid(xid);
888 return rc;
889 }
890 } else
891 *poffset += bytes_written;
Steve French133672e2007-11-13 22:41:37 +0000892 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 15 seconds is plenty */
894 }
895
Steve Frencha4544342005-08-24 13:59:35 -0700896 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700897
898 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +0000899 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
900 struct inode *inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000901/* Do not update local mtime - server will set its actual value on write
902 * inode->i_ctime = inode->i_mtime =
Steve French3677db12007-02-26 16:46:11 +0000903 * current_fs_time(inode->i_sb);*/
904 if (total_written > 0) {
905 spin_lock(&inode->i_lock);
906 if (*poffset > file->f_path.dentry->d_inode->i_size)
907 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 *poffset);
Steve French3677db12007-02-26 16:46:11 +0000909 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000911 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 }
913 FreeXid(xid);
914 return total_written;
915}
916
917static ssize_t cifs_write(struct file *file, const char *write_data,
918 size_t write_size, loff_t *poffset)
919{
920 int rc = 0;
921 unsigned int bytes_written = 0;
922 unsigned int total_written;
923 struct cifs_sb_info *cifs_sb;
924 struct cifsTconInfo *pTcon;
925 int xid, long_op;
926 struct cifsFileInfo *open_file;
927
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800928 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
930 pTcon = cifs_sb->tcon;
931
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000932 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800933 *poffset, file->f_path.dentry->d_name.name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934
935 if (file->private_data == NULL)
936 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000937 open_file = (struct cifsFileInfo *)file->private_data;
Steve French50c2f752007-07-13 00:33:32 +0000938
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800941 if (*poffset > file->f_path.dentry->d_inode->i_size)
Steve French133672e2007-11-13 22:41:37 +0000942 long_op = CIFS_VLONG_OP; /* writes past EOF can be slow */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 else
Steve French133672e2007-11-13 22:41:37 +0000944 long_op = CIFS_LONG_OP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945
946 for (total_written = 0; write_size > total_written;
947 total_written += bytes_written) {
948 rc = -EAGAIN;
949 while (rc == -EAGAIN) {
950 if (file->private_data == NULL) {
951 /* file has been closed on us */
952 FreeXid(xid);
953 /* if we have gotten here we have written some data
954 and blocked, and the file has been freed on us
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000955 while we blocked so return what we managed to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956 write */
957 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000958 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959 if (open_file->closePend) {
960 FreeXid(xid);
961 if (total_written)
962 return total_written;
963 else
964 return -EBADF;
965 }
966 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 /* we could deadlock if we called
968 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000969 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 server now */
Steve French4b18f2a2008-04-29 00:06:05 +0000971 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 if (rc != 0)
973 break;
974 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000975 if (experimEnabled || (pTcon->ses->server &&
976 ((pTcon->ses->server->secMode &
Steve French08775832006-05-30 18:08:26 +0000977 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +0000978 == 0))) {
Steve French3e844692005-10-03 13:37:24 -0700979 struct kvec iov[2];
980 unsigned int len;
981
Steve French0ae0efa2005-10-10 10:57:19 -0700982 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -0700983 write_size - total_written);
984 /* iov[0] is reserved for smb header */
985 iov[1].iov_base = (char *)write_data +
986 total_written;
987 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500988 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -0700989 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500990 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -0700991 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500992 } else
Steve French60808232006-04-22 15:53:05 +0000993 rc = CIFSSMBWrite(xid, pTcon,
994 open_file->netfid,
995 min_t(const int, cifs_sb->wsize,
996 write_size - total_written),
997 *poffset, &bytes_written,
998 write_data + total_written,
999 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 }
1001 if (rc || (bytes_written == 0)) {
1002 if (total_written)
1003 break;
1004 else {
1005 FreeXid(xid);
1006 return rc;
1007 }
1008 } else
1009 *poffset += bytes_written;
Steve French133672e2007-11-13 22:41:37 +00001010 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 15 seconds is plenty */
1012 }
1013
Steve Frencha4544342005-08-24 13:59:35 -07001014 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015
1016 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001017 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
Steve French004c46b2007-02-17 04:34:13 +00001018/*BB We could make this contingent on superblock ATIME flag too */
Steve French3677db12007-02-26 16:46:11 +00001019/* file->f_path.dentry->d_inode->i_ctime =
1020 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1021 if (total_written > 0) {
1022 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1023 if (*poffset > file->f_path.dentry->d_inode->i_size)
1024 i_size_write(file->f_path.dentry->d_inode,
1025 *poffset);
1026 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 }
Steve French3677db12007-02-26 16:46:11 +00001028 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 }
1030 FreeXid(xid);
1031 return total_written;
1032}
1033
Steve French630f3f0c2007-10-25 21:17:17 +00001034#ifdef CONFIG_CIFS_EXPERIMENTAL
1035struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1036{
1037 struct cifsFileInfo *open_file = NULL;
1038
1039 read_lock(&GlobalSMBSeslock);
1040 /* we could simply get the first_list_entry since write-only entries
1041 are always at the end of the list but since the first entry might
1042 have a close pending, we go through the whole list */
1043 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1044 if (open_file->closePend)
1045 continue;
1046 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1047 (open_file->pfile->f_flags & O_RDONLY))) {
1048 if (!open_file->invalidHandle) {
1049 /* found a good file */
1050 /* lock it so it will not be closed on us */
1051 atomic_inc(&open_file->wrtPending);
1052 read_unlock(&GlobalSMBSeslock);
1053 return open_file;
1054 } /* else might as well continue, and look for
1055 another, or simply have the caller reopen it
1056 again rather than trying to fix this handle */
1057 } else /* write only file */
1058 break; /* write only files are last so must be done */
1059 }
1060 read_unlock(&GlobalSMBSeslock);
1061 return NULL;
1062}
1063#endif
1064
Steve Frenchdd99cd82005-10-05 19:32:49 -07001065struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
Steve French6148a742005-10-05 12:23:19 -07001066{
1067 struct cifsFileInfo *open_file;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001068 int rc;
Steve French6148a742005-10-05 12:23:19 -07001069
Steve French60808232006-04-22 15:53:05 +00001070 /* Having a null inode here (because mapping->host was set to zero by
1071 the VFS or MM) should not happen but we had reports of on oops (due to
1072 it being zero) during stress testcases so we need to check for it */
1073
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001074 if (cifs_inode == NULL) {
1075 cERROR(1, ("Null inode passed to cifs_writeable_file"));
Steve French60808232006-04-22 15:53:05 +00001076 dump_stack();
1077 return NULL;
1078 }
1079
Steve French6148a742005-10-05 12:23:19 -07001080 read_lock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001081refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001082 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1083 if (open_file->closePend)
1084 continue;
1085 if (open_file->pfile &&
1086 ((open_file->pfile->f_flags & O_RDWR) ||
1087 (open_file->pfile->f_flags & O_WRONLY))) {
Steve French23e7dd72005-10-20 13:44:56 -07001088 atomic_inc(&open_file->wrtPending);
Steve French9b22b0b2007-10-02 01:11:08 +00001089
1090 if (!open_file->invalidHandle) {
1091 /* found a good writable file */
1092 read_unlock(&GlobalSMBSeslock);
1093 return open_file;
1094 }
Steve French8840dee2007-11-16 23:05:52 +00001095
Steve French6148a742005-10-05 12:23:19 -07001096 read_unlock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001097 /* Had to unlock since following call can block */
Steve French4b18f2a2008-04-29 00:06:05 +00001098 rc = cifs_reopen_file(open_file->pfile, false);
Steve French8840dee2007-11-16 23:05:52 +00001099 if (!rc) {
Steve French9b22b0b2007-10-02 01:11:08 +00001100 if (!open_file->closePend)
1101 return open_file;
1102 else { /* start over in case this was deleted */
1103 /* since the list could be modified */
Steve French37c0eb42005-10-05 14:50:29 -07001104 read_lock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +00001105 atomic_dec(&open_file->wrtPending);
Steve French9b22b0b2007-10-02 01:11:08 +00001106 goto refind_writable;
Steve French37c0eb42005-10-05 14:50:29 -07001107 }
1108 }
Steve French9b22b0b2007-10-02 01:11:08 +00001109
1110 /* if it fails, try another handle if possible -
1111 (we can not do this if closePending since
1112 loop could be modified - in which case we
1113 have to start at the beginning of the list
1114 again. Note that it would be bad
1115 to hold up writepages here (rather than
1116 in caller) with continuous retries */
1117 cFYI(1, ("wp failed on reopen file"));
1118 read_lock(&GlobalSMBSeslock);
1119 /* can not use this handle, no write
1120 pending on this one after all */
1121 atomic_dec(&open_file->wrtPending);
Steve French8840dee2007-11-16 23:05:52 +00001122
Steve French9b22b0b2007-10-02 01:11:08 +00001123 if (open_file->closePend) /* list could have changed */
1124 goto refind_writable;
1125 /* else we simply continue to the next entry. Thus
1126 we do not loop on reopen errors. If we
1127 can not reopen the file, for example if we
1128 reconnected to a server with another client
1129 racing to delete or lock the file we would not
1130 make progress if we restarted before the beginning
1131 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001132 }
1133 }
1134 read_unlock(&GlobalSMBSeslock);
1135 return NULL;
1136}
1137
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1139{
1140 struct address_space *mapping = page->mapping;
1141 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1142 char *write_data;
1143 int rc = -EFAULT;
1144 int bytes_written = 0;
1145 struct cifs_sb_info *cifs_sb;
1146 struct cifsTconInfo *pTcon;
1147 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001148 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149
1150 if (!mapping || !mapping->host)
1151 return -EFAULT;
1152
1153 inode = page->mapping->host;
1154 cifs_sb = CIFS_SB(inode->i_sb);
1155 pTcon = cifs_sb->tcon;
1156
1157 offset += (loff_t)from;
1158 write_data = kmap(page);
1159 write_data += from;
1160
1161 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1162 kunmap(page);
1163 return -EIO;
1164 }
1165
1166 /* racing with truncate? */
1167 if (offset > mapping->host->i_size) {
1168 kunmap(page);
1169 return 0; /* don't care */
1170 }
1171
1172 /* check to make sure that we are not extending the file */
1173 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001174 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175
Steve French6148a742005-10-05 12:23:19 -07001176 open_file = find_writable_file(CIFS_I(mapping->host));
1177 if (open_file) {
1178 bytes_written = cifs_write(open_file->pfile, write_data,
1179 to-from, &offset);
Steve French23e7dd72005-10-20 13:44:56 -07001180 atomic_dec(&open_file->wrtPending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001182 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001183 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001184 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001185 else if (bytes_written < 0)
1186 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001187 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 cFYI(1, ("No writeable filehandles for inode"));
1189 rc = -EIO;
1190 }
1191
1192 kunmap(page);
1193 return rc;
1194}
1195
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001197 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198{
Steve French37c0eb42005-10-05 14:50:29 -07001199 struct backing_dev_info *bdi = mapping->backing_dev_info;
1200 unsigned int bytes_to_write;
1201 unsigned int bytes_written;
1202 struct cifs_sb_info *cifs_sb;
1203 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001204 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001205 pgoff_t index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001206 int range_whole = 0;
1207 struct kvec *iov;
Steve French84d2f072005-10-12 15:32:05 -07001208 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001209 int n_iov = 0;
1210 pgoff_t next;
1211 int nr_pages;
1212 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001213 struct cifsFileInfo *open_file;
Steve French37c0eb42005-10-05 14:50:29 -07001214 struct page *page;
1215 struct pagevec pvec;
1216 int rc = 0;
1217 int scanned = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 int xid;
1219
Steve French37c0eb42005-10-05 14:50:29 -07001220 cifs_sb = CIFS_SB(mapping->host->i_sb);
Steve French50c2f752007-07-13 00:33:32 +00001221
Steve French37c0eb42005-10-05 14:50:29 -07001222 /*
1223 * If wsize is smaller that the page cache size, default to writing
1224 * one page at a time via cifs_writepage
1225 */
1226 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1227 return generic_writepages(mapping, wbc);
1228
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001229 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1230 if (cifs_sb->tcon->ses->server->secMode &
1231 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1232 if (!experimEnabled)
Steve French60808232006-04-22 15:53:05 +00001233 return generic_writepages(mapping, wbc);
Steve French4a771182005-10-05 15:14:33 -07001234
Steve French9a0c8232007-02-02 04:21:57 +00001235 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001236 if (iov == NULL)
Steve French9a0c8232007-02-02 04:21:57 +00001237 return generic_writepages(mapping, wbc);
1238
1239
Steve French37c0eb42005-10-05 14:50:29 -07001240 /*
1241 * BB: Is this meaningful for a non-block-device file system?
1242 * If it is, we should test it again after we do I/O
1243 */
1244 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1245 wbc->encountered_congestion = 1;
Steve French9a0c8232007-02-02 04:21:57 +00001246 kfree(iov);
Steve French37c0eb42005-10-05 14:50:29 -07001247 return 0;
1248 }
1249
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 xid = GetXid();
1251
Steve French37c0eb42005-10-05 14:50:29 -07001252 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001253 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001254 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001255 end = -1;
1256 } else {
1257 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1258 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1259 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1260 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001261 scanned = 1;
1262 }
1263retry:
1264 while (!done && (index <= end) &&
1265 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1266 PAGECACHE_TAG_DIRTY,
1267 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1268 int first;
1269 unsigned int i;
1270
Steve French37c0eb42005-10-05 14:50:29 -07001271 first = -1;
1272 next = 0;
1273 n_iov = 0;
1274 bytes_to_write = 0;
1275
1276 for (i = 0; i < nr_pages; i++) {
1277 page = pvec.pages[i];
1278 /*
1279 * At this point we hold neither mapping->tree_lock nor
1280 * lock on the page itself: the page may be truncated or
1281 * invalidated (changing page->mapping to NULL), or even
1282 * swizzled back from swapper_space to tmpfs file
1283 * mapping
1284 */
1285
1286 if (first < 0)
1287 lock_page(page);
Nick Piggin529ae9a2008-08-02 12:01:03 +02001288 else if (!trylock_page(page))
Steve French37c0eb42005-10-05 14:50:29 -07001289 break;
1290
1291 if (unlikely(page->mapping != mapping)) {
1292 unlock_page(page);
1293 break;
1294 }
1295
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001296 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001297 done = 1;
1298 unlock_page(page);
1299 break;
1300 }
1301
1302 if (next && (page->index != next)) {
1303 /* Not next consecutive page */
1304 unlock_page(page);
1305 break;
1306 }
1307
1308 if (wbc->sync_mode != WB_SYNC_NONE)
1309 wait_on_page_writeback(page);
1310
1311 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001312 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001313 unlock_page(page);
1314 break;
1315 }
Steve French84d2f072005-10-12 15:32:05 -07001316
Linus Torvaldscb876f42006-12-23 16:19:07 -08001317 /*
1318 * This actually clears the dirty bit in the radix tree.
1319 * See cifs_writepage() for more commentary.
1320 */
1321 set_page_writeback(page);
1322
Steve French84d2f072005-10-12 15:32:05 -07001323 if (page_offset(page) >= mapping->host->i_size) {
1324 done = 1;
1325 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001326 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001327 break;
1328 }
1329
Steve French37c0eb42005-10-05 14:50:29 -07001330 /*
1331 * BB can we get rid of this? pages are held by pvec
1332 */
1333 page_cache_get(page);
1334
Steve French84d2f072005-10-12 15:32:05 -07001335 len = min(mapping->host->i_size - page_offset(page),
1336 (loff_t)PAGE_CACHE_SIZE);
1337
Steve French37c0eb42005-10-05 14:50:29 -07001338 /* reserve iov[0] for the smb header */
1339 n_iov++;
1340 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001341 iov[n_iov].iov_len = len;
1342 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001343
1344 if (first < 0) {
1345 first = i;
1346 offset = page_offset(page);
1347 }
1348 next = page->index + 1;
1349 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1350 break;
1351 }
1352 if (n_iov) {
Steve French23e7dd72005-10-20 13:44:56 -07001353 /* Search for a writable handle every time we call
1354 * CIFSSMBWrite2. We can't rely on the last handle
1355 * we used to still be valid
1356 */
1357 open_file = find_writable_file(CIFS_I(mapping->host));
1358 if (!open_file) {
1359 cERROR(1, ("No writable handles for inode"));
1360 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001361 } else {
Steve French23e7dd72005-10-20 13:44:56 -07001362 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1363 open_file->netfid,
1364 bytes_to_write, offset,
1365 &bytes_written, iov, n_iov,
Steve French133672e2007-11-13 22:41:37 +00001366 CIFS_LONG_OP);
Steve French23e7dd72005-10-20 13:44:56 -07001367 atomic_dec(&open_file->wrtPending);
1368 if (rc || bytes_written < bytes_to_write) {
Steve French63135e02007-07-17 17:34:02 +00001369 cERROR(1, ("Write2 ret %d, wrote %d",
Steve French23e7dd72005-10-20 13:44:56 -07001370 rc, bytes_written));
1371 /* BB what if continued retry is
1372 requested via mount flags? */
Jeff Laytoncea21802007-11-20 23:19:03 +00001373 if (rc == -ENOSPC)
1374 set_bit(AS_ENOSPC, &mapping->flags);
1375 else
1376 set_bit(AS_EIO, &mapping->flags);
Steve French23e7dd72005-10-20 13:44:56 -07001377 } else {
1378 cifs_stats_bytes_written(cifs_sb->tcon,
1379 bytes_written);
1380 }
Steve French37c0eb42005-10-05 14:50:29 -07001381 }
1382 for (i = 0; i < n_iov; i++) {
1383 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001384 /* Should we also set page error on
1385 success rc but too little data written? */
1386 /* BB investigate retry logic on temporary
1387 server crash cases and how recovery works
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001388 when page marked as error */
1389 if (rc)
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001390 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001391 kunmap(page);
1392 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001393 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001394 page_cache_release(page);
1395 }
1396 if ((wbc->nr_to_write -= n_iov) <= 0)
1397 done = 1;
1398 index = next;
1399 }
1400 pagevec_release(&pvec);
1401 }
1402 if (!scanned && !done) {
1403 /*
1404 * We hit the last page and there is more work to be done: wrap
1405 * back to the start of the file
1406 */
1407 scanned = 1;
1408 index = 0;
1409 goto retry;
1410 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001411 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001412 mapping->writeback_index = index;
1413
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001415 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 return rc;
1417}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001419static int cifs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420{
1421 int rc = -EFAULT;
1422 int xid;
1423
1424 xid = GetXid();
1425/* BB add check for wbc flags */
1426 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001427 if (!PageUptodate(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 cFYI(1, ("ppw - page not up to date"));
Linus Torvaldscb876f42006-12-23 16:19:07 -08001429
1430 /*
1431 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1432 *
1433 * A writepage() implementation always needs to do either this,
1434 * or re-dirty the page with "redirty_page_for_writepage()" in
1435 * the case of a failure.
1436 *
1437 * Just unlocking the page will cause the radix tree tag-bits
1438 * to fail to update with the state of the page correctly.
1439 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001440 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1442 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1443 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001444 end_page_writeback(page);
1445 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 FreeXid(xid);
1447 return rc;
1448}
1449
1450static int cifs_commit_write(struct file *file, struct page *page,
1451 unsigned offset, unsigned to)
1452{
1453 int xid;
1454 int rc = 0;
1455 struct inode *inode = page->mapping->host;
1456 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1457 char *page_data;
1458
1459 xid = GetXid();
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001460 cFYI(1, ("commit write for page %p up to position %lld for %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 page, position, to));
Steve French3677db12007-02-26 16:46:11 +00001462 spin_lock(&inode->i_lock);
Steve Frenchad7a2922008-02-07 23:25:02 +00001463 if (position > inode->i_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 i_size_write(inode, position);
Steve Frenchad7a2922008-02-07 23:25:02 +00001465
Steve French3677db12007-02-26 16:46:11 +00001466 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 if (!PageUptodate(page)) {
1468 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1469 /* can not rely on (or let) writepage write this data */
1470 if (to < offset) {
1471 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1472 offset, to));
1473 FreeXid(xid);
1474 return rc;
1475 }
1476 /* this is probably better than directly calling
1477 partialpage_write since in this function the file handle is
1478 known which we might as well leverage */
1479 /* BB check if anything else missing out of ppw
1480 such as updating last write time */
1481 page_data = kmap(page);
1482 rc = cifs_write(file, page_data + offset, to-offset,
1483 &position);
1484 if (rc > 0)
1485 rc = 0;
1486 /* else if (rc < 0) should we set writebehind rc? */
1487 kunmap(page);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001488 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 set_page_dirty(page);
1490 }
1491
1492 FreeXid(xid);
1493 return rc;
1494}
1495
1496int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1497{
1498 int xid;
1499 int rc = 0;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001500 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501
1502 xid = GetXid();
1503
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001504 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 dentry->d_name.name, datasync));
Steve French50c2f752007-07-13 00:33:32 +00001506
Jeff Laytoncea21802007-11-20 23:19:03 +00001507 rc = filemap_write_and_wait(inode->i_mapping);
1508 if (rc == 0) {
1509 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001511 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 FreeXid(xid);
1513 return rc;
1514}
1515
NeilBrown3978d712006-03-26 01:37:17 -08001516/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517{
1518 struct address_space *mapping;
1519 struct inode *inode;
1520 unsigned long index = page->index;
1521 unsigned int rpages = 0;
1522 int rc = 0;
1523
1524 cFYI(1, ("sync page %p",page));
1525 mapping = page->mapping;
1526 if (!mapping)
1527 return 0;
1528 inode = mapping->host;
1529 if (!inode)
NeilBrown3978d712006-03-26 01:37:17 -08001530 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001532/* fill in rpages then
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1534
Steve French26a21b92006-05-31 18:05:34 +00001535/* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536
NeilBrown3978d712006-03-26 01:37:17 -08001537#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538 if (rc < 0)
1539 return rc;
1540 return 0;
NeilBrown3978d712006-03-26 01:37:17 -08001541#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542} */
1543
1544/*
1545 * As file closes, flush all cached write data for this inode checking
1546 * for write behind errors.
1547 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001548int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001550 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 int rc = 0;
1552
1553 /* Rather than do the steps manually:
1554 lock the inode for writing
1555 loop through pages looking for write behind data (dirty pages)
1556 coalesce into contiguous 16K (or smaller) chunks to write to server
1557 send to server (prefer in parallel)
1558 deal with writebehind errors
1559 unlock inode for writing
1560 filemapfdatawrite appears easier for the time being */
1561
1562 rc = filemap_fdatawrite(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +00001563 /* reset wb rc if we were able to write out dirty pages */
1564 if (!rc) {
1565 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001567 }
Steve French50c2f752007-07-13 00:33:32 +00001568
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001569 cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570
1571 return rc;
1572}
1573
1574ssize_t cifs_user_read(struct file *file, char __user *read_data,
1575 size_t read_size, loff_t *poffset)
1576{
1577 int rc = -EACCES;
1578 unsigned int bytes_read = 0;
1579 unsigned int total_read = 0;
1580 unsigned int current_read_size;
1581 struct cifs_sb_info *cifs_sb;
1582 struct cifsTconInfo *pTcon;
1583 int xid;
1584 struct cifsFileInfo *open_file;
1585 char *smb_read_data;
1586 char __user *current_offset;
1587 struct smb_com_read_rsp *pSMBr;
1588
1589 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001590 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 pTcon = cifs_sb->tcon;
1592
1593 if (file->private_data == NULL) {
1594 FreeXid(xid);
1595 return -EBADF;
1596 }
1597 open_file = (struct cifsFileInfo *)file->private_data;
1598
Steve Frenchad7a2922008-02-07 23:25:02 +00001599 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 cFYI(1, ("attempting read on write only file instance"));
Steve Frenchad7a2922008-02-07 23:25:02 +00001601
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 for (total_read = 0, current_offset = read_data;
1603 read_size > total_read;
1604 total_read += bytes_read, current_offset += bytes_read) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001605 current_read_size = min_t(const int, read_size - total_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 cifs_sb->rsize);
1607 rc = -EAGAIN;
1608 smb_read_data = NULL;
1609 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001610 int buf_type = CIFS_NO_BUFFER;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001611 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001613 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 if (rc != 0)
1615 break;
1616 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001617 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001618 open_file->netfid,
1619 current_read_size, *poffset,
1620 &bytes_read, &smb_read_data,
1621 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001624 if (copy_to_user(current_offset,
1625 smb_read_data +
1626 4 /* RFC1001 length field */ +
1627 le16_to_cpu(pSMBr->DataOffset),
Steve Frenchad7a2922008-02-07 23:25:02 +00001628 bytes_read))
Steve French93544cc2006-02-14 22:30:52 -06001629 rc = -EFAULT;
Steve French93544cc2006-02-14 22:30:52 -06001630
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001631 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001632 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001633 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001634 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 smb_read_data = NULL;
1636 }
1637 }
1638 if (rc || (bytes_read == 0)) {
1639 if (total_read) {
1640 break;
1641 } else {
1642 FreeXid(xid);
1643 return rc;
1644 }
1645 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001646 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647 *poffset += bytes_read;
1648 }
1649 }
1650 FreeXid(xid);
1651 return total_read;
1652}
1653
1654
1655static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1656 loff_t *poffset)
1657{
1658 int rc = -EACCES;
1659 unsigned int bytes_read = 0;
1660 unsigned int total_read;
1661 unsigned int current_read_size;
1662 struct cifs_sb_info *cifs_sb;
1663 struct cifsTconInfo *pTcon;
1664 int xid;
1665 char *current_offset;
1666 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001667 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668
1669 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001670 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 pTcon = cifs_sb->tcon;
1672
1673 if (file->private_data == NULL) {
1674 FreeXid(xid);
1675 return -EBADF;
1676 }
1677 open_file = (struct cifsFileInfo *)file->private_data;
1678
1679 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1680 cFYI(1, ("attempting read on write only file instance"));
1681
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001682 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 read_size > total_read;
1684 total_read += bytes_read, current_offset += bytes_read) {
1685 current_read_size = min_t(const int, read_size - total_read,
1686 cifs_sb->rsize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001687 /* For windows me and 9x we do not want to request more
1688 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001689 if ((pTcon->ses) &&
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001690 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1691 current_read_size = min_t(const int, current_read_size,
1692 pTcon->ses->server->maxBuf - 128);
1693 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 rc = -EAGAIN;
1695 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001696 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001698 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 if (rc != 0)
1700 break;
1701 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001702 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001703 open_file->netfid,
1704 current_read_size, *poffset,
1705 &bytes_read, &current_offset,
1706 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 }
1708 if (rc || (bytes_read == 0)) {
1709 if (total_read) {
1710 break;
1711 } else {
1712 FreeXid(xid);
1713 return rc;
1714 }
1715 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001716 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 *poffset += bytes_read;
1718 }
1719 }
1720 FreeXid(xid);
1721 return total_read;
1722}
1723
1724int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1725{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001726 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001727 int rc, xid;
1728
1729 xid = GetXid();
1730 rc = cifs_revalidate(dentry);
1731 if (rc) {
1732 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1733 FreeXid(xid);
1734 return rc;
1735 }
1736 rc = generic_file_mmap(file, vma);
1737 FreeXid(xid);
1738 return rc;
1739}
1740
1741
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001742static void cifs_copy_cache_pages(struct address_space *mapping,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 struct list_head *pages, int bytes_read, char *data,
1744 struct pagevec *plru_pvec)
1745{
1746 struct page *page;
1747 char *target;
1748
1749 while (bytes_read > 0) {
1750 if (list_empty(pages))
1751 break;
1752
1753 page = list_entry(pages->prev, struct page, lru);
1754 list_del(&page->lru);
1755
1756 if (add_to_page_cache(page, mapping, page->index,
1757 GFP_KERNEL)) {
1758 page_cache_release(page);
1759 cFYI(1, ("Add page cache failed"));
Steve French3079ca62005-06-09 14:44:07 -07001760 data += PAGE_CACHE_SIZE;
1761 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 continue;
1763 }
1764
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001765 target = kmap_atomic(page, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766
1767 if (PAGE_CACHE_SIZE > bytes_read) {
1768 memcpy(target, data, bytes_read);
1769 /* zero the tail end of this partial page */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001770 memset(target + bytes_read, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 PAGE_CACHE_SIZE - bytes_read);
1772 bytes_read = 0;
1773 } else {
1774 memcpy(target, data, PAGE_CACHE_SIZE);
1775 bytes_read -= PAGE_CACHE_SIZE;
1776 }
1777 kunmap_atomic(target, KM_USER0);
1778
1779 flush_dcache_page(page);
1780 SetPageUptodate(page);
1781 unlock_page(page);
1782 if (!pagevec_add(plru_pvec, page))
1783 __pagevec_lru_add(plru_pvec);
1784 data += PAGE_CACHE_SIZE;
1785 }
1786 return;
1787}
1788
1789static int cifs_readpages(struct file *file, struct address_space *mapping,
1790 struct list_head *page_list, unsigned num_pages)
1791{
1792 int rc = -EACCES;
1793 int xid;
1794 loff_t offset;
1795 struct page *page;
1796 struct cifs_sb_info *cifs_sb;
1797 struct cifsTconInfo *pTcon;
Steve French2c2130e2007-10-12 19:10:28 +00001798 unsigned int bytes_read = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001799 unsigned int read_size, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 char *smb_read_data = NULL;
1801 struct smb_com_read_rsp *pSMBr;
1802 struct pagevec lru_pvec;
1803 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001804 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805
1806 xid = GetXid();
1807 if (file->private_data == NULL) {
1808 FreeXid(xid);
1809 return -EBADF;
1810 }
1811 open_file = (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001812 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 pTcon = cifs_sb->tcon;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001814
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 pagevec_init(&lru_pvec, 0);
Steve French90c81e02008-02-12 20:32:36 +00001816 cFYI(DBG2, ("rpages: num pages %d", num_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 for (i = 0; i < num_pages; ) {
1818 unsigned contig_pages;
1819 struct page *tmp_page;
1820 unsigned long expected_index;
1821
1822 if (list_empty(page_list))
1823 break;
1824
1825 page = list_entry(page_list->prev, struct page, lru);
1826 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1827
1828 /* count adjacent pages that we will read into */
1829 contig_pages = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001830 expected_index =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 list_entry(page_list->prev, struct page, lru)->index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001832 list_for_each_entry_reverse(tmp_page, page_list, lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 if (tmp_page->index == expected_index) {
1834 contig_pages++;
1835 expected_index++;
1836 } else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001837 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 }
1839 if (contig_pages + i > num_pages)
1840 contig_pages = num_pages - i;
1841
1842 /* for reads over a certain size could initiate async
1843 read ahead */
1844
1845 read_size = contig_pages * PAGE_CACHE_SIZE;
1846 /* Read size needs to be in multiples of one page */
1847 read_size = min_t(const unsigned int, read_size,
1848 cifs_sb->rsize & PAGE_CACHE_MASK);
Steve French90c81e02008-02-12 20:32:36 +00001849 cFYI(DBG2, ("rpages: read size 0x%x contiguous pages %d",
Steve French75865f8c2007-06-24 18:30:48 +00001850 read_size, contig_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 rc = -EAGAIN;
1852 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001853 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001855 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 if (rc != 0)
1857 break;
1858 }
1859
Steve Frenchbfa0d752005-08-31 21:50:37 -07001860 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001861 open_file->netfid,
1862 read_size, offset,
1863 &bytes_read, &smb_read_data,
1864 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001865 /* BB more RC checks ? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001866 if (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001868 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001869 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001870 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001871 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 smb_read_data = NULL;
1873 }
1874 }
1875 }
1876 if ((rc < 0) || (smb_read_data == NULL)) {
1877 cFYI(1, ("Read error in readpages: %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 break;
1879 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08001880 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1882 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1883 smb_read_data + 4 /* RFC1001 hdr */ +
1884 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1885
1886 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha4544342005-08-24 13:59:35 -07001887 cifs_stats_bytes_read(pTcon, bytes_read);
Steve French2c2130e2007-10-12 19:10:28 +00001888 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 i++; /* account for partial page */
1890
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001891 /* server copy of file can have smaller size
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892 than client */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001893 /* BB do we need to verify this common case ?
1894 this case is ok - if we are at server EOF
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 we will hit it on next read */
1896
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08001897 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 }
1899 } else {
1900 cFYI(1, ("No bytes read (%d) at offset %lld . "
1901 "Cleaning remaining pages from readahead list",
1902 bytes_read, offset));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001903 /* BB turn off caching and do new lookup on
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 break;
1906 }
1907 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001908 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001909 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001910 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001911 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 smb_read_data = NULL;
1913 }
1914 bytes_read = 0;
1915 }
1916
1917 pagevec_lru_add(&lru_pvec);
1918
1919/* need to free smb_read_data buf before exit */
1920 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001921 if (buf_type == CIFS_SMALL_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08001922 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001923 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08001924 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 smb_read_data = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001926 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001927
1928 FreeXid(xid);
1929 return rc;
1930}
1931
1932static int cifs_readpage_worker(struct file *file, struct page *page,
1933 loff_t *poffset)
1934{
1935 char *read_data;
1936 int rc;
1937
1938 page_cache_get(page);
1939 read_data = kmap(page);
1940 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001941
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001943
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 if (rc < 0)
1945 goto io_error;
1946 else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001947 cFYI(1, ("Bytes read %d", rc));
1948
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001949 file->f_path.dentry->d_inode->i_atime =
1950 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001951
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 if (PAGE_CACHE_SIZE > rc)
1953 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1954
1955 flush_dcache_page(page);
1956 SetPageUptodate(page);
1957 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001958
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001960 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 page_cache_release(page);
1962 return rc;
1963}
1964
1965static int cifs_readpage(struct file *file, struct page *page)
1966{
1967 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1968 int rc = -EACCES;
1969 int xid;
1970
1971 xid = GetXid();
1972
1973 if (file->private_data == NULL) {
1974 FreeXid(xid);
1975 return -EBADF;
1976 }
1977
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001978 cFYI(1, ("readpage %p at offset %d 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 page, (int)offset, (int)offset));
1980
1981 rc = cifs_readpage_worker(file, page, &offset);
1982
1983 unlock_page(page);
1984
1985 FreeXid(xid);
1986 return rc;
1987}
1988
Steve Frencha403a0a2007-07-26 15:54:16 +00001989static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
1990{
1991 struct cifsFileInfo *open_file;
1992
1993 read_lock(&GlobalSMBSeslock);
1994 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1995 if (open_file->closePend)
1996 continue;
1997 if (open_file->pfile &&
1998 ((open_file->pfile->f_flags & O_RDWR) ||
1999 (open_file->pfile->f_flags & O_WRONLY))) {
2000 read_unlock(&GlobalSMBSeslock);
2001 return 1;
2002 }
2003 }
2004 read_unlock(&GlobalSMBSeslock);
2005 return 0;
2006}
2007
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008/* We do not want to update the file size from server for inodes
2009 open for write - to avoid races with writepage extending
2010 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002011 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 but this is tricky to do without racing with writebehind
2013 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00002014bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015{
Steve Frencha403a0a2007-07-26 15:54:16 +00002016 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00002017 return true;
Steve French23e7dd72005-10-20 13:44:56 -07002018
Steve Frencha403a0a2007-07-26 15:54:16 +00002019 if (is_inode_writable(cifsInode)) {
2020 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08002021 struct cifs_sb_info *cifs_sb;
2022
Steve Frenchc32a0b62006-01-12 14:41:28 -08002023 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00002024 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002025 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08002026 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00002027 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08002028 }
2029
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002030 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00002031 return true;
Steve French7ba526312007-02-08 18:14:13 +00002032
Steve French4b18f2a2008-04-29 00:06:05 +00002033 return false;
Steve French23e7dd72005-10-20 13:44:56 -07002034 } else
Steve French4b18f2a2008-04-29 00:06:05 +00002035 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036}
2037
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038static int cifs_prepare_write(struct file *file, struct page *page,
2039 unsigned from, unsigned to)
2040{
2041 int rc = 0;
Steve French8a236262007-03-06 00:31:00 +00002042 loff_t i_size;
2043 loff_t offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002044
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002045 cFYI(1, ("prepare write for page %p from %d to %d", page, from, to));
Steve French8a236262007-03-06 00:31:00 +00002046 if (PageUptodate(page))
2047 return 0;
2048
2049 /* If we are writing a full page it will be up to date,
2050 no need to read from the server */
2051 if ((to == PAGE_CACHE_SIZE) && (from == 0)) {
2052 SetPageUptodate(page);
2053 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 }
2055
Steve French8a236262007-03-06 00:31:00 +00002056 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2057 i_size = i_size_read(page->mapping->host);
2058
2059 if ((offset >= i_size) ||
2060 ((from == 0) && (offset + to) >= i_size)) {
2061 /*
2062 * We don't need to read data beyond the end of the file.
2063 * zero it, and set the page uptodate
2064 */
Nate88038632007-07-16 15:45:13 +00002065 simple_prepare_write(file, page, from, to);
Steve French8a236262007-03-06 00:31:00 +00002066 SetPageUptodate(page);
2067 } else if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2068 /* might as well read a page, it is fast enough */
2069 rc = cifs_readpage_worker(file, page, &offset);
2070 } else {
2071 /* we could try using another file handle if there is one -
2072 but how would we lock it to prevent close of that handle
2073 racing with this read? In any case
2074 this will be written out by commit_write so is fine */
2075 }
2076
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002077 /* we do not need to pass errors back
2078 e.g. if we do not have read access to the file
Steve French8a236262007-03-06 00:31:00 +00002079 because cifs_commit_write will do the right thing. -- shaggy */
2080
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 return 0;
2082}
2083
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002084const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085 .readpage = cifs_readpage,
2086 .readpages = cifs_readpages,
2087 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002088 .writepages = cifs_writepages,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 .prepare_write = cifs_prepare_write,
2090 .commit_write = cifs_commit_write,
2091 .set_page_dirty = __set_page_dirty_nobuffers,
2092 /* .sync_page = cifs_sync_page, */
2093 /* .direct_IO = */
2094};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002095
2096/*
2097 * cifs_readpages requires the server to support a buffer large enough to
2098 * contain the header plus one complete page of data. Otherwise, we need
2099 * to leave cifs_readpages out of the address space operations.
2100 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002101const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002102 .readpage = cifs_readpage,
2103 .writepage = cifs_writepage,
2104 .writepages = cifs_writepages,
2105 .prepare_write = cifs_prepare_write,
2106 .commit_write = cifs_commit_write,
2107 .set_page_dirty = __set_page_dirty_nobuffers,
2108 /* .sync_page = cifs_sync_page, */
2109 /* .direct_IO = */
2110};