blob: 0aac824371a579bd4f508f7360685b15c4ad74a4 [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) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
314 inode->i_mode,
315 (__u64)-1, (__u64)-1, 0 /* dev */,
Steve French737b7582005-04-28 22:41:06 -0700316 cifs_sb->local_nls,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000317 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700318 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 } else {
320 /* BB implement via Windows security descriptors eg
321 CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
322 -1, -1, local_nls);
323 in the meantime could set r/o dos attribute when
324 perms are eg: mode & 0222 == 0 */
325 }
326 }
327
328out:
329 kfree(buf);
330 kfree(full_path);
331 FreeXid(xid);
332 return rc;
333}
334
Adrian Bunk04187262006-06-30 18:23:04 +0200335/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336/* to server was lost */
337static int cifs_relock_file(struct cifsFileInfo *cifsFile)
338{
339 int rc = 0;
340
341/* BB list all locks open on this file and relock */
342
343 return rc;
344}
345
Steve French4b18f2a2008-04-29 00:06:05 +0000346static int cifs_reopen_file(struct file *file, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347{
348 int rc = -EACCES;
349 int xid, oplock;
350 struct cifs_sb_info *cifs_sb;
351 struct cifsTconInfo *pTcon;
352 struct cifsFileInfo *pCifsFile;
353 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000354 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 char *full_path = NULL;
356 int desiredAccess;
357 int disposition = FILE_OPEN;
358 __u16 netfid;
359
Steve Frenchad7a2922008-02-07 23:25:02 +0000360 if (file->private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 pCifsFile = (struct cifsFileInfo *)file->private_data;
Steve Frenchad7a2922008-02-07 23:25:02 +0000362 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 return -EBADF;
364
365 xid = GetXid();
366 down(&pCifsFile->fh_sem);
Steve French4b18f2a2008-04-29 00:06:05 +0000367 if (!pCifsFile->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 up(&pCifsFile->fh_sem);
369 FreeXid(xid);
370 return 0;
371 }
372
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800373 if (file->f_path.dentry == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000374 cERROR(1, ("no valid name if dentry freed"));
375 dump_stack();
376 rc = -EBADF;
377 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 }
Steve French3a9f4622007-04-04 17:10:24 +0000379
380 inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000381 if (inode == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000382 cERROR(1, ("inode not valid"));
383 dump_stack();
384 rc = -EBADF;
385 goto reopen_error_exit;
386 }
Steve French50c2f752007-07-13 00:33:32 +0000387
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388 cifs_sb = CIFS_SB(inode->i_sb);
389 pTcon = cifs_sb->tcon;
Steve French3a9f4622007-04-04 17:10:24 +0000390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391/* can not grab rename sem here because various ops, including
392 those that already have the rename sem can end up causing writepage
393 to get called and if the server was down that means we end up here,
394 and we can never tell if the caller already has the rename_sem */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800395 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000397 rc = -ENOMEM;
398reopen_error_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 up(&pCifsFile->fh_sem);
400 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000401 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 }
403
Steve French3a9f4622007-04-04 17:10:24 +0000404 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000405 inode, file->f_flags, full_path));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 desiredAccess = cifs_convert_flags(file->f_flags);
407
408 if (oplockEnabled)
409 oplock = REQ_OPLOCK;
410 else
Steve French4b18f2a2008-04-29 00:06:05 +0000411 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
413 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000414 by SMBOpen and then calling get_inode_info with returned buf
415 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416 and server version of file size can be stale. If we knew for sure
417 that inode was not dirty locally we could do this */
418
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
420 CREATE_NOT_DIR, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000421 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700422 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 if (rc) {
424 up(&pCifsFile->fh_sem);
Steve French26a21b92006-05-31 18:05:34 +0000425 cFYI(1, ("cifs_open returned 0x%x", rc));
426 cFYI(1, ("oplock: %d", oplock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 } else {
428 pCifsFile->netfid = netfid;
Steve French4b18f2a2008-04-29 00:06:05 +0000429 pCifsFile->invalidHandle = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 up(&pCifsFile->fh_sem);
431 pCifsInode = CIFS_I(inode);
432 if (pCifsInode) {
433 if (can_flush) {
Jeff Laytoncea21802007-11-20 23:19:03 +0000434 rc = filemap_write_and_wait(inode->i_mapping);
435 if (rc != 0)
436 CIFS_I(inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 /* temporarily disable caching while we
438 go to server to get inode info */
Steve French4b18f2a2008-04-29 00:06:05 +0000439 pCifsInode->clientCanCacheAll = false;
440 pCifsInode->clientCanCacheRead = false;
Steve Frenchc18c8422007-07-18 23:21:09 +0000441 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 rc = cifs_get_inode_info_unix(&inode,
443 full_path, inode->i_sb, xid);
444 else
445 rc = cifs_get_inode_info(&inode,
446 full_path, NULL, inode->i_sb,
Steve French8b1327f2008-03-14 22:37:16 +0000447 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 } /* else we are writing out data to server already
449 and could deadlock if we tried to flush data, and
450 since we do not know if we have data that would
451 invalidate the current end of file on the server
452 we can not go to the server to get the new inod
453 info */
454 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000455 pCifsInode->clientCanCacheAll = true;
456 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800458 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 } else if ((oplock & 0xF) == OPLOCK_READ) {
Steve French4b18f2a2008-04-29 00:06:05 +0000460 pCifsInode->clientCanCacheRead = true;
461 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 } else {
Steve French4b18f2a2008-04-29 00:06:05 +0000463 pCifsInode->clientCanCacheRead = false;
464 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 }
466 cifs_relock_file(pCifsFile);
467 }
468 }
469
470 kfree(full_path);
471 FreeXid(xid);
472 return rc;
473}
474
475int cifs_close(struct inode *inode, struct file *file)
476{
477 int rc = 0;
Steve French15745322007-09-07 22:23:48 +0000478 int xid, timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 struct cifs_sb_info *cifs_sb;
480 struct cifsTconInfo *pTcon;
481 struct cifsFileInfo *pSMBFile =
482 (struct cifsFileInfo *)file->private_data;
483
484 xid = GetXid();
485
486 cifs_sb = CIFS_SB(inode->i_sb);
487 pTcon = cifs_sb->tcon;
488 if (pSMBFile) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000489 struct cifsLockInfo *li, *tmp;
490
Steve French4b18f2a2008-04-29 00:06:05 +0000491 pSMBFile->closePend = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 if (pTcon) {
493 /* no sense reconnecting to close a file that is
494 already closed */
495 if (pTcon->tidStatus != CifsNeedReconnect) {
Steve French15745322007-09-07 22:23:48 +0000496 timeout = 2;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000497 while ((atomic_read(&pSMBFile->wrtPending) != 0)
Steve French15745322007-09-07 22:23:48 +0000498 && (timeout <= 2048)) {
Steve French23e7dd72005-10-20 13:44:56 -0700499 /* Give write a better chance to get to
500 server ahead of the close. We do not
501 want to add a wait_q here as it would
502 increase the memory utilization as
503 the struct would be in each open file,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000504 but this should give enough time to
Steve French23e7dd72005-10-20 13:44:56 -0700505 clear the socket */
Steve French90c81e02008-02-12 20:32:36 +0000506 cFYI(DBG2,
507 ("close delay, write pending"));
Steve French23e7dd72005-10-20 13:44:56 -0700508 msleep(timeout);
509 timeout *= 4;
Steve French4891d532006-11-07 16:31:16 +0000510 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000511 if (atomic_read(&pSMBFile->wrtPending))
Steve French63135e02007-07-17 17:34:02 +0000512 cERROR(1,
513 ("close with pending writes"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 rc = CIFSSMBClose(xid, pTcon,
515 pSMBFile->netfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 }
517 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000518
519 /* Delete any outstanding lock records.
520 We'll lose them when the file is closed anyway. */
Roland Dreier796e5662007-05-03 04:33:45 +0000521 mutex_lock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000522 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
523 list_del(&li->llist);
524 kfree(li);
525 }
Roland Dreier796e5662007-05-03 04:33:45 +0000526 mutex_unlock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000527
Steve Frenchcbe04762005-04-28 22:41:05 -0700528 write_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 list_del(&pSMBFile->flist);
530 list_del(&pSMBFile->tlist);
Steve Frenchcbe04762005-04-28 22:41:05 -0700531 write_unlock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +0000532 timeout = 10;
533 /* We waited above to give the SMBWrite a chance to issue
534 on the wire (so we do not get SMBWrite returning EBADF
535 if writepages is racing with close. Note that writepages
536 does not specify a file handle, so it is possible for a file
537 to be opened twice, and the application close the "wrong"
538 file handle - in these cases we delay long enough to allow
539 the SMBWrite to get on the wire before the SMB Close.
540 We allow total wait here over 45 seconds, more than
541 oplock break time, and more than enough to allow any write
542 to complete on the server, or to time out on the client */
543 while ((atomic_read(&pSMBFile->wrtPending) != 0)
544 && (timeout <= 50000)) {
545 cERROR(1, ("writes pending, delay free of handle"));
546 msleep(timeout);
547 timeout *= 8;
548 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 kfree(file->private_data);
550 file->private_data = NULL;
551 } else
552 rc = -EBADF;
553
Steve French4efa53f2007-09-11 05:50:53 +0000554 read_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 if (list_empty(&(CIFS_I(inode)->openFileList))) {
556 cFYI(1, ("closing last open instance for inode %p", inode));
557 /* if the file is not open we do not know if we can cache info
558 on this inode, much less write behind and read ahead */
Steve French4b18f2a2008-04-29 00:06:05 +0000559 CIFS_I(inode)->clientCanCacheRead = false;
560 CIFS_I(inode)->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 }
Steve French4efa53f2007-09-11 05:50:53 +0000562 read_unlock(&GlobalSMBSeslock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000563 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 rc = CIFS_I(inode)->write_behind_rc;
565 FreeXid(xid);
566 return rc;
567}
568
569int cifs_closedir(struct inode *inode, struct file *file)
570{
571 int rc = 0;
572 int xid;
573 struct cifsFileInfo *pCFileStruct =
574 (struct cifsFileInfo *)file->private_data;
575 char *ptmp;
576
Steve French26a21b92006-05-31 18:05:34 +0000577 cFYI(1, ("Closedir inode = 0x%p", inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578
579 xid = GetXid();
580
581 if (pCFileStruct) {
582 struct cifsTconInfo *pTcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000583 struct cifs_sb_info *cifs_sb =
584 CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585
586 pTcon = cifs_sb->tcon;
587
588 cFYI(1, ("Freeing private data in close dir"));
Steve French4b18f2a2008-04-29 00:06:05 +0000589 if (!pCFileStruct->srch_inf.endOfSearch &&
590 !pCFileStruct->invalidHandle) {
591 pCFileStruct->invalidHandle = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
593 cFYI(1, ("Closing uncompleted readdir with rc %d",
594 rc));
595 /* not much we can do if it fails anyway, ignore rc */
596 rc = 0;
597 }
598 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
599 if (ptmp) {
Steve Frenchec637e32005-12-12 20:53:18 -0800600 cFYI(1, ("closedir free smb buf in srch struct"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000602 if (pCFileStruct->srch_inf.smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000603 cifs_small_buf_release(ptmp);
604 else
605 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 kfree(file->private_data);
608 file->private_data = NULL;
609 }
610 /* BB can we lock the filestruct while this is going on? */
611 FreeXid(xid);
612 return rc;
613}
614
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000615static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
616 __u64 offset, __u8 lockType)
617{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000618 struct cifsLockInfo *li =
619 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000620 if (li == NULL)
621 return -ENOMEM;
622 li->offset = offset;
623 li->length = len;
624 li->type = lockType;
Roland Dreier796e5662007-05-03 04:33:45 +0000625 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000626 list_add(&li->llist, &fid->llist);
Roland Dreier796e5662007-05-03 04:33:45 +0000627 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000628 return 0;
629}
630
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
632{
633 int rc, xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 __u32 numLock = 0;
635 __u32 numUnlock = 0;
636 __u64 length;
Steve French4b18f2a2008-04-29 00:06:05 +0000637 bool wait_flag = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 struct cifs_sb_info *cifs_sb;
639 struct cifsTconInfo *pTcon;
Steve French08547b02006-02-28 22:39:25 +0000640 __u16 netfid;
641 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
Steve French4b18f2a2008-04-29 00:06:05 +0000642 bool posix_locking;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
644 length = 1 + pfLock->fl_end - pfLock->fl_start;
645 rc = -EACCES;
646 xid = GetXid();
647
648 cFYI(1, ("Lock parm: 0x%x flockflags: "
649 "0x%x flocktype: 0x%x start: %lld end: %lld",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000650 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
651 pfLock->fl_end));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
653 if (pfLock->fl_flags & FL_POSIX)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000654 cFYI(1, ("Posix"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655 if (pfLock->fl_flags & FL_FLOCK)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000656 cFYI(1, ("Flock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 if (pfLock->fl_flags & FL_SLEEP) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000658 cFYI(1, ("Blocking lock"));
Steve French4b18f2a2008-04-29 00:06:05 +0000659 wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 }
661 if (pfLock->fl_flags & FL_ACCESS)
662 cFYI(1, ("Process suspended by mandatory locking - "
Steve French26a21b92006-05-31 18:05:34 +0000663 "not implemented yet"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 if (pfLock->fl_flags & FL_LEASE)
665 cFYI(1, ("Lease on file - not implemented yet"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000666 if (pfLock->fl_flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
668 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
669
670 if (pfLock->fl_type == F_WRLCK) {
671 cFYI(1, ("F_WRLCK "));
672 numLock = 1;
673 } else if (pfLock->fl_type == F_UNLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000674 cFYI(1, ("F_UNLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 numUnlock = 1;
Steve Frenchd47d7c12006-02-28 03:45:48 +0000676 /* Check if unlock includes more than
677 one lock range */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 } else if (pfLock->fl_type == F_RDLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000679 cFYI(1, ("F_RDLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 lockType |= LOCKING_ANDX_SHARED_LOCK;
681 numLock = 1;
682 } else if (pfLock->fl_type == F_EXLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000683 cFYI(1, ("F_EXLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 numLock = 1;
685 } else if (pfLock->fl_type == F_SHLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000686 cFYI(1, ("F_SHLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 lockType |= LOCKING_ANDX_SHARED_LOCK;
688 numLock = 1;
689 } else
Steve Frenchd47d7c12006-02-28 03:45:48 +0000690 cFYI(1, ("Unknown type of lock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800692 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 pTcon = cifs_sb->tcon;
694
695 if (file->private_data == NULL) {
696 FreeXid(xid);
697 return -EBADF;
698 }
Steve French08547b02006-02-28 22:39:25 +0000699 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000701 posix_locking = (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
702 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability));
Steve French08547b02006-02-28 22:39:25 +0000703
704 /* BB add code here to normalize offset and length to
705 account for negative length which we can not accept over the
706 wire */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 if (IS_GETLK(cmd)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000708 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000709 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000710 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000711 posix_lock_type = CIFS_RDLCK;
712 else
713 posix_lock_type = CIFS_WRLCK;
714 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 1 /* get */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000715 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000716 posix_lock_type, wait_flag);
717 FreeXid(xid);
718 return rc;
719 }
720
721 /* BB we could chain these into one lock request BB */
722 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
723 0, 1, lockType, 0 /* wait flag */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 if (rc == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000725 rc = CIFSSMBLock(xid, pTcon, netfid, length,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 pfLock->fl_start, 1 /* numUnlock */ ,
727 0 /* numLock */ , lockType,
728 0 /* wait flag */ );
729 pfLock->fl_type = F_UNLCK;
730 if (rc != 0)
731 cERROR(1, ("Error unlocking previously locked "
Steve French08547b02006-02-28 22:39:25 +0000732 "range %d during test of lock", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 rc = 0;
734
735 } else {
736 /* if rc == ERR_SHARING_VIOLATION ? */
737 rc = 0; /* do not change lock type to unlock
738 since range in use */
739 }
740
741 FreeXid(xid);
742 return rc;
743 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000744
745 if (!numLock && !numUnlock) {
746 /* if no lock or unlock then nothing
747 to do since we do not know what it is */
748 FreeXid(xid);
749 return -EOPNOTSUPP;
750 }
751
752 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000753 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000754 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000755 posix_lock_type = CIFS_RDLCK;
756 else
757 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +0000758
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000759 if (numUnlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +0000760 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000761
Steve French08547b02006-02-28 22:39:25 +0000762 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000763 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000764 posix_lock_type, wait_flag);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000765 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000766 struct cifsFileInfo *fid =
767 (struct cifsFileInfo *)file->private_data;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000768
769 if (numLock) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000770 rc = CIFSSMBLock(xid, pTcon, netfid, length,
771 pfLock->fl_start,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000772 0, numLock, lockType, wait_flag);
773
774 if (rc == 0) {
775 /* For Windows locks we must store them. */
776 rc = store_file_lock(fid, length,
777 pfLock->fl_start, lockType);
778 }
779 } else if (numUnlock) {
780 /* For each stored lock that this unlock overlaps
781 completely, unlock it. */
782 int stored_rc = 0;
783 struct cifsLockInfo *li, *tmp;
784
Steve French6b70c952006-09-21 07:35:29 +0000785 rc = 0;
Roland Dreier796e5662007-05-03 04:33:45 +0000786 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000787 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
788 if (pfLock->fl_start <= li->offset &&
Steve Frenchc19eb712007-08-24 03:22:48 +0000789 (pfLock->fl_start + length) >=
Jeff Layton39db8102007-08-24 03:16:51 +0000790 (li->offset + li->length)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000791 stored_rc = CIFSSMBLock(xid, pTcon,
792 netfid,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000793 li->length, li->offset,
Steve French4b18f2a2008-04-29 00:06:05 +0000794 1, 0, li->type, false);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000795 if (stored_rc)
796 rc = stored_rc;
797
798 list_del(&li->llist);
799 kfree(li);
800 }
801 }
Roland Dreier796e5662007-05-03 04:33:45 +0000802 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000803 }
804 }
805
Steve Frenchd634cc12005-08-26 14:42:59 -0500806 if (pfLock->fl_flags & FL_POSIX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 posix_lock_file_wait(file, pfLock);
808 FreeXid(xid);
809 return rc;
810}
811
812ssize_t cifs_user_write(struct file *file, const char __user *write_data,
813 size_t write_size, loff_t *poffset)
814{
815 int rc = 0;
816 unsigned int bytes_written = 0;
817 unsigned int total_written;
818 struct cifs_sb_info *cifs_sb;
819 struct cifsTconInfo *pTcon;
820 int xid, long_op;
821 struct cifsFileInfo *open_file;
822
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800823 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
825 pTcon = cifs_sb->tcon;
826
827 /* cFYI(1,
828 (" write %d bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800829 *poffset, file->f_path.dentry->d_name.name)); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
831 if (file->private_data == NULL)
832 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000833 open_file = (struct cifsFileInfo *) file->private_data;
Steve French50c2f752007-07-13 00:33:32 +0000834
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800837 if (*poffset > file->f_path.dentry->d_inode->i_size)
Steve French133672e2007-11-13 22:41:37 +0000838 long_op = CIFS_VLONG_OP; /* writes past EOF take long time */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 else
Steve French133672e2007-11-13 22:41:37 +0000840 long_op = CIFS_LONG_OP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
842 for (total_written = 0; write_size > total_written;
843 total_written += bytes_written) {
844 rc = -EAGAIN;
845 while (rc == -EAGAIN) {
846 if (file->private_data == NULL) {
847 /* file has been closed on us */
848 FreeXid(xid);
849 /* if we have gotten here we have written some data
850 and blocked, and the file has been freed on us while
851 we blocked so return what we managed to write */
852 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000853 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 if (open_file->closePend) {
855 FreeXid(xid);
856 if (total_written)
857 return total_written;
858 else
859 return -EBADF;
860 }
861 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 /* we could deadlock if we called
863 filemap_fdatawait from here so tell
864 reopen_file not to flush data to server
865 now */
Steve French4b18f2a2008-04-29 00:06:05 +0000866 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 if (rc != 0)
868 break;
869 }
870
871 rc = CIFSSMBWrite(xid, pTcon,
872 open_file->netfid,
873 min_t(const int, cifs_sb->wsize,
874 write_size - total_written),
875 *poffset, &bytes_written,
876 NULL, write_data + total_written, long_op);
877 }
878 if (rc || (bytes_written == 0)) {
879 if (total_written)
880 break;
881 else {
882 FreeXid(xid);
883 return rc;
884 }
885 } else
886 *poffset += bytes_written;
Steve French133672e2007-11-13 22:41:37 +0000887 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 15 seconds is plenty */
889 }
890
Steve Frencha4544342005-08-24 13:59:35 -0700891 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
893 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +0000894 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
895 struct inode *inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000896/* Do not update local mtime - server will set its actual value on write
897 * inode->i_ctime = inode->i_mtime =
Steve French3677db12007-02-26 16:46:11 +0000898 * current_fs_time(inode->i_sb);*/
899 if (total_written > 0) {
900 spin_lock(&inode->i_lock);
901 if (*poffset > file->f_path.dentry->d_inode->i_size)
902 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 *poffset);
Steve French3677db12007-02-26 16:46:11 +0000904 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000906 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 }
908 FreeXid(xid);
909 return total_written;
910}
911
912static ssize_t cifs_write(struct file *file, const char *write_data,
913 size_t write_size, loff_t *poffset)
914{
915 int rc = 0;
916 unsigned int bytes_written = 0;
917 unsigned int total_written;
918 struct cifs_sb_info *cifs_sb;
919 struct cifsTconInfo *pTcon;
920 int xid, long_op;
921 struct cifsFileInfo *open_file;
922
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800923 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924
925 pTcon = cifs_sb->tcon;
926
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000927 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800928 *poffset, file->f_path.dentry->d_name.name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929
930 if (file->private_data == NULL)
931 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000932 open_file = (struct cifsFileInfo *)file->private_data;
Steve French50c2f752007-07-13 00:33:32 +0000933
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800936 if (*poffset > file->f_path.dentry->d_inode->i_size)
Steve French133672e2007-11-13 22:41:37 +0000937 long_op = CIFS_VLONG_OP; /* writes past EOF can be slow */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 else
Steve French133672e2007-11-13 22:41:37 +0000939 long_op = CIFS_LONG_OP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940
941 for (total_written = 0; write_size > total_written;
942 total_written += bytes_written) {
943 rc = -EAGAIN;
944 while (rc == -EAGAIN) {
945 if (file->private_data == NULL) {
946 /* file has been closed on us */
947 FreeXid(xid);
948 /* if we have gotten here we have written some data
949 and blocked, and the file has been freed on us
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000950 while we blocked so return what we managed to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 write */
952 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000953 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954 if (open_file->closePend) {
955 FreeXid(xid);
956 if (total_written)
957 return total_written;
958 else
959 return -EBADF;
960 }
961 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 /* we could deadlock if we called
963 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000964 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965 server now */
Steve French4b18f2a2008-04-29 00:06:05 +0000966 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 if (rc != 0)
968 break;
969 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000970 if (experimEnabled || (pTcon->ses->server &&
971 ((pTcon->ses->server->secMode &
Steve French08775832006-05-30 18:08:26 +0000972 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +0000973 == 0))) {
Steve French3e844692005-10-03 13:37:24 -0700974 struct kvec iov[2];
975 unsigned int len;
976
Steve French0ae0efa2005-10-10 10:57:19 -0700977 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -0700978 write_size - total_written);
979 /* iov[0] is reserved for smb header */
980 iov[1].iov_base = (char *)write_data +
981 total_written;
982 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500983 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -0700984 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500985 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -0700986 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500987 } else
Steve French60808232006-04-22 15:53:05 +0000988 rc = CIFSSMBWrite(xid, pTcon,
989 open_file->netfid,
990 min_t(const int, cifs_sb->wsize,
991 write_size - total_written),
992 *poffset, &bytes_written,
993 write_data + total_written,
994 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 }
996 if (rc || (bytes_written == 0)) {
997 if (total_written)
998 break;
999 else {
1000 FreeXid(xid);
1001 return rc;
1002 }
1003 } else
1004 *poffset += bytes_written;
Steve French133672e2007-11-13 22:41:37 +00001005 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 15 seconds is plenty */
1007 }
1008
Steve Frencha4544342005-08-24 13:59:35 -07001009 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010
1011 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001012 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
Steve French004c46b2007-02-17 04:34:13 +00001013/*BB We could make this contingent on superblock ATIME flag too */
Steve French3677db12007-02-26 16:46:11 +00001014/* file->f_path.dentry->d_inode->i_ctime =
1015 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1016 if (total_written > 0) {
1017 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1018 if (*poffset > file->f_path.dentry->d_inode->i_size)
1019 i_size_write(file->f_path.dentry->d_inode,
1020 *poffset);
1021 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 }
Steve French3677db12007-02-26 16:46:11 +00001023 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 }
1025 FreeXid(xid);
1026 return total_written;
1027}
1028
Steve French630f3f02007-10-25 21:17:17 +00001029#ifdef CONFIG_CIFS_EXPERIMENTAL
1030struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1031{
1032 struct cifsFileInfo *open_file = NULL;
1033
1034 read_lock(&GlobalSMBSeslock);
1035 /* we could simply get the first_list_entry since write-only entries
1036 are always at the end of the list but since the first entry might
1037 have a close pending, we go through the whole list */
1038 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1039 if (open_file->closePend)
1040 continue;
1041 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1042 (open_file->pfile->f_flags & O_RDONLY))) {
1043 if (!open_file->invalidHandle) {
1044 /* found a good file */
1045 /* lock it so it will not be closed on us */
1046 atomic_inc(&open_file->wrtPending);
1047 read_unlock(&GlobalSMBSeslock);
1048 return open_file;
1049 } /* else might as well continue, and look for
1050 another, or simply have the caller reopen it
1051 again rather than trying to fix this handle */
1052 } else /* write only file */
1053 break; /* write only files are last so must be done */
1054 }
1055 read_unlock(&GlobalSMBSeslock);
1056 return NULL;
1057}
1058#endif
1059
Steve Frenchdd99cd82005-10-05 19:32:49 -07001060struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
Steve French6148a742005-10-05 12:23:19 -07001061{
1062 struct cifsFileInfo *open_file;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001063 int rc;
Steve French6148a742005-10-05 12:23:19 -07001064
Steve French60808232006-04-22 15:53:05 +00001065 /* Having a null inode here (because mapping->host was set to zero by
1066 the VFS or MM) should not happen but we had reports of on oops (due to
1067 it being zero) during stress testcases so we need to check for it */
1068
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001069 if (cifs_inode == NULL) {
1070 cERROR(1, ("Null inode passed to cifs_writeable_file"));
Steve French60808232006-04-22 15:53:05 +00001071 dump_stack();
1072 return NULL;
1073 }
1074
Steve French6148a742005-10-05 12:23:19 -07001075 read_lock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001076refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001077 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1078 if (open_file->closePend)
1079 continue;
1080 if (open_file->pfile &&
1081 ((open_file->pfile->f_flags & O_RDWR) ||
1082 (open_file->pfile->f_flags & O_WRONLY))) {
Steve French23e7dd72005-10-20 13:44:56 -07001083 atomic_inc(&open_file->wrtPending);
Steve French9b22b0b2007-10-02 01:11:08 +00001084
1085 if (!open_file->invalidHandle) {
1086 /* found a good writable file */
1087 read_unlock(&GlobalSMBSeslock);
1088 return open_file;
1089 }
Steve French8840dee2007-11-16 23:05:52 +00001090
Steve French6148a742005-10-05 12:23:19 -07001091 read_unlock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001092 /* Had to unlock since following call can block */
Steve French4b18f2a2008-04-29 00:06:05 +00001093 rc = cifs_reopen_file(open_file->pfile, false);
Steve French8840dee2007-11-16 23:05:52 +00001094 if (!rc) {
Steve French9b22b0b2007-10-02 01:11:08 +00001095 if (!open_file->closePend)
1096 return open_file;
1097 else { /* start over in case this was deleted */
1098 /* since the list could be modified */
Steve French37c0eb42005-10-05 14:50:29 -07001099 read_lock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +00001100 atomic_dec(&open_file->wrtPending);
Steve French9b22b0b2007-10-02 01:11:08 +00001101 goto refind_writable;
Steve French37c0eb42005-10-05 14:50:29 -07001102 }
1103 }
Steve French9b22b0b2007-10-02 01:11:08 +00001104
1105 /* if it fails, try another handle if possible -
1106 (we can not do this if closePending since
1107 loop could be modified - in which case we
1108 have to start at the beginning of the list
1109 again. Note that it would be bad
1110 to hold up writepages here (rather than
1111 in caller) with continuous retries */
1112 cFYI(1, ("wp failed on reopen file"));
1113 read_lock(&GlobalSMBSeslock);
1114 /* can not use this handle, no write
1115 pending on this one after all */
1116 atomic_dec(&open_file->wrtPending);
Steve French8840dee2007-11-16 23:05:52 +00001117
Steve French9b22b0b2007-10-02 01:11:08 +00001118 if (open_file->closePend) /* list could have changed */
1119 goto refind_writable;
1120 /* else we simply continue to the next entry. Thus
1121 we do not loop on reopen errors. If we
1122 can not reopen the file, for example if we
1123 reconnected to a server with another client
1124 racing to delete or lock the file we would not
1125 make progress if we restarted before the beginning
1126 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001127 }
1128 }
1129 read_unlock(&GlobalSMBSeslock);
1130 return NULL;
1131}
1132
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1134{
1135 struct address_space *mapping = page->mapping;
1136 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1137 char *write_data;
1138 int rc = -EFAULT;
1139 int bytes_written = 0;
1140 struct cifs_sb_info *cifs_sb;
1141 struct cifsTconInfo *pTcon;
1142 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001143 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144
1145 if (!mapping || !mapping->host)
1146 return -EFAULT;
1147
1148 inode = page->mapping->host;
1149 cifs_sb = CIFS_SB(inode->i_sb);
1150 pTcon = cifs_sb->tcon;
1151
1152 offset += (loff_t)from;
1153 write_data = kmap(page);
1154 write_data += from;
1155
1156 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1157 kunmap(page);
1158 return -EIO;
1159 }
1160
1161 /* racing with truncate? */
1162 if (offset > mapping->host->i_size) {
1163 kunmap(page);
1164 return 0; /* don't care */
1165 }
1166
1167 /* check to make sure that we are not extending the file */
1168 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001169 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170
Steve French6148a742005-10-05 12:23:19 -07001171 open_file = find_writable_file(CIFS_I(mapping->host));
1172 if (open_file) {
1173 bytes_written = cifs_write(open_file->pfile, write_data,
1174 to-from, &offset);
Steve French23e7dd72005-10-20 13:44:56 -07001175 atomic_dec(&open_file->wrtPending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001177 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001178 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001179 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001180 else if (bytes_written < 0)
1181 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001182 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 cFYI(1, ("No writeable filehandles for inode"));
1184 rc = -EIO;
1185 }
1186
1187 kunmap(page);
1188 return rc;
1189}
1190
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001192 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193{
Steve French37c0eb42005-10-05 14:50:29 -07001194 struct backing_dev_info *bdi = mapping->backing_dev_info;
1195 unsigned int bytes_to_write;
1196 unsigned int bytes_written;
1197 struct cifs_sb_info *cifs_sb;
1198 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001199 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001200 pgoff_t index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001201 int range_whole = 0;
1202 struct kvec *iov;
Steve French84d2f072005-10-12 15:32:05 -07001203 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001204 int n_iov = 0;
1205 pgoff_t next;
1206 int nr_pages;
1207 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001208 struct cifsFileInfo *open_file;
Steve French37c0eb42005-10-05 14:50:29 -07001209 struct page *page;
1210 struct pagevec pvec;
1211 int rc = 0;
1212 int scanned = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 int xid;
1214
Steve French37c0eb42005-10-05 14:50:29 -07001215 cifs_sb = CIFS_SB(mapping->host->i_sb);
Steve French50c2f752007-07-13 00:33:32 +00001216
Steve French37c0eb42005-10-05 14:50:29 -07001217 /*
1218 * If wsize is smaller that the page cache size, default to writing
1219 * one page at a time via cifs_writepage
1220 */
1221 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1222 return generic_writepages(mapping, wbc);
1223
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001224 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1225 if (cifs_sb->tcon->ses->server->secMode &
1226 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1227 if (!experimEnabled)
Steve French60808232006-04-22 15:53:05 +00001228 return generic_writepages(mapping, wbc);
Steve French4a771182005-10-05 15:14:33 -07001229
Steve French9a0c8232007-02-02 04:21:57 +00001230 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001231 if (iov == NULL)
Steve French9a0c8232007-02-02 04:21:57 +00001232 return generic_writepages(mapping, wbc);
1233
1234
Steve French37c0eb42005-10-05 14:50:29 -07001235 /*
1236 * BB: Is this meaningful for a non-block-device file system?
1237 * If it is, we should test it again after we do I/O
1238 */
1239 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1240 wbc->encountered_congestion = 1;
Steve French9a0c8232007-02-02 04:21:57 +00001241 kfree(iov);
Steve French37c0eb42005-10-05 14:50:29 -07001242 return 0;
1243 }
1244
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 xid = GetXid();
1246
Steve French37c0eb42005-10-05 14:50:29 -07001247 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001248 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001249 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001250 end = -1;
1251 } else {
1252 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1253 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1254 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1255 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001256 scanned = 1;
1257 }
1258retry:
1259 while (!done && (index <= end) &&
1260 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1261 PAGECACHE_TAG_DIRTY,
1262 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1263 int first;
1264 unsigned int i;
1265
Steve French37c0eb42005-10-05 14:50:29 -07001266 first = -1;
1267 next = 0;
1268 n_iov = 0;
1269 bytes_to_write = 0;
1270
1271 for (i = 0; i < nr_pages; i++) {
1272 page = pvec.pages[i];
1273 /*
1274 * At this point we hold neither mapping->tree_lock nor
1275 * lock on the page itself: the page may be truncated or
1276 * invalidated (changing page->mapping to NULL), or even
1277 * swizzled back from swapper_space to tmpfs file
1278 * mapping
1279 */
1280
1281 if (first < 0)
1282 lock_page(page);
1283 else if (TestSetPageLocked(page))
1284 break;
1285
1286 if (unlikely(page->mapping != mapping)) {
1287 unlock_page(page);
1288 break;
1289 }
1290
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001291 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001292 done = 1;
1293 unlock_page(page);
1294 break;
1295 }
1296
1297 if (next && (page->index != next)) {
1298 /* Not next consecutive page */
1299 unlock_page(page);
1300 break;
1301 }
1302
1303 if (wbc->sync_mode != WB_SYNC_NONE)
1304 wait_on_page_writeback(page);
1305
1306 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001307 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001308 unlock_page(page);
1309 break;
1310 }
Steve French84d2f072005-10-12 15:32:05 -07001311
Linus Torvaldscb876f42006-12-23 16:19:07 -08001312 /*
1313 * This actually clears the dirty bit in the radix tree.
1314 * See cifs_writepage() for more commentary.
1315 */
1316 set_page_writeback(page);
1317
Steve French84d2f072005-10-12 15:32:05 -07001318 if (page_offset(page) >= mapping->host->i_size) {
1319 done = 1;
1320 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001321 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001322 break;
1323 }
1324
Steve French37c0eb42005-10-05 14:50:29 -07001325 /*
1326 * BB can we get rid of this? pages are held by pvec
1327 */
1328 page_cache_get(page);
1329
Steve French84d2f072005-10-12 15:32:05 -07001330 len = min(mapping->host->i_size - page_offset(page),
1331 (loff_t)PAGE_CACHE_SIZE);
1332
Steve French37c0eb42005-10-05 14:50:29 -07001333 /* reserve iov[0] for the smb header */
1334 n_iov++;
1335 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001336 iov[n_iov].iov_len = len;
1337 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001338
1339 if (first < 0) {
1340 first = i;
1341 offset = page_offset(page);
1342 }
1343 next = page->index + 1;
1344 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1345 break;
1346 }
1347 if (n_iov) {
Steve French23e7dd72005-10-20 13:44:56 -07001348 /* Search for a writable handle every time we call
1349 * CIFSSMBWrite2. We can't rely on the last handle
1350 * we used to still be valid
1351 */
1352 open_file = find_writable_file(CIFS_I(mapping->host));
1353 if (!open_file) {
1354 cERROR(1, ("No writable handles for inode"));
1355 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001356 } else {
Steve French23e7dd72005-10-20 13:44:56 -07001357 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1358 open_file->netfid,
1359 bytes_to_write, offset,
1360 &bytes_written, iov, n_iov,
Steve French133672e2007-11-13 22:41:37 +00001361 CIFS_LONG_OP);
Steve French23e7dd72005-10-20 13:44:56 -07001362 atomic_dec(&open_file->wrtPending);
1363 if (rc || bytes_written < bytes_to_write) {
Steve French63135e02007-07-17 17:34:02 +00001364 cERROR(1, ("Write2 ret %d, wrote %d",
Steve French23e7dd72005-10-20 13:44:56 -07001365 rc, bytes_written));
1366 /* BB what if continued retry is
1367 requested via mount flags? */
Jeff Laytoncea21802007-11-20 23:19:03 +00001368 if (rc == -ENOSPC)
1369 set_bit(AS_ENOSPC, &mapping->flags);
1370 else
1371 set_bit(AS_EIO, &mapping->flags);
Steve French23e7dd72005-10-20 13:44:56 -07001372 } else {
1373 cifs_stats_bytes_written(cifs_sb->tcon,
1374 bytes_written);
1375 }
Steve French37c0eb42005-10-05 14:50:29 -07001376 }
1377 for (i = 0; i < n_iov; i++) {
1378 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001379 /* Should we also set page error on
1380 success rc but too little data written? */
1381 /* BB investigate retry logic on temporary
1382 server crash cases and how recovery works
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001383 when page marked as error */
1384 if (rc)
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001385 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001386 kunmap(page);
1387 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001388 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001389 page_cache_release(page);
1390 }
1391 if ((wbc->nr_to_write -= n_iov) <= 0)
1392 done = 1;
1393 index = next;
1394 }
1395 pagevec_release(&pvec);
1396 }
1397 if (!scanned && !done) {
1398 /*
1399 * We hit the last page and there is more work to be done: wrap
1400 * back to the start of the file
1401 */
1402 scanned = 1;
1403 index = 0;
1404 goto retry;
1405 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001406 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001407 mapping->writeback_index = index;
1408
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001410 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411 return rc;
1412}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001414static int cifs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415{
1416 int rc = -EFAULT;
1417 int xid;
1418
1419 xid = GetXid();
1420/* BB add check for wbc flags */
1421 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001422 if (!PageUptodate(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 cFYI(1, ("ppw - page not up to date"));
Linus Torvaldscb876f42006-12-23 16:19:07 -08001424
1425 /*
1426 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1427 *
1428 * A writepage() implementation always needs to do either this,
1429 * or re-dirty the page with "redirty_page_for_writepage()" in
1430 * the case of a failure.
1431 *
1432 * Just unlocking the page will cause the radix tree tag-bits
1433 * to fail to update with the state of the page correctly.
1434 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001435 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1437 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1438 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001439 end_page_writeback(page);
1440 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 FreeXid(xid);
1442 return rc;
1443}
1444
1445static int cifs_commit_write(struct file *file, struct page *page,
1446 unsigned offset, unsigned to)
1447{
1448 int xid;
1449 int rc = 0;
1450 struct inode *inode = page->mapping->host;
1451 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1452 char *page_data;
1453
1454 xid = GetXid();
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001455 cFYI(1, ("commit write for page %p up to position %lld for %d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456 page, position, to));
Steve French3677db12007-02-26 16:46:11 +00001457 spin_lock(&inode->i_lock);
Steve Frenchad7a2922008-02-07 23:25:02 +00001458 if (position > inode->i_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 i_size_write(inode, position);
Steve Frenchad7a2922008-02-07 23:25:02 +00001460
Steve French3677db12007-02-26 16:46:11 +00001461 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462 if (!PageUptodate(page)) {
1463 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1464 /* can not rely on (or let) writepage write this data */
1465 if (to < offset) {
1466 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1467 offset, to));
1468 FreeXid(xid);
1469 return rc;
1470 }
1471 /* this is probably better than directly calling
1472 partialpage_write since in this function the file handle is
1473 known which we might as well leverage */
1474 /* BB check if anything else missing out of ppw
1475 such as updating last write time */
1476 page_data = kmap(page);
1477 rc = cifs_write(file, page_data + offset, to-offset,
1478 &position);
1479 if (rc > 0)
1480 rc = 0;
1481 /* else if (rc < 0) should we set writebehind rc? */
1482 kunmap(page);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001483 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 set_page_dirty(page);
1485 }
1486
1487 FreeXid(xid);
1488 return rc;
1489}
1490
1491int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1492{
1493 int xid;
1494 int rc = 0;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001495 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496
1497 xid = GetXid();
1498
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001499 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 dentry->d_name.name, datasync));
Steve French50c2f752007-07-13 00:33:32 +00001501
Jeff Laytoncea21802007-11-20 23:19:03 +00001502 rc = filemap_write_and_wait(inode->i_mapping);
1503 if (rc == 0) {
1504 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001505 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001506 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 FreeXid(xid);
1508 return rc;
1509}
1510
NeilBrown3978d712006-03-26 01:37:17 -08001511/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512{
1513 struct address_space *mapping;
1514 struct inode *inode;
1515 unsigned long index = page->index;
1516 unsigned int rpages = 0;
1517 int rc = 0;
1518
1519 cFYI(1, ("sync page %p",page));
1520 mapping = page->mapping;
1521 if (!mapping)
1522 return 0;
1523 inode = mapping->host;
1524 if (!inode)
NeilBrown3978d712006-03-26 01:37:17 -08001525 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001527/* fill in rpages then
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1529
Steve French26a21b92006-05-31 18:05:34 +00001530/* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531
NeilBrown3978d712006-03-26 01:37:17 -08001532#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 if (rc < 0)
1534 return rc;
1535 return 0;
NeilBrown3978d712006-03-26 01:37:17 -08001536#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537} */
1538
1539/*
1540 * As file closes, flush all cached write data for this inode checking
1541 * for write behind errors.
1542 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001543int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001545 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 int rc = 0;
1547
1548 /* Rather than do the steps manually:
1549 lock the inode for writing
1550 loop through pages looking for write behind data (dirty pages)
1551 coalesce into contiguous 16K (or smaller) chunks to write to server
1552 send to server (prefer in parallel)
1553 deal with writebehind errors
1554 unlock inode for writing
1555 filemapfdatawrite appears easier for the time being */
1556
1557 rc = filemap_fdatawrite(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +00001558 /* reset wb rc if we were able to write out dirty pages */
1559 if (!rc) {
1560 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001562 }
Steve French50c2f752007-07-13 00:33:32 +00001563
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001564 cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001565
1566 return rc;
1567}
1568
1569ssize_t cifs_user_read(struct file *file, char __user *read_data,
1570 size_t read_size, loff_t *poffset)
1571{
1572 int rc = -EACCES;
1573 unsigned int bytes_read = 0;
1574 unsigned int total_read = 0;
1575 unsigned int current_read_size;
1576 struct cifs_sb_info *cifs_sb;
1577 struct cifsTconInfo *pTcon;
1578 int xid;
1579 struct cifsFileInfo *open_file;
1580 char *smb_read_data;
1581 char __user *current_offset;
1582 struct smb_com_read_rsp *pSMBr;
1583
1584 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001585 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 pTcon = cifs_sb->tcon;
1587
1588 if (file->private_data == NULL) {
1589 FreeXid(xid);
1590 return -EBADF;
1591 }
1592 open_file = (struct cifsFileInfo *)file->private_data;
1593
Steve Frenchad7a2922008-02-07 23:25:02 +00001594 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 cFYI(1, ("attempting read on write only file instance"));
Steve Frenchad7a2922008-02-07 23:25:02 +00001596
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597 for (total_read = 0, current_offset = read_data;
1598 read_size > total_read;
1599 total_read += bytes_read, current_offset += bytes_read) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001600 current_read_size = min_t(const int, read_size - total_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 cifs_sb->rsize);
1602 rc = -EAGAIN;
1603 smb_read_data = NULL;
1604 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001605 int buf_type = CIFS_NO_BUFFER;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001606 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001608 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 if (rc != 0)
1610 break;
1611 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001612 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001613 open_file->netfid,
1614 current_read_size, *poffset,
1615 &bytes_read, &smb_read_data,
1616 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001619 if (copy_to_user(current_offset,
1620 smb_read_data +
1621 4 /* RFC1001 length field */ +
1622 le16_to_cpu(pSMBr->DataOffset),
Steve Frenchad7a2922008-02-07 23:25:02 +00001623 bytes_read))
Steve French93544cc2006-02-14 22:30:52 -06001624 rc = -EFAULT;
Steve French93544cc2006-02-14 22:30:52 -06001625
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001626 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001627 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001628 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001629 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 smb_read_data = NULL;
1631 }
1632 }
1633 if (rc || (bytes_read == 0)) {
1634 if (total_read) {
1635 break;
1636 } else {
1637 FreeXid(xid);
1638 return rc;
1639 }
1640 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001641 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 *poffset += bytes_read;
1643 }
1644 }
1645 FreeXid(xid);
1646 return total_read;
1647}
1648
1649
1650static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1651 loff_t *poffset)
1652{
1653 int rc = -EACCES;
1654 unsigned int bytes_read = 0;
1655 unsigned int total_read;
1656 unsigned int current_read_size;
1657 struct cifs_sb_info *cifs_sb;
1658 struct cifsTconInfo *pTcon;
1659 int xid;
1660 char *current_offset;
1661 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001662 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
1664 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001665 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 pTcon = cifs_sb->tcon;
1667
1668 if (file->private_data == NULL) {
1669 FreeXid(xid);
1670 return -EBADF;
1671 }
1672 open_file = (struct cifsFileInfo *)file->private_data;
1673
1674 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1675 cFYI(1, ("attempting read on write only file instance"));
1676
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001677 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 read_size > total_read;
1679 total_read += bytes_read, current_offset += bytes_read) {
1680 current_read_size = min_t(const int, read_size - total_read,
1681 cifs_sb->rsize);
Steve Frenchf9f5c812005-09-15 23:06:38 -07001682 /* For windows me and 9x we do not want to request more
1683 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001684 if ((pTcon->ses) &&
Steve Frenchf9f5c812005-09-15 23:06:38 -07001685 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1686 current_read_size = min_t(const int, current_read_size,
1687 pTcon->ses->server->maxBuf - 128);
1688 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 rc = -EAGAIN;
1690 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001691 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001693 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694 if (rc != 0)
1695 break;
1696 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001697 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001698 open_file->netfid,
1699 current_read_size, *poffset,
1700 &bytes_read, &current_offset,
1701 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 }
1703 if (rc || (bytes_read == 0)) {
1704 if (total_read) {
1705 break;
1706 } else {
1707 FreeXid(xid);
1708 return rc;
1709 }
1710 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001711 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 *poffset += bytes_read;
1713 }
1714 }
1715 FreeXid(xid);
1716 return total_read;
1717}
1718
1719int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1720{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001721 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722 int rc, xid;
1723
1724 xid = GetXid();
1725 rc = cifs_revalidate(dentry);
1726 if (rc) {
1727 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1728 FreeXid(xid);
1729 return rc;
1730 }
1731 rc = generic_file_mmap(file, vma);
1732 FreeXid(xid);
1733 return rc;
1734}
1735
1736
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001737static void cifs_copy_cache_pages(struct address_space *mapping,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 struct list_head *pages, int bytes_read, char *data,
1739 struct pagevec *plru_pvec)
1740{
1741 struct page *page;
1742 char *target;
1743
1744 while (bytes_read > 0) {
1745 if (list_empty(pages))
1746 break;
1747
1748 page = list_entry(pages->prev, struct page, lru);
1749 list_del(&page->lru);
1750
1751 if (add_to_page_cache(page, mapping, page->index,
1752 GFP_KERNEL)) {
1753 page_cache_release(page);
1754 cFYI(1, ("Add page cache failed"));
Steve French3079ca62005-06-09 14:44:07 -07001755 data += PAGE_CACHE_SIZE;
1756 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 continue;
1758 }
1759
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001760 target = kmap_atomic(page, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761
1762 if (PAGE_CACHE_SIZE > bytes_read) {
1763 memcpy(target, data, bytes_read);
1764 /* zero the tail end of this partial page */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001765 memset(target + bytes_read, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 PAGE_CACHE_SIZE - bytes_read);
1767 bytes_read = 0;
1768 } else {
1769 memcpy(target, data, PAGE_CACHE_SIZE);
1770 bytes_read -= PAGE_CACHE_SIZE;
1771 }
1772 kunmap_atomic(target, KM_USER0);
1773
1774 flush_dcache_page(page);
1775 SetPageUptodate(page);
1776 unlock_page(page);
1777 if (!pagevec_add(plru_pvec, page))
1778 __pagevec_lru_add(plru_pvec);
1779 data += PAGE_CACHE_SIZE;
1780 }
1781 return;
1782}
1783
1784static int cifs_readpages(struct file *file, struct address_space *mapping,
1785 struct list_head *page_list, unsigned num_pages)
1786{
1787 int rc = -EACCES;
1788 int xid;
1789 loff_t offset;
1790 struct page *page;
1791 struct cifs_sb_info *cifs_sb;
1792 struct cifsTconInfo *pTcon;
Steve French2c2130e2007-10-12 19:10:28 +00001793 unsigned int bytes_read = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001794 unsigned int read_size, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795 char *smb_read_data = NULL;
1796 struct smb_com_read_rsp *pSMBr;
1797 struct pagevec lru_pvec;
1798 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001799 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800
1801 xid = GetXid();
1802 if (file->private_data == NULL) {
1803 FreeXid(xid);
1804 return -EBADF;
1805 }
1806 open_file = (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001807 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 pTcon = cifs_sb->tcon;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001809
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 pagevec_init(&lru_pvec, 0);
Steve French90c81e02008-02-12 20:32:36 +00001811 cFYI(DBG2, ("rpages: num pages %d", num_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 for (i = 0; i < num_pages; ) {
1813 unsigned contig_pages;
1814 struct page *tmp_page;
1815 unsigned long expected_index;
1816
1817 if (list_empty(page_list))
1818 break;
1819
1820 page = list_entry(page_list->prev, struct page, lru);
1821 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1822
1823 /* count adjacent pages that we will read into */
1824 contig_pages = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001825 expected_index =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 list_entry(page_list->prev, struct page, lru)->index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001827 list_for_each_entry_reverse(tmp_page, page_list, lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 if (tmp_page->index == expected_index) {
1829 contig_pages++;
1830 expected_index++;
1831 } else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001832 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833 }
1834 if (contig_pages + i > num_pages)
1835 contig_pages = num_pages - i;
1836
1837 /* for reads over a certain size could initiate async
1838 read ahead */
1839
1840 read_size = contig_pages * PAGE_CACHE_SIZE;
1841 /* Read size needs to be in multiples of one page */
1842 read_size = min_t(const unsigned int, read_size,
1843 cifs_sb->rsize & PAGE_CACHE_MASK);
Steve French90c81e02008-02-12 20:32:36 +00001844 cFYI(DBG2, ("rpages: read size 0x%x contiguous pages %d",
Steve French75865f82007-06-24 18:30:48 +00001845 read_size, contig_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 rc = -EAGAIN;
1847 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001848 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001850 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 if (rc != 0)
1852 break;
1853 }
1854
Steve Frenchbfa0d752005-08-31 21:50:37 -07001855 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001856 open_file->netfid,
1857 read_size, offset,
1858 &bytes_read, &smb_read_data,
1859 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001860 /* BB more RC checks ? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001861 if (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001863 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001864 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001865 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001866 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 smb_read_data = NULL;
1868 }
1869 }
1870 }
1871 if ((rc < 0) || (smb_read_data == NULL)) {
1872 cFYI(1, ("Read error in readpages: %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 break;
1874 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08001875 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001876 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1877 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1878 smb_read_data + 4 /* RFC1001 hdr */ +
1879 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1880
1881 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha4544342005-08-24 13:59:35 -07001882 cifs_stats_bytes_read(pTcon, bytes_read);
Steve French2c2130e2007-10-12 19:10:28 +00001883 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 i++; /* account for partial page */
1885
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001886 /* server copy of file can have smaller size
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 than client */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001888 /* BB do we need to verify this common case ?
1889 this case is ok - if we are at server EOF
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 we will hit it on next read */
1891
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08001892 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 }
1894 } else {
1895 cFYI(1, ("No bytes read (%d) at offset %lld . "
1896 "Cleaning remaining pages from readahead list",
1897 bytes_read, offset));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001898 /* BB turn off caching and do new lookup on
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 break;
1901 }
1902 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001903 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001904 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001905 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001906 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907 smb_read_data = NULL;
1908 }
1909 bytes_read = 0;
1910 }
1911
1912 pagevec_lru_add(&lru_pvec);
1913
1914/* need to free smb_read_data buf before exit */
1915 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001916 if (buf_type == CIFS_SMALL_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08001917 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001918 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08001919 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 smb_read_data = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001921 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922
1923 FreeXid(xid);
1924 return rc;
1925}
1926
1927static int cifs_readpage_worker(struct file *file, struct page *page,
1928 loff_t *poffset)
1929{
1930 char *read_data;
1931 int rc;
1932
1933 page_cache_get(page);
1934 read_data = kmap(page);
1935 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001936
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001938
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939 if (rc < 0)
1940 goto io_error;
1941 else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001942 cFYI(1, ("Bytes read %d", rc));
1943
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001944 file->f_path.dentry->d_inode->i_atime =
1945 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001946
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 if (PAGE_CACHE_SIZE > rc)
1948 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1949
1950 flush_dcache_page(page);
1951 SetPageUptodate(page);
1952 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001953
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001955 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001956 page_cache_release(page);
1957 return rc;
1958}
1959
1960static int cifs_readpage(struct file *file, struct page *page)
1961{
1962 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1963 int rc = -EACCES;
1964 int xid;
1965
1966 xid = GetXid();
1967
1968 if (file->private_data == NULL) {
1969 FreeXid(xid);
1970 return -EBADF;
1971 }
1972
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001973 cFYI(1, ("readpage %p at offset %d 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 page, (int)offset, (int)offset));
1975
1976 rc = cifs_readpage_worker(file, page, &offset);
1977
1978 unlock_page(page);
1979
1980 FreeXid(xid);
1981 return rc;
1982}
1983
Steve Frencha403a0a2007-07-26 15:54:16 +00001984static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
1985{
1986 struct cifsFileInfo *open_file;
1987
1988 read_lock(&GlobalSMBSeslock);
1989 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1990 if (open_file->closePend)
1991 continue;
1992 if (open_file->pfile &&
1993 ((open_file->pfile->f_flags & O_RDWR) ||
1994 (open_file->pfile->f_flags & O_WRONLY))) {
1995 read_unlock(&GlobalSMBSeslock);
1996 return 1;
1997 }
1998 }
1999 read_unlock(&GlobalSMBSeslock);
2000 return 0;
2001}
2002
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003/* We do not want to update the file size from server for inodes
2004 open for write - to avoid races with writepage extending
2005 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002006 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002007 but this is tricky to do without racing with writebehind
2008 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00002009bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010{
Steve Frencha403a0a2007-07-26 15:54:16 +00002011 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00002012 return true;
Steve French23e7dd72005-10-20 13:44:56 -07002013
Steve Frencha403a0a2007-07-26 15:54:16 +00002014 if (is_inode_writable(cifsInode)) {
2015 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08002016 struct cifs_sb_info *cifs_sb;
2017
Steve Frenchc32a0b62006-01-12 14:41:28 -08002018 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00002019 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002020 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08002021 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00002022 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08002023 }
2024
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002025 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00002026 return true;
Steve French7ba52632007-02-08 18:14:13 +00002027
Steve French4b18f2a2008-04-29 00:06:05 +00002028 return false;
Steve French23e7dd72005-10-20 13:44:56 -07002029 } else
Steve French4b18f2a2008-04-29 00:06:05 +00002030 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031}
2032
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033static int cifs_prepare_write(struct file *file, struct page *page,
2034 unsigned from, unsigned to)
2035{
2036 int rc = 0;
Steve French8a236262007-03-06 00:31:00 +00002037 loff_t i_size;
2038 loff_t offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002040 cFYI(1, ("prepare write for page %p from %d to %d", page, from, to));
Steve French8a236262007-03-06 00:31:00 +00002041 if (PageUptodate(page))
2042 return 0;
2043
2044 /* If we are writing a full page it will be up to date,
2045 no need to read from the server */
2046 if ((to == PAGE_CACHE_SIZE) && (from == 0)) {
2047 SetPageUptodate(page);
2048 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002049 }
2050
Steve French8a236262007-03-06 00:31:00 +00002051 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2052 i_size = i_size_read(page->mapping->host);
2053
2054 if ((offset >= i_size) ||
2055 ((from == 0) && (offset + to) >= i_size)) {
2056 /*
2057 * We don't need to read data beyond the end of the file.
2058 * zero it, and set the page uptodate
2059 */
Nate88038632007-07-16 15:45:13 +00002060 simple_prepare_write(file, page, from, to);
Steve French8a236262007-03-06 00:31:00 +00002061 SetPageUptodate(page);
2062 } else if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2063 /* might as well read a page, it is fast enough */
2064 rc = cifs_readpage_worker(file, page, &offset);
2065 } else {
2066 /* we could try using another file handle if there is one -
2067 but how would we lock it to prevent close of that handle
2068 racing with this read? In any case
2069 this will be written out by commit_write so is fine */
2070 }
2071
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002072 /* we do not need to pass errors back
2073 e.g. if we do not have read access to the file
Steve French8a236262007-03-06 00:31:00 +00002074 because cifs_commit_write will do the right thing. -- shaggy */
2075
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 return 0;
2077}
2078
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002079const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 .readpage = cifs_readpage,
2081 .readpages = cifs_readpages,
2082 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002083 .writepages = cifs_writepages,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 .prepare_write = cifs_prepare_write,
2085 .commit_write = cifs_commit_write,
2086 .set_page_dirty = __set_page_dirty_nobuffers,
2087 /* .sync_page = cifs_sync_page, */
2088 /* .direct_IO = */
2089};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002090
2091/*
2092 * cifs_readpages requires the server to support a buffer large enough to
2093 * contain the header plus one complete page of data. Otherwise, we need
2094 * to leave cifs_readpages out of the address space operations.
2095 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002096const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002097 .readpage = cifs_readpage,
2098 .writepage = cifs_writepage,
2099 .writepages = cifs_writepages,
2100 .prepare_write = cifs_prepare_write,
2101 .commit_write = cifs_commit_write,
2102 .set_page_dirty = __set_page_dirty_nobuffers,
2103 /* .sync_page = cifs_sync_page, */
2104 /* .direct_IO = */
2105};