blob: 302ea15f02e611fb2d254e68740cb8e1cbdd81c2 [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;
Steve Frencha6ce4932009-04-09 01:14:32 +000049 mutex_init(&private_data->fh_mutex);
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);
Steve French7fc8f4e2009-02-23 20:43:11 +000081}
Jeff Laytone10f7b52008-05-14 10:21:33 -070082
Steve French7fc8f4e2009-02-23 20:43:11 +000083static inline fmode_t cifs_posix_convert_flags(unsigned int flags)
84{
85 fmode_t posix_flags = 0;
Jeff Laytone10f7b52008-05-14 10:21:33 -070086
Steve French7fc8f4e2009-02-23 20:43:11 +000087 if ((flags & O_ACCMODE) == O_RDONLY)
88 posix_flags = FMODE_READ;
89 else if ((flags & O_ACCMODE) == O_WRONLY)
90 posix_flags = FMODE_WRITE;
91 else if ((flags & O_ACCMODE) == O_RDWR) {
92 /* GENERIC_ALL is too much permission to request
93 can cause unnecessary access denied on create */
94 /* return GENERIC_ALL; */
95 posix_flags = FMODE_READ | FMODE_WRITE;
96 }
97 /* can not map O_CREAT or O_EXCL or O_TRUNC flags when
98 reopening a file. They had their effect on the original open */
99 if (flags & O_APPEND)
100 posix_flags |= (fmode_t)O_APPEND;
101 if (flags & O_SYNC)
102 posix_flags |= (fmode_t)O_SYNC;
103 if (flags & O_DIRECTORY)
104 posix_flags |= (fmode_t)O_DIRECTORY;
105 if (flags & O_NOFOLLOW)
106 posix_flags |= (fmode_t)O_NOFOLLOW;
107 if (flags & O_DIRECT)
108 posix_flags |= (fmode_t)O_DIRECT;
109
110 return posix_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111}
112
113static inline int cifs_get_disposition(unsigned int flags)
114{
115 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
116 return FILE_CREATE;
117 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
118 return FILE_OVERWRITE_IF;
119 else if ((flags & O_CREAT) == O_CREAT)
120 return FILE_OPEN_IF;
Steve French55aa2e02006-05-30 18:09:31 +0000121 else if ((flags & O_TRUNC) == O_TRUNC)
122 return FILE_OVERWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 else
124 return FILE_OPEN;
125}
126
127/* all arguments to this function must be checked for validity in caller */
Steve French276a74a2009-03-03 18:00:34 +0000128static inline int cifs_posix_open_inode_helper(struct inode *inode,
129 struct file *file, struct cifsInodeInfo *pCifsInode,
130 struct cifsFileInfo *pCifsFile, int oplock, u16 netfid)
131{
Steve French276a74a2009-03-03 18:00:34 +0000132
Steve French276a74a2009-03-03 18:00:34 +0000133 write_lock(&GlobalSMBSeslock);
Steve French276a74a2009-03-03 18:00:34 +0000134
135 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
136 if (pCifsInode == NULL) {
137 write_unlock(&GlobalSMBSeslock);
138 return -EINVAL;
139 }
140
Steve French276a74a2009-03-03 18:00:34 +0000141 if (pCifsInode->clientCanCacheRead) {
142 /* we have the inode open somewhere else
143 no need to discard cache data */
144 goto psx_client_can_cache;
145 }
146
147 /* BB FIXME need to fix this check to move it earlier into posix_open
148 BB fIX following section BB FIXME */
149
150 /* if not oplocked, invalidate inode pages if mtime or file
151 size changed */
152/* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
153 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
154 (file->f_path.dentry->d_inode->i_size ==
155 (loff_t)le64_to_cpu(buf->EndOfFile))) {
156 cFYI(1, ("inode unchanged on server"));
157 } else {
158 if (file->f_path.dentry->d_inode->i_mapping) {
159 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
160 if (rc != 0)
161 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
162 }
163 cFYI(1, ("invalidating remote inode since open detected it "
164 "changed"));
165 invalidate_remote_inode(file->f_path.dentry->d_inode);
166 } */
167
168psx_client_can_cache:
169 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
170 pCifsInode->clientCanCacheAll = true;
171 pCifsInode->clientCanCacheRead = true;
172 cFYI(1, ("Exclusive Oplock granted on inode %p",
173 file->f_path.dentry->d_inode));
174 } else if ((oplock & 0xF) == OPLOCK_READ)
175 pCifsInode->clientCanCacheRead = true;
176
177 /* will have to change the unlock if we reenable the
178 filemap_fdatawrite (which does not seem necessary */
179 write_unlock(&GlobalSMBSeslock);
180 return 0;
181}
182
Steve French703a3b82009-05-21 22:21:53 +0000183static struct cifsFileInfo *
184cifs_fill_filedata(struct file *file)
185{
186 struct list_head *tmp;
187 struct cifsFileInfo *pCifsFile = NULL;
188 struct cifsInodeInfo *pCifsInode = NULL;
189
190 /* search inode for this file and fill in file->private_data */
191 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
192 read_lock(&GlobalSMBSeslock);
193 list_for_each(tmp, &pCifsInode->openFileList) {
194 pCifsFile = list_entry(tmp, struct cifsFileInfo, flist);
195 if ((pCifsFile->pfile == NULL) &&
196 (pCifsFile->pid == current->tgid)) {
197 /* mode set in cifs_create */
198
199 /* needed for writepage */
200 pCifsFile->pfile = file;
201 file->private_data = pCifsFile;
202 break;
203 }
204 }
205 read_unlock(&GlobalSMBSeslock);
206
207 if (file->private_data != NULL) {
208 return pCifsFile;
209 } else if ((file->f_flags & O_CREAT) && (file->f_flags & O_EXCL))
210 cERROR(1, ("could not find file instance for "
211 "new file %p", file));
212 return NULL;
213}
214
Steve French276a74a2009-03-03 18:00:34 +0000215/* all arguments to this function must be checked for validity in caller */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
217 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
218 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
219 char *full_path, int xid)
220{
221 struct timespec temp;
222 int rc;
223
224 /* want handles we can use to read with first
225 in the list so we do not have to walk the
Nick Piggind9414772008-09-24 11:32:59 -0400226 list to search for one in write_begin */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000228 list_add_tail(&pCifsFile->flist,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 &pCifsInode->openFileList);
230 } else {
231 list_add(&pCifsFile->flist,
232 &pCifsInode->openFileList);
233 }
234 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 if (pCifsInode->clientCanCacheRead) {
236 /* we have the inode open somewhere else
237 no need to discard cache data */
238 goto client_can_cache;
239 }
240
241 /* BB need same check in cifs_create too? */
242 /* if not oplocked, invalidate inode pages if mtime or file
243 size changed */
244 temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800245 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
246 (file->f_path.dentry->d_inode->i_size ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 (loff_t)le64_to_cpu(buf->EndOfFile))) {
248 cFYI(1, ("inode unchanged on server"));
249 } else {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800250 if (file->f_path.dentry->d_inode->i_mapping) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 /* BB no need to lock inode until after invalidate
252 since namei code should already have it locked? */
Jeff Laytoncea21802007-11-20 23:19:03 +0000253 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
254 if (rc != 0)
255 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 }
257 cFYI(1, ("invalidating remote inode since open detected it "
258 "changed"));
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800259 invalidate_remote_inode(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 }
261
262client_can_cache:
Steve Frenchc18c8422007-07-18 23:21:09 +0000263 if (pTcon->unix_ext)
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800264 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 full_path, inode->i_sb, xid);
266 else
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800267 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
Steve French8b1327f2008-03-14 22:37:16 +0000268 full_path, buf, inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
270 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000271 pCifsInode->clientCanCacheAll = true;
272 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800274 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 } else if ((*oplock & 0xF) == OPLOCK_READ)
Steve French4b18f2a2008-04-29 00:06:05 +0000276 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277
278 return rc;
279}
280
281int cifs_open(struct inode *inode, struct file *file)
282{
283 int rc = -EACCES;
284 int xid, oplock;
285 struct cifs_sb_info *cifs_sb;
Steve French276a74a2009-03-03 18:00:34 +0000286 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 struct cifsFileInfo *pCifsFile;
288 struct cifsInodeInfo *pCifsInode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 char *full_path = NULL;
290 int desiredAccess;
291 int disposition;
292 __u16 netfid;
293 FILE_ALL_INFO *buf = NULL;
294
295 xid = GetXid();
296
297 cifs_sb = CIFS_SB(inode->i_sb);
Steve French276a74a2009-03-03 18:00:34 +0000298 tcon = cifs_sb->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
Steve Frencha6ce4932009-04-09 01:14:32 +0000300 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Steve French703a3b82009-05-21 22:21:53 +0000301 pCifsFile = cifs_fill_filedata(file);
302 if (pCifsFile) {
Steve Frencha6ce4932009-04-09 01:14:32 +0000303 FreeXid(xid);
Steve French703a3b82009-05-21 22:21:53 +0000304 return 0;
305 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800307 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 if (full_path == NULL) {
309 FreeXid(xid);
310 return -ENOMEM;
311 }
312
Steve French7521a3c2007-07-11 18:30:34 +0000313 cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 inode, file->f_flags, full_path));
Steve French276a74a2009-03-03 18:00:34 +0000315
316 if (oplockEnabled)
317 oplock = REQ_OPLOCK;
318 else
319 oplock = 0;
320
Steve French64cc2c62009-03-04 19:54:08 +0000321 if (!tcon->broken_posix_open && tcon->unix_ext &&
322 (tcon->ses->capabilities & CAP_UNIX) &&
Steve French276a74a2009-03-03 18:00:34 +0000323 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
324 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
325 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
326 /* can not refresh inode info since size could be stale */
327 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
328 cifs_sb->mnt_file_mode /* ignored */,
329 oflags, &oplock, &netfid, xid);
330 if (rc == 0) {
331 cFYI(1, ("posix open succeeded"));
332 /* no need for special case handling of setting mode
333 on read only files needed here */
334
Steve French703a3b82009-05-21 22:21:53 +0000335 pCifsFile = cifs_fill_filedata(file);
Steve French276a74a2009-03-03 18:00:34 +0000336 cifs_posix_open_inode_helper(inode, file, pCifsInode,
337 pCifsFile, oplock, netfid);
338 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000339 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
340 if (tcon->ses->serverNOS)
341 cERROR(1, ("server %s of type %s returned"
342 " unexpected error on SMB posix open"
343 ", disabling posix open support."
344 " Check if server update available.",
345 tcon->ses->serverName,
346 tcon->ses->serverNOS));
347 tcon->broken_posix_open = true;
Steve French276a74a2009-03-03 18:00:34 +0000348 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
349 (rc != -EOPNOTSUPP)) /* path not found or net err */
350 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000351 /* else fallthrough to retry open the old way on network i/o
352 or DFS errors */
Steve French276a74a2009-03-03 18:00:34 +0000353 }
354
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 desiredAccess = cifs_convert_flags(file->f_flags);
356
357/*********************************************************************
358 * open flag mapping table:
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000359 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 * POSIX Flag CIFS Disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000361 * ---------- ----------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 * O_CREAT FILE_OPEN_IF
363 * O_CREAT | O_EXCL FILE_CREATE
364 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
365 * O_TRUNC FILE_OVERWRITE
366 * none of the above FILE_OPEN
367 *
368 * Note that there is not a direct match between disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000369 * FILE_SUPERSEDE (ie create whether or not file exists although
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 * O_CREAT | O_TRUNC is similar but truncates the existing
371 * file rather than creating a new file as FILE_SUPERSEDE does
372 * (which uses the attributes / metadata passed in on open call)
373 *?
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000374 *? O_SYNC is a reasonable match to CIFS writethrough flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 *? and the read write flags match reasonably. O_LARGEFILE
376 *? is irrelevant because largefile support is always used
377 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
378 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
379 *********************************************************************/
380
381 disposition = cifs_get_disposition(file->f_flags);
382
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 /* BB pass O_SYNC flag through on file attributes .. BB */
384
385 /* Also refresh inode by passing in file_info buf returned by SMBOpen
386 and calling get_inode_info with returned buf (at least helps
387 non-Unix server case) */
388
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000389 /* BB we can not do this if this is the second open of a file
390 and the first handle has writebehind data, we might be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
392 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
393 if (!buf) {
394 rc = -ENOMEM;
395 goto out;
396 }
Steve French5bafd762006-06-07 00:18:43 +0000397
398 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
Steve French276a74a2009-03-03 18:00:34 +0000399 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
Steve French5bafd762006-06-07 00:18:43 +0000400 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
Steve French737b7582005-04-28 22:41:06 -0700401 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
402 & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000403 else
404 rc = -EIO; /* no NT SMB support fall into legacy open below */
405
Steve Frencha9d02ad2005-08-24 23:06:05 -0700406 if (rc == -EIO) {
407 /* Old server, try legacy style OpenX */
Steve French276a74a2009-03-03 18:00:34 +0000408 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
Steve Frencha9d02ad2005-08-24 23:06:05 -0700409 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
410 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
411 & CIFS_MOUNT_MAP_SPECIAL_CHR);
412 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 if (rc) {
Steve French26a21b92006-05-31 18:05:34 +0000414 cFYI(1, ("cifs_open returned 0x%x", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 goto out;
416 }
417 file->private_data =
418 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
419 if (file->private_data == NULL) {
420 rc = -ENOMEM;
421 goto out;
422 }
423 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 write_lock(&GlobalSMBSeslock);
Steve French276a74a2009-03-03 18:00:34 +0000425 list_add(&pCifsFile->tlist, &tcon->openFileList);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800427 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 if (pCifsInode) {
429 rc = cifs_open_inode_helper(inode, file, pCifsInode,
Steve French276a74a2009-03-03 18:00:34 +0000430 pCifsFile, tcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 &oplock, buf, full_path, xid);
432 } else {
433 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 }
435
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000436 if (oplock & CIFS_CREATE_ACTION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 /* time to set mode which we can not set earlier due to
438 problems creating new read-only files */
Steve French276a74a2009-03-03 18:00:34 +0000439 if (tcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400440 struct cifs_unix_set_info_args args = {
441 .mode = inode->i_mode,
442 .uid = NO_CHANGE_64,
443 .gid = NO_CHANGE_64,
444 .ctime = NO_CHANGE_64,
445 .atime = NO_CHANGE_64,
446 .mtime = NO_CHANGE_64,
447 .device = 0,
448 };
Steve French276a74a2009-03-03 18:00:34 +0000449 CIFSSMBUnixSetInfo(xid, tcon, full_path, &args,
Steve French737b7582005-04-28 22:41:06 -0700450 cifs_sb->local_nls,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000451 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700452 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 }
454 }
455
456out:
457 kfree(buf);
458 kfree(full_path);
459 FreeXid(xid);
460 return rc;
461}
462
Adrian Bunk04187262006-06-30 18:23:04 +0200463/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464/* to server was lost */
465static int cifs_relock_file(struct cifsFileInfo *cifsFile)
466{
467 int rc = 0;
468
469/* BB list all locks open on this file and relock */
470
471 return rc;
472}
473
Steve French4b18f2a2008-04-29 00:06:05 +0000474static int cifs_reopen_file(struct file *file, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475{
476 int rc = -EACCES;
477 int xid, oplock;
478 struct cifs_sb_info *cifs_sb;
Steve French7fc8f4e2009-02-23 20:43:11 +0000479 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 struct cifsFileInfo *pCifsFile;
481 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000482 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 char *full_path = NULL;
484 int desiredAccess;
485 int disposition = FILE_OPEN;
486 __u16 netfid;
487
Steve Frenchad7a2922008-02-07 23:25:02 +0000488 if (file->private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 pCifsFile = (struct cifsFileInfo *)file->private_data;
Steve Frenchad7a2922008-02-07 23:25:02 +0000490 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 return -EBADF;
492
493 xid = GetXid();
Steve Frencha6ce4932009-04-09 01:14:32 +0000494 mutex_unlock(&pCifsFile->fh_mutex);
Steve French4b18f2a2008-04-29 00:06:05 +0000495 if (!pCifsFile->invalidHandle) {
Steve Frencha6ce4932009-04-09 01:14:32 +0000496 mutex_lock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 FreeXid(xid);
498 return 0;
499 }
500
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800501 if (file->f_path.dentry == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000502 cERROR(1, ("no valid name if dentry freed"));
503 dump_stack();
504 rc = -EBADF;
505 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 }
Steve French3a9f4622007-04-04 17:10:24 +0000507
508 inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000509 if (inode == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000510 cERROR(1, ("inode not valid"));
511 dump_stack();
512 rc = -EBADF;
513 goto reopen_error_exit;
514 }
Steve French50c2f752007-07-13 00:33:32 +0000515
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 cifs_sb = CIFS_SB(inode->i_sb);
Steve French7fc8f4e2009-02-23 20:43:11 +0000517 tcon = cifs_sb->tcon;
Steve French3a9f4622007-04-04 17:10:24 +0000518
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519/* can not grab rename sem here because various ops, including
520 those that already have the rename sem can end up causing writepage
521 to get called and if the server was down that means we end up here,
522 and we can never tell if the caller already has the rename_sem */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800523 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000525 rc = -ENOMEM;
526reopen_error_exit:
Steve Frencha6ce4932009-04-09 01:14:32 +0000527 mutex_lock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000529 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 }
531
Steve French3a9f4622007-04-04 17:10:24 +0000532 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000533 inode, file->f_flags, full_path));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534
535 if (oplockEnabled)
536 oplock = REQ_OPLOCK;
537 else
Steve French4b18f2a2008-04-29 00:06:05 +0000538 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Steve French7fc8f4e2009-02-23 20:43:11 +0000540 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
541 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
542 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
543 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
544 /* can not refresh inode info since size could be stale */
545 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
546 cifs_sb->mnt_file_mode /* ignored */,
547 oflags, &oplock, &netfid, xid);
548 if (rc == 0) {
549 cFYI(1, ("posix reopen succeeded"));
550 goto reopen_success;
551 }
552 /* fallthrough to retry open the old way on errors, especially
553 in the reconnect path it is important to retry hard */
554 }
555
556 desiredAccess = cifs_convert_flags(file->f_flags);
557
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000559 by SMBOpen and then calling get_inode_info with returned buf
560 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 and server version of file size can be stale. If we knew for sure
562 that inode was not dirty locally we could do this */
563
Steve French7fc8f4e2009-02-23 20:43:11 +0000564 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 CREATE_NOT_DIR, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000566 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700567 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 if (rc) {
Steve Frencha6ce4932009-04-09 01:14:32 +0000569 mutex_lock(&pCifsFile->fh_mutex);
Steve French26a21b92006-05-31 18:05:34 +0000570 cFYI(1, ("cifs_open returned 0x%x", rc));
571 cFYI(1, ("oplock: %d", oplock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 } else {
Steve French7fc8f4e2009-02-23 20:43:11 +0000573reopen_success:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 pCifsFile->netfid = netfid;
Steve French4b18f2a2008-04-29 00:06:05 +0000575 pCifsFile->invalidHandle = false;
Steve Frencha6ce4932009-04-09 01:14:32 +0000576 mutex_lock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 pCifsInode = CIFS_I(inode);
578 if (pCifsInode) {
579 if (can_flush) {
Jeff Laytoncea21802007-11-20 23:19:03 +0000580 rc = filemap_write_and_wait(inode->i_mapping);
581 if (rc != 0)
582 CIFS_I(inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 /* temporarily disable caching while we
584 go to server to get inode info */
Steve French4b18f2a2008-04-29 00:06:05 +0000585 pCifsInode->clientCanCacheAll = false;
586 pCifsInode->clientCanCacheRead = false;
Steve French7fc8f4e2009-02-23 20:43:11 +0000587 if (tcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588 rc = cifs_get_inode_info_unix(&inode,
589 full_path, inode->i_sb, xid);
590 else
591 rc = cifs_get_inode_info(&inode,
592 full_path, NULL, inode->i_sb,
Steve French8b1327f2008-03-14 22:37:16 +0000593 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700594 } /* else we are writing out data to server already
595 and could deadlock if we tried to flush data, and
596 since we do not know if we have data that would
597 invalidate the current end of file on the server
598 we can not go to the server to get the new inod
599 info */
600 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000601 pCifsInode->clientCanCacheAll = true;
602 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800604 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 } else if ((oplock & 0xF) == OPLOCK_READ) {
Steve French4b18f2a2008-04-29 00:06:05 +0000606 pCifsInode->clientCanCacheRead = true;
607 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 } else {
Steve French4b18f2a2008-04-29 00:06:05 +0000609 pCifsInode->clientCanCacheRead = false;
610 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 }
612 cifs_relock_file(pCifsFile);
613 }
614 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 kfree(full_path);
616 FreeXid(xid);
617 return rc;
618}
619
620int cifs_close(struct inode *inode, struct file *file)
621{
622 int rc = 0;
Steve French15745322007-09-07 22:23:48 +0000623 int xid, timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 struct cifs_sb_info *cifs_sb;
625 struct cifsTconInfo *pTcon;
626 struct cifsFileInfo *pSMBFile =
627 (struct cifsFileInfo *)file->private_data;
628
629 xid = GetXid();
630
631 cifs_sb = CIFS_SB(inode->i_sb);
632 pTcon = cifs_sb->tcon;
633 if (pSMBFile) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000634 struct cifsLockInfo *li, *tmp;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000635 write_lock(&GlobalSMBSeslock);
Steve French4b18f2a2008-04-29 00:06:05 +0000636 pSMBFile->closePend = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 if (pTcon) {
638 /* no sense reconnecting to close a file that is
639 already closed */
Steve French3b795212008-11-13 19:45:32 +0000640 if (!pTcon->need_reconnect) {
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000641 write_unlock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +0000642 timeout = 2;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000643 while ((atomic_read(&pSMBFile->wrtPending) != 0)
Steve French15745322007-09-07 22:23:48 +0000644 && (timeout <= 2048)) {
Steve French23e7dd72005-10-20 13:44:56 -0700645 /* Give write a better chance to get to
646 server ahead of the close. We do not
647 want to add a wait_q here as it would
648 increase the memory utilization as
649 the struct would be in each open file,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000650 but this should give enough time to
Steve French23e7dd72005-10-20 13:44:56 -0700651 clear the socket */
Steve French90c81e02008-02-12 20:32:36 +0000652 cFYI(DBG2,
653 ("close delay, write pending"));
Steve French23e7dd72005-10-20 13:44:56 -0700654 msleep(timeout);
655 timeout *= 4;
Steve French4891d532006-11-07 16:31:16 +0000656 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000657 if (atomic_read(&pSMBFile->wrtPending))
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000658 cERROR(1, ("close with pending write"));
659 if (!pTcon->need_reconnect &&
660 !pSMBFile->invalidHandle)
661 rc = CIFSSMBClose(xid, pTcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 pSMBFile->netfid);
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000663 } else
664 write_unlock(&GlobalSMBSeslock);
665 } else
666 write_unlock(&GlobalSMBSeslock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000667
668 /* Delete any outstanding lock records.
669 We'll lose them when the file is closed anyway. */
Roland Dreier796e5662007-05-03 04:33:45 +0000670 mutex_lock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000671 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
672 list_del(&li->llist);
673 kfree(li);
674 }
Roland Dreier796e5662007-05-03 04:33:45 +0000675 mutex_unlock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000676
Steve Frenchcbe04762005-04-28 22:41:05 -0700677 write_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 list_del(&pSMBFile->flist);
679 list_del(&pSMBFile->tlist);
Steve Frenchcbe04762005-04-28 22:41:05 -0700680 write_unlock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +0000681 timeout = 10;
682 /* We waited above to give the SMBWrite a chance to issue
683 on the wire (so we do not get SMBWrite returning EBADF
684 if writepages is racing with close. Note that writepages
685 does not specify a file handle, so it is possible for a file
686 to be opened twice, and the application close the "wrong"
687 file handle - in these cases we delay long enough to allow
688 the SMBWrite to get on the wire before the SMB Close.
689 We allow total wait here over 45 seconds, more than
690 oplock break time, and more than enough to allow any write
691 to complete on the server, or to time out on the client */
692 while ((atomic_read(&pSMBFile->wrtPending) != 0)
693 && (timeout <= 50000)) {
694 cERROR(1, ("writes pending, delay free of handle"));
695 msleep(timeout);
696 timeout *= 8;
697 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700698 kfree(file->private_data);
699 file->private_data = NULL;
700 } else
701 rc = -EBADF;
702
Steve French4efa53f2007-09-11 05:50:53 +0000703 read_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 if (list_empty(&(CIFS_I(inode)->openFileList))) {
705 cFYI(1, ("closing last open instance for inode %p", inode));
706 /* if the file is not open we do not know if we can cache info
707 on this inode, much less write behind and read ahead */
Steve French4b18f2a2008-04-29 00:06:05 +0000708 CIFS_I(inode)->clientCanCacheRead = false;
709 CIFS_I(inode)->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 }
Steve French4efa53f2007-09-11 05:50:53 +0000711 read_unlock(&GlobalSMBSeslock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000712 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 rc = CIFS_I(inode)->write_behind_rc;
714 FreeXid(xid);
715 return rc;
716}
717
718int cifs_closedir(struct inode *inode, struct file *file)
719{
720 int rc = 0;
721 int xid;
722 struct cifsFileInfo *pCFileStruct =
723 (struct cifsFileInfo *)file->private_data;
724 char *ptmp;
725
Steve French26a21b92006-05-31 18:05:34 +0000726 cFYI(1, ("Closedir inode = 0x%p", inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
728 xid = GetXid();
729
730 if (pCFileStruct) {
731 struct cifsTconInfo *pTcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000732 struct cifs_sb_info *cifs_sb =
733 CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734
735 pTcon = cifs_sb->tcon;
736
737 cFYI(1, ("Freeing private data in close dir"));
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000738 write_lock(&GlobalSMBSeslock);
Steve French4b18f2a2008-04-29 00:06:05 +0000739 if (!pCFileStruct->srch_inf.endOfSearch &&
740 !pCFileStruct->invalidHandle) {
741 pCFileStruct->invalidHandle = true;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000742 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
744 cFYI(1, ("Closing uncompleted readdir with rc %d",
745 rc));
746 /* not much we can do if it fails anyway, ignore rc */
747 rc = 0;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000748 } else
749 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
751 if (ptmp) {
Steve Frenchec637e32005-12-12 20:53:18 -0800752 cFYI(1, ("closedir free smb buf in srch struct"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000754 if (pCFileStruct->srch_inf.smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000755 cifs_small_buf_release(ptmp);
756 else
757 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 kfree(file->private_data);
760 file->private_data = NULL;
761 }
762 /* BB can we lock the filestruct while this is going on? */
763 FreeXid(xid);
764 return rc;
765}
766
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000767static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
768 __u64 offset, __u8 lockType)
769{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000770 struct cifsLockInfo *li =
771 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000772 if (li == NULL)
773 return -ENOMEM;
774 li->offset = offset;
775 li->length = len;
776 li->type = lockType;
Roland Dreier796e5662007-05-03 04:33:45 +0000777 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000778 list_add(&li->llist, &fid->llist);
Roland Dreier796e5662007-05-03 04:33:45 +0000779 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000780 return 0;
781}
782
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
784{
785 int rc, xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 __u32 numLock = 0;
787 __u32 numUnlock = 0;
788 __u64 length;
Steve French4b18f2a2008-04-29 00:06:05 +0000789 bool wait_flag = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 struct cifs_sb_info *cifs_sb;
Steve French13a6e422008-12-02 17:24:33 +0000791 struct cifsTconInfo *tcon;
Steve French08547b02006-02-28 22:39:25 +0000792 __u16 netfid;
793 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
Steve French13a6e422008-12-02 17:24:33 +0000794 bool posix_locking = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795
796 length = 1 + pfLock->fl_end - pfLock->fl_start;
797 rc = -EACCES;
798 xid = GetXid();
799
800 cFYI(1, ("Lock parm: 0x%x flockflags: "
801 "0x%x flocktype: 0x%x start: %lld end: %lld",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000802 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
803 pfLock->fl_end));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
805 if (pfLock->fl_flags & FL_POSIX)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000806 cFYI(1, ("Posix"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 if (pfLock->fl_flags & FL_FLOCK)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000808 cFYI(1, ("Flock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 if (pfLock->fl_flags & FL_SLEEP) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000810 cFYI(1, ("Blocking lock"));
Steve French4b18f2a2008-04-29 00:06:05 +0000811 wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 }
813 if (pfLock->fl_flags & FL_ACCESS)
814 cFYI(1, ("Process suspended by mandatory locking - "
Steve French26a21b92006-05-31 18:05:34 +0000815 "not implemented yet"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 if (pfLock->fl_flags & FL_LEASE)
817 cFYI(1, ("Lease on file - not implemented yet"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000818 if (pfLock->fl_flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
820 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
821
822 if (pfLock->fl_type == F_WRLCK) {
823 cFYI(1, ("F_WRLCK "));
824 numLock = 1;
825 } else if (pfLock->fl_type == F_UNLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000826 cFYI(1, ("F_UNLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 numUnlock = 1;
Steve Frenchd47d7c12006-02-28 03:45:48 +0000828 /* Check if unlock includes more than
829 one lock range */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 } else if (pfLock->fl_type == F_RDLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000831 cFYI(1, ("F_RDLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 lockType |= LOCKING_ANDX_SHARED_LOCK;
833 numLock = 1;
834 } else if (pfLock->fl_type == F_EXLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000835 cFYI(1, ("F_EXLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 numLock = 1;
837 } else if (pfLock->fl_type == F_SHLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000838 cFYI(1, ("F_SHLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839 lockType |= LOCKING_ANDX_SHARED_LOCK;
840 numLock = 1;
841 } else
Steve Frenchd47d7c12006-02-28 03:45:48 +0000842 cFYI(1, ("Unknown type of lock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800844 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Steve French13a6e422008-12-02 17:24:33 +0000845 tcon = cifs_sb->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846
847 if (file->private_data == NULL) {
848 FreeXid(xid);
849 return -EBADF;
850 }
Steve French08547b02006-02-28 22:39:25 +0000851 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852
Steve French13a6e422008-12-02 17:24:33 +0000853 if ((tcon->ses->capabilities & CAP_UNIX) &&
854 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
Steve Frenchacc18aa2008-12-02 18:53:55 +0000855 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
Steve French13a6e422008-12-02 17:24:33 +0000856 posix_locking = 1;
Steve French08547b02006-02-28 22:39:25 +0000857 /* BB add code here to normalize offset and length to
858 account for negative length which we can not accept over the
859 wire */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 if (IS_GETLK(cmd)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000861 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000862 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000863 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000864 posix_lock_type = CIFS_RDLCK;
865 else
866 posix_lock_type = CIFS_WRLCK;
Steve French13a6e422008-12-02 17:24:33 +0000867 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000868 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000869 posix_lock_type, wait_flag);
870 FreeXid(xid);
871 return rc;
872 }
873
874 /* BB we could chain these into one lock request BB */
Steve French13a6e422008-12-02 17:24:33 +0000875 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
Steve French08547b02006-02-28 22:39:25 +0000876 0, 1, lockType, 0 /* wait flag */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 if (rc == 0) {
Steve French13a6e422008-12-02 17:24:33 +0000878 rc = CIFSSMBLock(xid, tcon, netfid, length,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 pfLock->fl_start, 1 /* numUnlock */ ,
880 0 /* numLock */ , lockType,
881 0 /* wait flag */ );
882 pfLock->fl_type = F_UNLCK;
883 if (rc != 0)
884 cERROR(1, ("Error unlocking previously locked "
Steve French08547b02006-02-28 22:39:25 +0000885 "range %d during test of lock", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 rc = 0;
887
888 } else {
889 /* if rc == ERR_SHARING_VIOLATION ? */
890 rc = 0; /* do not change lock type to unlock
891 since range in use */
892 }
893
894 FreeXid(xid);
895 return rc;
896 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000897
898 if (!numLock && !numUnlock) {
899 /* if no lock or unlock then nothing
900 to do since we do not know what it is */
901 FreeXid(xid);
902 return -EOPNOTSUPP;
903 }
904
905 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000906 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000907 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000908 posix_lock_type = CIFS_RDLCK;
909 else
910 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +0000911
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000912 if (numUnlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +0000913 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000914
Steve French13a6e422008-12-02 17:24:33 +0000915 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000916 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000917 posix_lock_type, wait_flag);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000918 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000919 struct cifsFileInfo *fid =
920 (struct cifsFileInfo *)file->private_data;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000921
922 if (numLock) {
Steve French13a6e422008-12-02 17:24:33 +0000923 rc = CIFSSMBLock(xid, tcon, netfid, length,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000924 pfLock->fl_start,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000925 0, numLock, lockType, wait_flag);
926
927 if (rc == 0) {
928 /* For Windows locks we must store them. */
929 rc = store_file_lock(fid, length,
930 pfLock->fl_start, lockType);
931 }
932 } else if (numUnlock) {
933 /* For each stored lock that this unlock overlaps
934 completely, unlock it. */
935 int stored_rc = 0;
936 struct cifsLockInfo *li, *tmp;
937
Steve French6b70c952006-09-21 07:35:29 +0000938 rc = 0;
Roland Dreier796e5662007-05-03 04:33:45 +0000939 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000940 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
941 if (pfLock->fl_start <= li->offset &&
Steve Frenchc19eb712007-08-24 03:22:48 +0000942 (pfLock->fl_start + length) >=
Jeff Layton39db8102007-08-24 03:16:51 +0000943 (li->offset + li->length)) {
Steve French13a6e422008-12-02 17:24:33 +0000944 stored_rc = CIFSSMBLock(xid, tcon,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000945 netfid,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000946 li->length, li->offset,
Steve French4b18f2a2008-04-29 00:06:05 +0000947 1, 0, li->type, false);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000948 if (stored_rc)
949 rc = stored_rc;
950
951 list_del(&li->llist);
952 kfree(li);
953 }
954 }
Roland Dreier796e5662007-05-03 04:33:45 +0000955 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000956 }
957 }
958
Steve Frenchd634cc12005-08-26 14:42:59 -0500959 if (pfLock->fl_flags & FL_POSIX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 posix_lock_file_wait(file, pfLock);
961 FreeXid(xid);
962 return rc;
963}
964
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400965/*
966 * Set the timeout on write requests past EOF. For some servers (Windows)
967 * these calls can be very long.
968 *
969 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
970 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
971 * The 10M cutoff is totally arbitrary. A better scheme for this would be
972 * welcome if someone wants to suggest one.
973 *
974 * We may be able to do a better job with this if there were some way to
975 * declare that a file should be sparse.
976 */
977static int
978cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
979{
980 if (offset <= cifsi->server_eof)
981 return CIFS_STD_OP;
982 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
983 return CIFS_VLONG_OP;
984 else
985 return CIFS_LONG_OP;
986}
987
988/* update the file size (if needed) after a write */
989static void
990cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
991 unsigned int bytes_written)
992{
993 loff_t end_of_write = offset + bytes_written;
994
995 if (end_of_write > cifsi->server_eof)
996 cifsi->server_eof = end_of_write;
997}
998
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999ssize_t cifs_user_write(struct file *file, const char __user *write_data,
1000 size_t write_size, loff_t *poffset)
1001{
1002 int rc = 0;
1003 unsigned int bytes_written = 0;
1004 unsigned int total_written;
1005 struct cifs_sb_info *cifs_sb;
1006 struct cifsTconInfo *pTcon;
1007 int xid, long_op;
1008 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001009 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001011 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012
1013 pTcon = cifs_sb->tcon;
1014
1015 /* cFYI(1,
1016 (" write %d bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001017 *poffset, file->f_path.dentry->d_name.name)); */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018
1019 if (file->private_data == NULL)
1020 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +00001021 open_file = (struct cifsFileInfo *) file->private_data;
Steve French50c2f752007-07-13 00:33:32 +00001022
Jeff Layton838726c2008-08-28 07:54:59 -04001023 rc = generic_write_checks(file, poffset, &write_size, 0);
1024 if (rc)
1025 return rc;
1026
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001029 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 for (total_written = 0; write_size > total_written;
1031 total_written += bytes_written) {
1032 rc = -EAGAIN;
1033 while (rc == -EAGAIN) {
1034 if (file->private_data == NULL) {
1035 /* file has been closed on us */
1036 FreeXid(xid);
1037 /* if we have gotten here we have written some data
1038 and blocked, and the file has been freed on us while
1039 we blocked so return what we managed to write */
1040 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001041 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 if (open_file->closePend) {
1043 FreeXid(xid);
1044 if (total_written)
1045 return total_written;
1046 else
1047 return -EBADF;
1048 }
1049 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 /* we could deadlock if we called
1051 filemap_fdatawait from here so tell
1052 reopen_file not to flush data to server
1053 now */
Steve French4b18f2a2008-04-29 00:06:05 +00001054 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 if (rc != 0)
1056 break;
1057 }
1058
1059 rc = CIFSSMBWrite(xid, pTcon,
1060 open_file->netfid,
1061 min_t(const int, cifs_sb->wsize,
1062 write_size - total_written),
1063 *poffset, &bytes_written,
1064 NULL, write_data + total_written, long_op);
1065 }
1066 if (rc || (bytes_written == 0)) {
1067 if (total_written)
1068 break;
1069 else {
1070 FreeXid(xid);
1071 return rc;
1072 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001073 } else {
1074 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001076 }
Steve French133672e2007-11-13 22:41:37 +00001077 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 15 seconds is plenty */
1079 }
1080
Steve Frencha4544342005-08-24 13:59:35 -07001081 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082
1083 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001084 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1085 struct inode *inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001086/* Do not update local mtime - server will set its actual value on write
1087 * inode->i_ctime = inode->i_mtime =
Steve French3677db12007-02-26 16:46:11 +00001088 * current_fs_time(inode->i_sb);*/
1089 if (total_written > 0) {
1090 spin_lock(&inode->i_lock);
1091 if (*poffset > file->f_path.dentry->d_inode->i_size)
1092 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093 *poffset);
Steve French3677db12007-02-26 16:46:11 +00001094 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001096 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 }
1098 FreeXid(xid);
1099 return total_written;
1100}
1101
1102static ssize_t cifs_write(struct file *file, const char *write_data,
Nick Piggind9414772008-09-24 11:32:59 -04001103 size_t write_size, loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104{
1105 int rc = 0;
1106 unsigned int bytes_written = 0;
1107 unsigned int total_written;
1108 struct cifs_sb_info *cifs_sb;
1109 struct cifsTconInfo *pTcon;
1110 int xid, long_op;
1111 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001112 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001114 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
1116 pTcon = cifs_sb->tcon;
1117
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001118 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001119 *poffset, file->f_path.dentry->d_name.name));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001120
1121 if (file->private_data == NULL)
1122 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +00001123 open_file = (struct cifsFileInfo *)file->private_data;
Steve French50c2f752007-07-13 00:33:32 +00001124
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001127 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 for (total_written = 0; write_size > total_written;
1129 total_written += bytes_written) {
1130 rc = -EAGAIN;
1131 while (rc == -EAGAIN) {
1132 if (file->private_data == NULL) {
1133 /* file has been closed on us */
1134 FreeXid(xid);
1135 /* if we have gotten here we have written some data
1136 and blocked, and the file has been freed on us
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001137 while we blocked so return what we managed to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 write */
1139 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001140 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 if (open_file->closePend) {
1142 FreeXid(xid);
1143 if (total_written)
1144 return total_written;
1145 else
1146 return -EBADF;
1147 }
1148 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001149 /* we could deadlock if we called
1150 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001151 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 server now */
Steve French4b18f2a2008-04-29 00:06:05 +00001153 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 if (rc != 0)
1155 break;
1156 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001157 if (experimEnabled || (pTcon->ses->server &&
1158 ((pTcon->ses->server->secMode &
Steve French08775832006-05-30 18:08:26 +00001159 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +00001160 == 0))) {
Steve French3e844692005-10-03 13:37:24 -07001161 struct kvec iov[2];
1162 unsigned int len;
1163
Steve French0ae0efa2005-10-10 10:57:19 -07001164 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -07001165 write_size - total_written);
1166 /* iov[0] is reserved for smb header */
1167 iov[1].iov_base = (char *)write_data +
1168 total_written;
1169 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001170 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -07001171 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001172 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -07001173 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001174 } else
Steve French60808232006-04-22 15:53:05 +00001175 rc = CIFSSMBWrite(xid, pTcon,
1176 open_file->netfid,
1177 min_t(const int, cifs_sb->wsize,
1178 write_size - total_written),
1179 *poffset, &bytes_written,
1180 write_data + total_written,
1181 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 }
1183 if (rc || (bytes_written == 0)) {
1184 if (total_written)
1185 break;
1186 else {
1187 FreeXid(xid);
1188 return rc;
1189 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001190 } else {
1191 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001193 }
Steve French133672e2007-11-13 22:41:37 +00001194 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 15 seconds is plenty */
1196 }
1197
Steve Frencha4544342005-08-24 13:59:35 -07001198 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
1200 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001201 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
Steve French004c46b2007-02-17 04:34:13 +00001202/*BB We could make this contingent on superblock ATIME flag too */
Steve French3677db12007-02-26 16:46:11 +00001203/* file->f_path.dentry->d_inode->i_ctime =
1204 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1205 if (total_written > 0) {
1206 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1207 if (*poffset > file->f_path.dentry->d_inode->i_size)
1208 i_size_write(file->f_path.dentry->d_inode,
1209 *poffset);
1210 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 }
Steve French3677db12007-02-26 16:46:11 +00001212 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213 }
1214 FreeXid(xid);
1215 return total_written;
1216}
1217
Steve French630f3f02007-10-25 21:17:17 +00001218#ifdef CONFIG_CIFS_EXPERIMENTAL
1219struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1220{
1221 struct cifsFileInfo *open_file = NULL;
1222
1223 read_lock(&GlobalSMBSeslock);
1224 /* we could simply get the first_list_entry since write-only entries
1225 are always at the end of the list but since the first entry might
1226 have a close pending, we go through the whole list */
1227 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1228 if (open_file->closePend)
1229 continue;
1230 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1231 (open_file->pfile->f_flags & O_RDONLY))) {
1232 if (!open_file->invalidHandle) {
1233 /* found a good file */
1234 /* lock it so it will not be closed on us */
1235 atomic_inc(&open_file->wrtPending);
1236 read_unlock(&GlobalSMBSeslock);
1237 return open_file;
1238 } /* else might as well continue, and look for
1239 another, or simply have the caller reopen it
1240 again rather than trying to fix this handle */
1241 } else /* write only file */
1242 break; /* write only files are last so must be done */
1243 }
1244 read_unlock(&GlobalSMBSeslock);
1245 return NULL;
1246}
1247#endif
1248
Steve Frenchdd99cd82005-10-05 19:32:49 -07001249struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
Steve French6148a742005-10-05 12:23:19 -07001250{
1251 struct cifsFileInfo *open_file;
Jeff Layton2846d382008-09-22 21:33:33 -04001252 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001253 int rc;
Steve French6148a742005-10-05 12:23:19 -07001254
Steve French60808232006-04-22 15:53:05 +00001255 /* Having a null inode here (because mapping->host was set to zero by
1256 the VFS or MM) should not happen but we had reports of on oops (due to
1257 it being zero) during stress testcases so we need to check for it */
1258
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001259 if (cifs_inode == NULL) {
1260 cERROR(1, ("Null inode passed to cifs_writeable_file"));
Steve French60808232006-04-22 15:53:05 +00001261 dump_stack();
1262 return NULL;
1263 }
1264
Steve French6148a742005-10-05 12:23:19 -07001265 read_lock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001266refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001267 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2846d382008-09-22 21:33:33 -04001268 if (open_file->closePend ||
1269 (!any_available && open_file->pid != current->tgid))
Steve French6148a742005-10-05 12:23:19 -07001270 continue;
Jeff Layton2846d382008-09-22 21:33:33 -04001271
Steve French6148a742005-10-05 12:23:19 -07001272 if (open_file->pfile &&
1273 ((open_file->pfile->f_flags & O_RDWR) ||
1274 (open_file->pfile->f_flags & O_WRONLY))) {
Steve French23e7dd72005-10-20 13:44:56 -07001275 atomic_inc(&open_file->wrtPending);
Steve French9b22b0b2007-10-02 01:11:08 +00001276
1277 if (!open_file->invalidHandle) {
1278 /* found a good writable file */
1279 read_unlock(&GlobalSMBSeslock);
1280 return open_file;
1281 }
Steve French8840dee2007-11-16 23:05:52 +00001282
Steve French6148a742005-10-05 12:23:19 -07001283 read_unlock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001284 /* Had to unlock since following call can block */
Steve French4b18f2a2008-04-29 00:06:05 +00001285 rc = cifs_reopen_file(open_file->pfile, false);
Steve French8840dee2007-11-16 23:05:52 +00001286 if (!rc) {
Steve French9b22b0b2007-10-02 01:11:08 +00001287 if (!open_file->closePend)
1288 return open_file;
1289 else { /* start over in case this was deleted */
1290 /* since the list could be modified */
Steve French37c0eb42005-10-05 14:50:29 -07001291 read_lock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +00001292 atomic_dec(&open_file->wrtPending);
Steve French9b22b0b2007-10-02 01:11:08 +00001293 goto refind_writable;
Steve French37c0eb42005-10-05 14:50:29 -07001294 }
1295 }
Steve French9b22b0b2007-10-02 01:11:08 +00001296
1297 /* if it fails, try another handle if possible -
1298 (we can not do this if closePending since
1299 loop could be modified - in which case we
1300 have to start at the beginning of the list
1301 again. Note that it would be bad
1302 to hold up writepages here (rather than
1303 in caller) with continuous retries */
1304 cFYI(1, ("wp failed on reopen file"));
1305 read_lock(&GlobalSMBSeslock);
1306 /* can not use this handle, no write
1307 pending on this one after all */
1308 atomic_dec(&open_file->wrtPending);
Steve French8840dee2007-11-16 23:05:52 +00001309
Steve French9b22b0b2007-10-02 01:11:08 +00001310 if (open_file->closePend) /* list could have changed */
1311 goto refind_writable;
1312 /* else we simply continue to the next entry. Thus
1313 we do not loop on reopen errors. If we
1314 can not reopen the file, for example if we
1315 reconnected to a server with another client
1316 racing to delete or lock the file we would not
1317 make progress if we restarted before the beginning
1318 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001319 }
1320 }
Jeff Layton2846d382008-09-22 21:33:33 -04001321 /* couldn't find useable FH with same pid, try any available */
1322 if (!any_available) {
1323 any_available = true;
1324 goto refind_writable;
1325 }
Steve French6148a742005-10-05 12:23:19 -07001326 read_unlock(&GlobalSMBSeslock);
1327 return NULL;
1328}
1329
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1331{
1332 struct address_space *mapping = page->mapping;
1333 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1334 char *write_data;
1335 int rc = -EFAULT;
1336 int bytes_written = 0;
1337 struct cifs_sb_info *cifs_sb;
1338 struct cifsTconInfo *pTcon;
1339 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001340 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341
1342 if (!mapping || !mapping->host)
1343 return -EFAULT;
1344
1345 inode = page->mapping->host;
1346 cifs_sb = CIFS_SB(inode->i_sb);
1347 pTcon = cifs_sb->tcon;
1348
1349 offset += (loff_t)from;
1350 write_data = kmap(page);
1351 write_data += from;
1352
1353 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1354 kunmap(page);
1355 return -EIO;
1356 }
1357
1358 /* racing with truncate? */
1359 if (offset > mapping->host->i_size) {
1360 kunmap(page);
1361 return 0; /* don't care */
1362 }
1363
1364 /* check to make sure that we are not extending the file */
1365 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001366 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367
Steve French6148a742005-10-05 12:23:19 -07001368 open_file = find_writable_file(CIFS_I(mapping->host));
1369 if (open_file) {
1370 bytes_written = cifs_write(open_file->pfile, write_data,
1371 to-from, &offset);
Steve French23e7dd72005-10-20 13:44:56 -07001372 atomic_dec(&open_file->wrtPending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001374 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001375 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001376 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001377 else if (bytes_written < 0)
1378 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001379 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 cFYI(1, ("No writeable filehandles for inode"));
1381 rc = -EIO;
1382 }
1383
1384 kunmap(page);
1385 return rc;
1386}
1387
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001389 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390{
Steve French37c0eb42005-10-05 14:50:29 -07001391 struct backing_dev_info *bdi = mapping->backing_dev_info;
1392 unsigned int bytes_to_write;
1393 unsigned int bytes_written;
1394 struct cifs_sb_info *cifs_sb;
1395 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001396 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001397 pgoff_t index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001398 int range_whole = 0;
1399 struct kvec *iov;
Steve French84d2f072005-10-12 15:32:05 -07001400 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001401 int n_iov = 0;
1402 pgoff_t next;
1403 int nr_pages;
1404 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001405 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001406 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
Steve French37c0eb42005-10-05 14:50:29 -07001407 struct page *page;
1408 struct pagevec pvec;
1409 int rc = 0;
1410 int scanned = 0;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001411 int xid, long_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412
Steve French37c0eb42005-10-05 14:50:29 -07001413 cifs_sb = CIFS_SB(mapping->host->i_sb);
Steve French50c2f752007-07-13 00:33:32 +00001414
Steve French37c0eb42005-10-05 14:50:29 -07001415 /*
1416 * If wsize is smaller that the page cache size, default to writing
1417 * one page at a time via cifs_writepage
1418 */
1419 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1420 return generic_writepages(mapping, wbc);
1421
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001422 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1423 if (cifs_sb->tcon->ses->server->secMode &
1424 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1425 if (!experimEnabled)
Steve French60808232006-04-22 15:53:05 +00001426 return generic_writepages(mapping, wbc);
Steve French4a771182005-10-05 15:14:33 -07001427
Steve French9a0c8232007-02-02 04:21:57 +00001428 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001429 if (iov == NULL)
Steve French9a0c8232007-02-02 04:21:57 +00001430 return generic_writepages(mapping, wbc);
1431
1432
Steve French37c0eb42005-10-05 14:50:29 -07001433 /*
1434 * BB: Is this meaningful for a non-block-device file system?
1435 * If it is, we should test it again after we do I/O
1436 */
1437 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1438 wbc->encountered_congestion = 1;
Steve French9a0c8232007-02-02 04:21:57 +00001439 kfree(iov);
Steve French37c0eb42005-10-05 14:50:29 -07001440 return 0;
1441 }
1442
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 xid = GetXid();
1444
Steve French37c0eb42005-10-05 14:50:29 -07001445 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001446 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001447 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001448 end = -1;
1449 } else {
1450 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1451 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1452 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1453 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001454 scanned = 1;
1455 }
1456retry:
1457 while (!done && (index <= end) &&
1458 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1459 PAGECACHE_TAG_DIRTY,
1460 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1461 int first;
1462 unsigned int i;
1463
Steve French37c0eb42005-10-05 14:50:29 -07001464 first = -1;
1465 next = 0;
1466 n_iov = 0;
1467 bytes_to_write = 0;
1468
1469 for (i = 0; i < nr_pages; i++) {
1470 page = pvec.pages[i];
1471 /*
1472 * At this point we hold neither mapping->tree_lock nor
1473 * lock on the page itself: the page may be truncated or
1474 * invalidated (changing page->mapping to NULL), or even
1475 * swizzled back from swapper_space to tmpfs file
1476 * mapping
1477 */
1478
1479 if (first < 0)
1480 lock_page(page);
Nick Piggin529ae9a2008-08-02 12:01:03 +02001481 else if (!trylock_page(page))
Steve French37c0eb42005-10-05 14:50:29 -07001482 break;
1483
1484 if (unlikely(page->mapping != mapping)) {
1485 unlock_page(page);
1486 break;
1487 }
1488
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001489 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001490 done = 1;
1491 unlock_page(page);
1492 break;
1493 }
1494
1495 if (next && (page->index != next)) {
1496 /* Not next consecutive page */
1497 unlock_page(page);
1498 break;
1499 }
1500
1501 if (wbc->sync_mode != WB_SYNC_NONE)
1502 wait_on_page_writeback(page);
1503
1504 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001505 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001506 unlock_page(page);
1507 break;
1508 }
Steve French84d2f072005-10-12 15:32:05 -07001509
Linus Torvaldscb876f42006-12-23 16:19:07 -08001510 /*
1511 * This actually clears the dirty bit in the radix tree.
1512 * See cifs_writepage() for more commentary.
1513 */
1514 set_page_writeback(page);
1515
Steve French84d2f072005-10-12 15:32:05 -07001516 if (page_offset(page) >= mapping->host->i_size) {
1517 done = 1;
1518 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001519 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001520 break;
1521 }
1522
Steve French37c0eb42005-10-05 14:50:29 -07001523 /*
1524 * BB can we get rid of this? pages are held by pvec
1525 */
1526 page_cache_get(page);
1527
Steve French84d2f072005-10-12 15:32:05 -07001528 len = min(mapping->host->i_size - page_offset(page),
1529 (loff_t)PAGE_CACHE_SIZE);
1530
Steve French37c0eb42005-10-05 14:50:29 -07001531 /* reserve iov[0] for the smb header */
1532 n_iov++;
1533 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001534 iov[n_iov].iov_len = len;
1535 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001536
1537 if (first < 0) {
1538 first = i;
1539 offset = page_offset(page);
1540 }
1541 next = page->index + 1;
1542 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1543 break;
1544 }
1545 if (n_iov) {
Steve French23e7dd72005-10-20 13:44:56 -07001546 /* Search for a writable handle every time we call
1547 * CIFSSMBWrite2. We can't rely on the last handle
1548 * we used to still be valid
1549 */
1550 open_file = find_writable_file(CIFS_I(mapping->host));
1551 if (!open_file) {
1552 cERROR(1, ("No writable handles for inode"));
1553 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001554 } else {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001555 long_op = cifs_write_timeout(cifsi, offset);
Steve French23e7dd72005-10-20 13:44:56 -07001556 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1557 open_file->netfid,
1558 bytes_to_write, offset,
1559 &bytes_written, iov, n_iov,
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001560 long_op);
Steve French23e7dd72005-10-20 13:44:56 -07001561 atomic_dec(&open_file->wrtPending);
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001562 cifs_update_eof(cifsi, offset, bytes_written);
1563
Steve French23e7dd72005-10-20 13:44:56 -07001564 if (rc || bytes_written < bytes_to_write) {
Steve French63135e02007-07-17 17:34:02 +00001565 cERROR(1, ("Write2 ret %d, wrote %d",
Steve French23e7dd72005-10-20 13:44:56 -07001566 rc, bytes_written));
1567 /* BB what if continued retry is
1568 requested via mount flags? */
Jeff Laytoncea21802007-11-20 23:19:03 +00001569 if (rc == -ENOSPC)
1570 set_bit(AS_ENOSPC, &mapping->flags);
1571 else
1572 set_bit(AS_EIO, &mapping->flags);
Steve French23e7dd72005-10-20 13:44:56 -07001573 } else {
1574 cifs_stats_bytes_written(cifs_sb->tcon,
1575 bytes_written);
1576 }
Steve French37c0eb42005-10-05 14:50:29 -07001577 }
1578 for (i = 0; i < n_iov; i++) {
1579 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001580 /* Should we also set page error on
1581 success rc but too little data written? */
1582 /* BB investigate retry logic on temporary
1583 server crash cases and how recovery works
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001584 when page marked as error */
1585 if (rc)
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001586 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001587 kunmap(page);
1588 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001589 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001590 page_cache_release(page);
1591 }
1592 if ((wbc->nr_to_write -= n_iov) <= 0)
1593 done = 1;
1594 index = next;
Dave Kleikampb066a482008-11-18 03:49:05 +00001595 } else
1596 /* Need to re-find the pages we skipped */
1597 index = pvec.pages[0]->index + 1;
1598
Steve French37c0eb42005-10-05 14:50:29 -07001599 pagevec_release(&pvec);
1600 }
1601 if (!scanned && !done) {
1602 /*
1603 * We hit the last page and there is more work to be done: wrap
1604 * back to the start of the file
1605 */
1606 scanned = 1;
1607 index = 0;
1608 goto retry;
1609 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001610 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001611 mapping->writeback_index = index;
1612
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001614 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 return rc;
1616}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001618static int cifs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619{
1620 int rc = -EFAULT;
1621 int xid;
1622
1623 xid = GetXid();
1624/* BB add check for wbc flags */
1625 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001626 if (!PageUptodate(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 cFYI(1, ("ppw - page not up to date"));
Linus Torvaldscb876f42006-12-23 16:19:07 -08001628
1629 /*
1630 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1631 *
1632 * A writepage() implementation always needs to do either this,
1633 * or re-dirty the page with "redirty_page_for_writepage()" in
1634 * the case of a failure.
1635 *
1636 * Just unlocking the page will cause the radix tree tag-bits
1637 * to fail to update with the state of the page correctly.
1638 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001639 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1641 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1642 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001643 end_page_writeback(page);
1644 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 FreeXid(xid);
1646 return rc;
1647}
1648
Nick Piggind9414772008-09-24 11:32:59 -04001649static int cifs_write_end(struct file *file, struct address_space *mapping,
1650 loff_t pos, unsigned len, unsigned copied,
1651 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652{
Nick Piggind9414772008-09-24 11:32:59 -04001653 int rc;
1654 struct inode *inode = mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
Nick Piggind9414772008-09-24 11:32:59 -04001656 cFYI(1, ("write_end for page %p from pos %lld with %d bytes",
1657 page, pos, copied));
Steve Frenchad7a2922008-02-07 23:25:02 +00001658
Jeff Laytona98ee8c2008-11-26 19:32:33 +00001659 if (PageChecked(page)) {
1660 if (copied == len)
1661 SetPageUptodate(page);
1662 ClearPageChecked(page);
1663 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04001664 SetPageUptodate(page);
1665
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04001667 char *page_data;
1668 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1669 int xid;
1670
1671 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 /* this is probably better than directly calling
1673 partialpage_write since in this function the file handle is
1674 known which we might as well leverage */
1675 /* BB check if anything else missing out of ppw
1676 such as updating last write time */
1677 page_data = kmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001678 rc = cifs_write(file, page_data + offset, copied, &pos);
1679 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001681
1682 FreeXid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001683 } else {
Nick Piggind9414772008-09-24 11:32:59 -04001684 rc = copied;
1685 pos += copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 set_page_dirty(page);
1687 }
1688
Nick Piggind9414772008-09-24 11:32:59 -04001689 if (rc > 0) {
1690 spin_lock(&inode->i_lock);
1691 if (pos > inode->i_size)
1692 i_size_write(inode, pos);
1693 spin_unlock(&inode->i_lock);
1694 }
1695
1696 unlock_page(page);
1697 page_cache_release(page);
1698
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 return rc;
1700}
1701
1702int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1703{
1704 int xid;
1705 int rc = 0;
Steve Frenchb298f222009-02-21 21:17:43 +00001706 struct cifsTconInfo *tcon;
1707 struct cifsFileInfo *smbfile =
1708 (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001709 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710
1711 xid = GetXid();
1712
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001713 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 dentry->d_name.name, datasync));
Steve French50c2f752007-07-13 00:33:32 +00001715
Jeff Laytoncea21802007-11-20 23:19:03 +00001716 rc = filemap_write_and_wait(inode->i_mapping);
1717 if (rc == 0) {
1718 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 CIFS_I(inode)->write_behind_rc = 0;
Steve Frenchb298f222009-02-21 21:17:43 +00001720 tcon = CIFS_SB(inode->i_sb)->tcon;
Steve Frenchbe652442009-02-23 15:21:59 +00001721 if (!rc && tcon && smbfile &&
Steve French4717bed2009-02-24 14:44:19 +00001722 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
Steve Frenchb298f222009-02-21 21:17:43 +00001723 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
Jeff Laytoncea21802007-11-20 23:19:03 +00001724 }
Steve Frenchb298f222009-02-21 21:17:43 +00001725
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726 FreeXid(xid);
1727 return rc;
1728}
1729
NeilBrown3978d712006-03-26 01:37:17 -08001730/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731{
1732 struct address_space *mapping;
1733 struct inode *inode;
1734 unsigned long index = page->index;
1735 unsigned int rpages = 0;
1736 int rc = 0;
1737
1738 cFYI(1, ("sync page %p",page));
1739 mapping = page->mapping;
1740 if (!mapping)
1741 return 0;
1742 inode = mapping->host;
1743 if (!inode)
NeilBrown3978d712006-03-26 01:37:17 -08001744 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001746/* fill in rpages then
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1748
Steve French26a21b92006-05-31 18:05:34 +00001749/* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750
NeilBrown3978d712006-03-26 01:37:17 -08001751#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 if (rc < 0)
1753 return rc;
1754 return 0;
NeilBrown3978d712006-03-26 01:37:17 -08001755#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756} */
1757
1758/*
1759 * As file closes, flush all cached write data for this inode checking
1760 * for write behind errors.
1761 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001762int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001764 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 int rc = 0;
1766
1767 /* Rather than do the steps manually:
1768 lock the inode for writing
1769 loop through pages looking for write behind data (dirty pages)
1770 coalesce into contiguous 16K (or smaller) chunks to write to server
1771 send to server (prefer in parallel)
1772 deal with writebehind errors
1773 unlock inode for writing
1774 filemapfdatawrite appears easier for the time being */
1775
1776 rc = filemap_fdatawrite(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +00001777 /* reset wb rc if we were able to write out dirty pages */
1778 if (!rc) {
1779 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001781 }
Steve French50c2f752007-07-13 00:33:32 +00001782
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001783 cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784
1785 return rc;
1786}
1787
1788ssize_t cifs_user_read(struct file *file, char __user *read_data,
1789 size_t read_size, loff_t *poffset)
1790{
1791 int rc = -EACCES;
1792 unsigned int bytes_read = 0;
1793 unsigned int total_read = 0;
1794 unsigned int current_read_size;
1795 struct cifs_sb_info *cifs_sb;
1796 struct cifsTconInfo *pTcon;
1797 int xid;
1798 struct cifsFileInfo *open_file;
1799 char *smb_read_data;
1800 char __user *current_offset;
1801 struct smb_com_read_rsp *pSMBr;
1802
1803 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001804 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 pTcon = cifs_sb->tcon;
1806
1807 if (file->private_data == NULL) {
1808 FreeXid(xid);
1809 return -EBADF;
1810 }
1811 open_file = (struct cifsFileInfo *)file->private_data;
1812
Steve Frenchad7a2922008-02-07 23:25:02 +00001813 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 cFYI(1, ("attempting read on write only file instance"));
Steve Frenchad7a2922008-02-07 23:25:02 +00001815
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 for (total_read = 0, current_offset = read_data;
1817 read_size > total_read;
1818 total_read += bytes_read, current_offset += bytes_read) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001819 current_read_size = min_t(const int, read_size - total_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 cifs_sb->rsize);
1821 rc = -EAGAIN;
1822 smb_read_data = NULL;
1823 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001824 int buf_type = CIFS_NO_BUFFER;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001825 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001827 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828 if (rc != 0)
1829 break;
1830 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001831 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001832 open_file->netfid,
1833 current_read_size, *poffset,
1834 &bytes_read, &smb_read_data,
1835 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001838 if (copy_to_user(current_offset,
1839 smb_read_data +
1840 4 /* RFC1001 length field */ +
1841 le16_to_cpu(pSMBr->DataOffset),
Steve Frenchad7a2922008-02-07 23:25:02 +00001842 bytes_read))
Steve French93544cc2006-02-14 22:30:52 -06001843 rc = -EFAULT;
Steve French93544cc2006-02-14 22:30:52 -06001844
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001845 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001846 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001847 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001848 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 smb_read_data = NULL;
1850 }
1851 }
1852 if (rc || (bytes_read == 0)) {
1853 if (total_read) {
1854 break;
1855 } else {
1856 FreeXid(xid);
1857 return rc;
1858 }
1859 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001860 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 *poffset += bytes_read;
1862 }
1863 }
1864 FreeXid(xid);
1865 return total_read;
1866}
1867
1868
1869static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1870 loff_t *poffset)
1871{
1872 int rc = -EACCES;
1873 unsigned int bytes_read = 0;
1874 unsigned int total_read;
1875 unsigned int current_read_size;
1876 struct cifs_sb_info *cifs_sb;
1877 struct cifsTconInfo *pTcon;
1878 int xid;
1879 char *current_offset;
1880 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001881 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882
1883 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001884 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885 pTcon = cifs_sb->tcon;
1886
1887 if (file->private_data == NULL) {
1888 FreeXid(xid);
1889 return -EBADF;
1890 }
1891 open_file = (struct cifsFileInfo *)file->private_data;
1892
1893 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1894 cFYI(1, ("attempting read on write only file instance"));
1895
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001896 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 read_size > total_read;
1898 total_read += bytes_read, current_offset += bytes_read) {
1899 current_read_size = min_t(const int, read_size - total_read,
1900 cifs_sb->rsize);
Steve Frenchf9f5c812005-09-15 23:06:38 -07001901 /* For windows me and 9x we do not want to request more
1902 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001903 if ((pTcon->ses) &&
Steve Frenchf9f5c812005-09-15 23:06:38 -07001904 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1905 current_read_size = min_t(const int, current_read_size,
1906 pTcon->ses->server->maxBuf - 128);
1907 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 rc = -EAGAIN;
1909 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001910 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001912 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 if (rc != 0)
1914 break;
1915 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001916 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001917 open_file->netfid,
1918 current_read_size, *poffset,
1919 &bytes_read, &current_offset,
1920 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 }
1922 if (rc || (bytes_read == 0)) {
1923 if (total_read) {
1924 break;
1925 } else {
1926 FreeXid(xid);
1927 return rc;
1928 }
1929 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001930 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931 *poffset += bytes_read;
1932 }
1933 }
1934 FreeXid(xid);
1935 return total_read;
1936}
1937
1938int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1939{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001940 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 int rc, xid;
1942
1943 xid = GetXid();
1944 rc = cifs_revalidate(dentry);
1945 if (rc) {
1946 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1947 FreeXid(xid);
1948 return rc;
1949 }
1950 rc = generic_file_mmap(file, vma);
1951 FreeXid(xid);
1952 return rc;
1953}
1954
1955
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001956static void cifs_copy_cache_pages(struct address_space *mapping,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 struct list_head *pages, int bytes_read, char *data,
1958 struct pagevec *plru_pvec)
1959{
1960 struct page *page;
1961 char *target;
1962
1963 while (bytes_read > 0) {
1964 if (list_empty(pages))
1965 break;
1966
1967 page = list_entry(pages->prev, struct page, lru);
1968 list_del(&page->lru);
1969
1970 if (add_to_page_cache(page, mapping, page->index,
1971 GFP_KERNEL)) {
1972 page_cache_release(page);
1973 cFYI(1, ("Add page cache failed"));
Steve French3079ca62005-06-09 14:44:07 -07001974 data += PAGE_CACHE_SIZE;
1975 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 continue;
1977 }
1978
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001979 target = kmap_atomic(page, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980
1981 if (PAGE_CACHE_SIZE > bytes_read) {
1982 memcpy(target, data, bytes_read);
1983 /* zero the tail end of this partial page */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001984 memset(target + bytes_read, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 PAGE_CACHE_SIZE - bytes_read);
1986 bytes_read = 0;
1987 } else {
1988 memcpy(target, data, PAGE_CACHE_SIZE);
1989 bytes_read -= PAGE_CACHE_SIZE;
1990 }
1991 kunmap_atomic(target, KM_USER0);
1992
1993 flush_dcache_page(page);
1994 SetPageUptodate(page);
1995 unlock_page(page);
1996 if (!pagevec_add(plru_pvec, page))
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001997 __pagevec_lru_add_file(plru_pvec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 data += PAGE_CACHE_SIZE;
1999 }
2000 return;
2001}
2002
2003static int cifs_readpages(struct file *file, struct address_space *mapping,
2004 struct list_head *page_list, unsigned num_pages)
2005{
2006 int rc = -EACCES;
2007 int xid;
2008 loff_t offset;
2009 struct page *page;
2010 struct cifs_sb_info *cifs_sb;
2011 struct cifsTconInfo *pTcon;
Steve French2c2130e2007-10-12 19:10:28 +00002012 unsigned int bytes_read = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002013 unsigned int read_size, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 char *smb_read_data = NULL;
2015 struct smb_com_read_rsp *pSMBr;
2016 struct pagevec lru_pvec;
2017 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08002018 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019
2020 xid = GetXid();
2021 if (file->private_data == NULL) {
2022 FreeXid(xid);
2023 return -EBADF;
2024 }
2025 open_file = (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002026 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 pTcon = cifs_sb->tcon;
Steve Frenchbfa0d752005-08-31 21:50:37 -07002028
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 pagevec_init(&lru_pvec, 0);
Steve French61de8002008-10-30 20:15:22 +00002030 cFYI(DBG2, ("rpages: num pages %d", num_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 for (i = 0; i < num_pages; ) {
2032 unsigned contig_pages;
2033 struct page *tmp_page;
2034 unsigned long expected_index;
2035
2036 if (list_empty(page_list))
2037 break;
2038
2039 page = list_entry(page_list->prev, struct page, lru);
2040 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2041
2042 /* count adjacent pages that we will read into */
2043 contig_pages = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002044 expected_index =
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 list_entry(page_list->prev, struct page, lru)->index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002046 list_for_each_entry_reverse(tmp_page, page_list, lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 if (tmp_page->index == expected_index) {
2048 contig_pages++;
2049 expected_index++;
2050 } else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002051 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052 }
2053 if (contig_pages + i > num_pages)
2054 contig_pages = num_pages - i;
2055
2056 /* for reads over a certain size could initiate async
2057 read ahead */
2058
2059 read_size = contig_pages * PAGE_CACHE_SIZE;
2060 /* Read size needs to be in multiples of one page */
2061 read_size = min_t(const unsigned int, read_size,
2062 cifs_sb->rsize & PAGE_CACHE_MASK);
Steve French90c81e02008-02-12 20:32:36 +00002063 cFYI(DBG2, ("rpages: read size 0x%x contiguous pages %d",
Steve French75865f82007-06-24 18:30:48 +00002064 read_size, contig_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 rc = -EAGAIN;
2066 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002067 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00002069 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070 if (rc != 0)
2071 break;
2072 }
2073
Steve Frenchbfa0d752005-08-31 21:50:37 -07002074 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08002075 open_file->netfid,
2076 read_size, offset,
2077 &bytes_read, &smb_read_data,
2078 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07002079 /* BB more RC checks ? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002080 if (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002082 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002083 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002084 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002085 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 smb_read_data = NULL;
2087 }
2088 }
2089 }
2090 if ((rc < 0) || (smb_read_data == NULL)) {
2091 cFYI(1, ("Read error in readpages: %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 break;
2093 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08002094 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2096 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2097 smb_read_data + 4 /* RFC1001 hdr */ +
2098 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
2099
2100 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha4544342005-08-24 13:59:35 -07002101 cifs_stats_bytes_read(pTcon, bytes_read);
Steve French2c2130e2007-10-12 19:10:28 +00002102 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 i++; /* account for partial page */
2104
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002105 /* server copy of file can have smaller size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002106 than client */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002107 /* BB do we need to verify this common case ?
2108 this case is ok - if we are at server EOF
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 we will hit it on next read */
2110
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08002111 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 }
2113 } else {
2114 cFYI(1, ("No bytes read (%d) at offset %lld . "
2115 "Cleaning remaining pages from readahead list",
2116 bytes_read, offset));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002117 /* BB turn off caching and do new lookup on
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002119 break;
2120 }
2121 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002122 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002123 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002124 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002125 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 smb_read_data = NULL;
2127 }
2128 bytes_read = 0;
2129 }
2130
Rik van Riel4f98a2f2008-10-18 20:26:32 -07002131 pagevec_lru_add_file(&lru_pvec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132
2133/* need to free smb_read_data buf before exit */
2134 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002135 if (buf_type == CIFS_SMALL_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002136 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002137 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002138 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 smb_read_data = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002140 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141
2142 FreeXid(xid);
2143 return rc;
2144}
2145
2146static int cifs_readpage_worker(struct file *file, struct page *page,
2147 loff_t *poffset)
2148{
2149 char *read_data;
2150 int rc;
2151
2152 page_cache_get(page);
2153 read_data = kmap(page);
2154 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002155
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002157
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158 if (rc < 0)
2159 goto io_error;
2160 else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002161 cFYI(1, ("Bytes read %d", rc));
2162
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002163 file->f_path.dentry->d_inode->i_atime =
2164 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002165
Linus Torvalds1da177e2005-04-16 15:20:36 -07002166 if (PAGE_CACHE_SIZE > rc)
2167 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2168
2169 flush_dcache_page(page);
2170 SetPageUptodate(page);
2171 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002172
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002174 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 page_cache_release(page);
2176 return rc;
2177}
2178
2179static int cifs_readpage(struct file *file, struct page *page)
2180{
2181 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2182 int rc = -EACCES;
2183 int xid;
2184
2185 xid = GetXid();
2186
2187 if (file->private_data == NULL) {
2188 FreeXid(xid);
2189 return -EBADF;
2190 }
2191
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002192 cFYI(1, ("readpage %p at offset %d 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193 page, (int)offset, (int)offset));
2194
2195 rc = cifs_readpage_worker(file, page, &offset);
2196
2197 unlock_page(page);
2198
2199 FreeXid(xid);
2200 return rc;
2201}
2202
Steve Frencha403a0a2007-07-26 15:54:16 +00002203static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2204{
2205 struct cifsFileInfo *open_file;
2206
2207 read_lock(&GlobalSMBSeslock);
2208 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2209 if (open_file->closePend)
2210 continue;
2211 if (open_file->pfile &&
2212 ((open_file->pfile->f_flags & O_RDWR) ||
2213 (open_file->pfile->f_flags & O_WRONLY))) {
2214 read_unlock(&GlobalSMBSeslock);
2215 return 1;
2216 }
2217 }
2218 read_unlock(&GlobalSMBSeslock);
2219 return 0;
2220}
2221
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222/* We do not want to update the file size from server for inodes
2223 open for write - to avoid races with writepage extending
2224 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002225 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 but this is tricky to do without racing with writebehind
2227 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00002228bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229{
Steve Frencha403a0a2007-07-26 15:54:16 +00002230 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00002231 return true;
Steve French23e7dd72005-10-20 13:44:56 -07002232
Steve Frencha403a0a2007-07-26 15:54:16 +00002233 if (is_inode_writable(cifsInode)) {
2234 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08002235 struct cifs_sb_info *cifs_sb;
2236
Steve Frenchc32a0b62006-01-12 14:41:28 -08002237 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00002238 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002239 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08002240 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00002241 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08002242 }
2243
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002244 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00002245 return true;
Steve French7ba52632007-02-08 18:14:13 +00002246
Steve French4b18f2a2008-04-29 00:06:05 +00002247 return false;
Steve French23e7dd72005-10-20 13:44:56 -07002248 } else
Steve French4b18f2a2008-04-29 00:06:05 +00002249 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250}
2251
Nick Piggind9414772008-09-24 11:32:59 -04002252static int cifs_write_begin(struct file *file, struct address_space *mapping,
2253 loff_t pos, unsigned len, unsigned flags,
2254 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255{
Nick Piggind9414772008-09-24 11:32:59 -04002256 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2257 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002258 loff_t page_start = pos & PAGE_MASK;
2259 loff_t i_size;
2260 struct page *page;
2261 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262
Nick Piggind9414772008-09-24 11:32:59 -04002263 cFYI(1, ("write_begin from %lld len %d", (long long)pos, len));
2264
Nick Piggin54566b22009-01-04 12:00:53 -08002265 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002266 if (!page) {
2267 rc = -ENOMEM;
2268 goto out;
2269 }
Nick Piggind9414772008-09-24 11:32:59 -04002270
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002271 if (PageUptodate(page))
2272 goto out;
Steve French8a236262007-03-06 00:31:00 +00002273
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002274 /*
2275 * If we write a full page it will be up to date, no need to read from
2276 * the server. If the write is short, we'll end up doing a sync write
2277 * instead.
2278 */
2279 if (len == PAGE_CACHE_SIZE)
2280 goto out;
2281
2282 /*
2283 * optimize away the read when we have an oplock, and we're not
2284 * expecting to use any of the data we'd be reading in. That
2285 * is, when the page lies beyond the EOF, or straddles the EOF
2286 * and the write will cover all of the existing data.
2287 */
2288 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2289 i_size = i_size_read(mapping->host);
2290 if (page_start >= i_size ||
2291 (offset == 0 && (pos + len) >= i_size)) {
2292 zero_user_segments(page, 0, offset,
2293 offset + len,
2294 PAGE_CACHE_SIZE);
2295 /*
2296 * PageChecked means that the parts of the page
2297 * to which we're not writing are considered up
2298 * to date. Once the data is copied to the
2299 * page, it can be set uptodate.
2300 */
2301 SetPageChecked(page);
2302 goto out;
2303 }
2304 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002305
Nick Piggind9414772008-09-24 11:32:59 -04002306 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002307 /*
2308 * might as well read a page, it is fast enough. If we get
2309 * an error, we don't need to return it. cifs_write_end will
2310 * do a sync write instead since PG_uptodate isn't set.
2311 */
2312 cifs_readpage_worker(file, page, &page_start);
Steve French8a236262007-03-06 00:31:00 +00002313 } else {
2314 /* we could try using another file handle if there is one -
2315 but how would we lock it to prevent close of that handle
2316 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04002317 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00002318 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002319out:
2320 *pagep = page;
2321 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322}
2323
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002324const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325 .readpage = cifs_readpage,
2326 .readpages = cifs_readpages,
2327 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002328 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002329 .write_begin = cifs_write_begin,
2330 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 .set_page_dirty = __set_page_dirty_nobuffers,
2332 /* .sync_page = cifs_sync_page, */
2333 /* .direct_IO = */
2334};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002335
2336/*
2337 * cifs_readpages requires the server to support a buffer large enough to
2338 * contain the header plus one complete page of data. Otherwise, we need
2339 * to leave cifs_readpages out of the address space operations.
2340 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002341const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002342 .readpage = cifs_readpage,
2343 .writepage = cifs_writepage,
2344 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002345 .write_begin = cifs_write_begin,
2346 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002347 .set_page_dirty = __set_page_dirty_nobuffers,
2348 /* .sync_page = cifs_sync_page, */
2349 /* .direct_IO = */
2350};