blob: 394cf28f080d432a20643dbba562094a5054d8d0 [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 *
Steve Frenchf19159d2010-04-21 04:12:10 +00006 * Copyright (C) International Business Machines Corp., 2002,2010
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Author(s): Steve French (sfrench@us.ibm.com)
Jeremy Allison7ee1af72006-08-02 21:56:33 +00008 * Jeremy Allison (jra@samba.org)
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
10 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24#include <linux/fs.h>
Steve French37c0eb42005-10-05 14:50:29 -070025#include <linux/backing-dev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/stat.h>
27#include <linux/fcntl.h>
28#include <linux/pagemap.h>
29#include <linux/pagevec.h>
Steve French37c0eb42005-10-05 14:50:29 -070030#include <linux/writeback.h>
Andrew Morton6f88cc22006-12-10 02:19:44 -080031#include <linux/task_io_accounting_ops.h>
Steve French23e7dd72005-10-20 13:44:56 -070032#include <linux/delay.h>
Jeff Layton3bc303c2009-09-21 06:47:50 -040033#include <linux/mount.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090034#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <asm/div64.h>
36#include "cifsfs.h"
37#include "cifspdu.h"
38#include "cifsglob.h"
39#include "cifsproto.h"
40#include "cifs_unicode.h"
41#include "cifs_debug.h"
42#include "cifs_fs_sb.h"
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +053043#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Linus Torvalds1da177e2005-04-16 15:20:36 -070045static inline int cifs_convert_flags(unsigned int flags)
46{
47 if ((flags & O_ACCMODE) == O_RDONLY)
48 return GENERIC_READ;
49 else if ((flags & O_ACCMODE) == O_WRONLY)
50 return GENERIC_WRITE;
51 else if ((flags & O_ACCMODE) == O_RDWR) {
52 /* GENERIC_ALL is too much permission to request
53 can cause unnecessary access denied on create */
54 /* return GENERIC_ALL; */
55 return (GENERIC_READ | GENERIC_WRITE);
56 }
57
Jeff Laytone10f7b52008-05-14 10:21:33 -070058 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
59 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
60 FILE_READ_DATA);
Steve French7fc8f4e2009-02-23 20:43:11 +000061}
Jeff Laytone10f7b52008-05-14 10:21:33 -070062
Jeff Layton608712f2010-10-15 15:33:56 -040063static u32 cifs_posix_convert_flags(unsigned int flags)
Steve French7fc8f4e2009-02-23 20:43:11 +000064{
Jeff Layton608712f2010-10-15 15:33:56 -040065 u32 posix_flags = 0;
Jeff Laytone10f7b52008-05-14 10:21:33 -070066
Steve French7fc8f4e2009-02-23 20:43:11 +000067 if ((flags & O_ACCMODE) == O_RDONLY)
Jeff Layton608712f2010-10-15 15:33:56 -040068 posix_flags = SMB_O_RDONLY;
Steve French7fc8f4e2009-02-23 20:43:11 +000069 else if ((flags & O_ACCMODE) == O_WRONLY)
Jeff Layton608712f2010-10-15 15:33:56 -040070 posix_flags = SMB_O_WRONLY;
71 else if ((flags & O_ACCMODE) == O_RDWR)
72 posix_flags = SMB_O_RDWR;
73
74 if (flags & O_CREAT)
75 posix_flags |= SMB_O_CREAT;
76 if (flags & O_EXCL)
77 posix_flags |= SMB_O_EXCL;
78 if (flags & O_TRUNC)
79 posix_flags |= SMB_O_TRUNC;
80 /* be safe and imply O_SYNC for O_DSYNC */
Christoph Hellwig6b2f3d12009-10-27 11:05:28 +010081 if (flags & O_DSYNC)
Jeff Layton608712f2010-10-15 15:33:56 -040082 posix_flags |= SMB_O_SYNC;
Steve French7fc8f4e2009-02-23 20:43:11 +000083 if (flags & O_DIRECTORY)
Jeff Layton608712f2010-10-15 15:33:56 -040084 posix_flags |= SMB_O_DIRECTORY;
Steve French7fc8f4e2009-02-23 20:43:11 +000085 if (flags & O_NOFOLLOW)
Jeff Layton608712f2010-10-15 15:33:56 -040086 posix_flags |= SMB_O_NOFOLLOW;
Steve French7fc8f4e2009-02-23 20:43:11 +000087 if (flags & O_DIRECT)
Jeff Layton608712f2010-10-15 15:33:56 -040088 posix_flags |= SMB_O_DIRECT;
Steve French7fc8f4e2009-02-23 20:43:11 +000089
90 return posix_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091}
92
93static inline int cifs_get_disposition(unsigned int flags)
94{
95 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
96 return FILE_CREATE;
97 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
98 return FILE_OVERWRITE_IF;
99 else if ((flags & O_CREAT) == O_CREAT)
100 return FILE_OPEN_IF;
Steve French55aa2e02006-05-30 18:09:31 +0000101 else if ((flags & O_TRUNC) == O_TRUNC)
102 return FILE_OVERWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 else
104 return FILE_OPEN;
105}
106
Jeff Laytondb460242010-06-16 13:40:17 -0400107static inline int cifs_open_inode_helper(struct inode *inode,
Suresh Jayaramana347ecb2010-09-17 19:43:10 +0530108 struct cifsTconInfo *pTcon, __u32 oplock, FILE_ALL_INFO *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 char *full_path, int xid)
110{
Jeff Laytondb460242010-06-16 13:40:17 -0400111 struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 struct timespec temp;
113 int rc;
114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 if (pCifsInode->clientCanCacheRead) {
116 /* we have the inode open somewhere else
117 no need to discard cache data */
118 goto client_can_cache;
119 }
120
121 /* BB need same check in cifs_create too? */
122 /* if not oplocked, invalidate inode pages if mtime or file
123 size changed */
Jeff Layton07119a42009-05-27 09:37:33 -0400124 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
Jeff Laytondb460242010-06-16 13:40:17 -0400125 if (timespec_equal(&inode->i_mtime, &temp) &&
126 (inode->i_size ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 (loff_t)le64_to_cpu(buf->EndOfFile))) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000128 cFYI(1, "inode unchanged on server");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 } else {
Jeff Laytondb460242010-06-16 13:40:17 -0400130 if (inode->i_mapping) {
Steve Frenchff2157132010-03-09 20:30:42 +0000131 /* BB no need to lock inode until after invalidate
132 since namei code should already have it locked? */
Jeff Laytondb460242010-06-16 13:40:17 -0400133 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +0000134 if (rc != 0)
Jeff Laytondb460242010-06-16 13:40:17 -0400135 pCifsInode->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000137 cFYI(1, "invalidating remote inode since open detected it "
138 "changed");
Jeff Laytondb460242010-06-16 13:40:17 -0400139 invalidate_remote_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 }
141
142client_can_cache:
Steve Frenchc18c8422007-07-18 23:21:09 +0000143 if (pTcon->unix_ext)
Jeff Laytondb460242010-06-16 13:40:17 -0400144 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
145 xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 else
Jeff Laytondb460242010-06-16 13:40:17 -0400147 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
148 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
Suresh Jayaramana347ecb2010-09-17 19:43:10 +0530150 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000151 pCifsInode->clientCanCacheAll = true;
152 pCifsInode->clientCanCacheRead = true;
Jeff Laytondb460242010-06-16 13:40:17 -0400153 cFYI(1, "Exclusive Oplock granted on inode %p", inode);
Suresh Jayaramana347ecb2010-09-17 19:43:10 +0530154 } else if ((oplock & 0xF) == OPLOCK_READ)
Steve French4b18f2a2008-04-29 00:06:05 +0000155 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157 return rc;
158}
159
Jeff Layton608712f2010-10-15 15:33:56 -0400160int cifs_posix_open(char *full_path, struct inode **pinode,
161 struct super_block *sb, int mode, unsigned int f_flags,
162 __u32 *poplock, __u16 *pnetfid, int xid)
163{
164 int rc;
165 FILE_UNIX_BASIC_INFO *presp_data;
166 __u32 posix_flags = 0;
167 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
168 struct cifs_fattr fattr;
169 struct tcon_link *tlink;
170 struct cifsTconInfo *tcon;
171
172 cFYI(1, "posix open %s", full_path);
173
174 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
175 if (presp_data == NULL)
176 return -ENOMEM;
177
178 tlink = cifs_sb_tlink(cifs_sb);
179 if (IS_ERR(tlink)) {
180 rc = PTR_ERR(tlink);
181 goto posix_open_ret;
182 }
183
184 tcon = tlink_tcon(tlink);
185 mode &= ~current_umask();
186
187 posix_flags = cifs_posix_convert_flags(f_flags);
188 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
189 poplock, full_path, cifs_sb->local_nls,
190 cifs_sb->mnt_cifs_flags &
191 CIFS_MOUNT_MAP_SPECIAL_CHR);
192 cifs_put_tlink(tlink);
193
194 if (rc)
195 goto posix_open_ret;
196
197 if (presp_data->Type == cpu_to_le32(-1))
198 goto posix_open_ret; /* open ok, caller does qpathinfo */
199
200 if (!pinode)
201 goto posix_open_ret; /* caller does not need info */
202
203 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
204
205 /* get new inode and set it up */
206 if (*pinode == NULL) {
207 cifs_fill_uniqueid(sb, &fattr);
208 *pinode = cifs_iget(sb, &fattr);
209 if (!*pinode) {
210 rc = -ENOMEM;
211 goto posix_open_ret;
212 }
213 } else {
214 cifs_fattr_to_inode(*pinode, &fattr);
215 }
216
217posix_open_ret:
218 kfree(presp_data);
219 return rc;
220}
221
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222int cifs_open(struct inode *inode, struct file *file)
223{
224 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400225 int xid;
226 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 struct cifs_sb_info *cifs_sb;
Steve French276a74a2009-03-03 18:00:34 +0000228 struct cifsTconInfo *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400229 struct tcon_link *tlink;
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400230 struct cifsFileInfo *pCifsFile = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 struct cifsInodeInfo *pCifsInode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 char *full_path = NULL;
233 int desiredAccess;
234 int disposition;
235 __u16 netfid;
236 FILE_ALL_INFO *buf = NULL;
237
238 xid = GetXid();
239
240 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400241 tlink = cifs_sb_tlink(cifs_sb);
242 if (IS_ERR(tlink)) {
243 FreeXid(xid);
244 return PTR_ERR(tlink);
245 }
246 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
Steve Frencha6ce4932009-04-09 01:14:32 +0000248 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800250 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530252 rc = -ENOMEM;
Jeff Layton232341b2010-08-05 13:58:38 -0400253 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254 }
255
Joe Perchesb6b38f72010-04-21 03:50:45 +0000256 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
257 inode, file->f_flags, full_path);
Steve French276a74a2009-03-03 18:00:34 +0000258
259 if (oplockEnabled)
260 oplock = REQ_OPLOCK;
261 else
262 oplock = 0;
263
Steve French64cc2c62009-03-04 19:54:08 +0000264 if (!tcon->broken_posix_open && tcon->unix_ext &&
265 (tcon->ses->capabilities & CAP_UNIX) &&
Steve French276a74a2009-03-03 18:00:34 +0000266 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
267 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Steve French276a74a2009-03-03 18:00:34 +0000268 /* can not refresh inode info since size could be stale */
Jeff Layton2422f672010-06-16 13:40:16 -0400269 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
Steve Frenchfa588e02010-04-22 19:21:55 +0000270 cifs_sb->mnt_file_mode /* ignored */,
Jeff Layton608712f2010-10-15 15:33:56 -0400271 file->f_flags, &oplock, &netfid, xid);
Steve French276a74a2009-03-03 18:00:34 +0000272 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000273 cFYI(1, "posix open succeeded");
Jeff Layton47c78b72010-06-16 13:40:17 -0400274
Jeff Laytonabfe1ee2010-10-15 15:33:58 -0400275 pCifsFile = cifs_new_fileinfo(netfid, file, tlink,
276 oplock);
Jeff Layton2422f672010-06-16 13:40:16 -0400277 if (pCifsFile == NULL) {
278 CIFSSMBClose(xid, tcon, netfid);
279 rc = -ENOMEM;
Jeff Layton2422f672010-06-16 13:40:16 -0400280 }
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530281
282 cifs_fscache_set_inode_cookie(inode, file);
283
Steve French276a74a2009-03-03 18:00:34 +0000284 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000285 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
286 if (tcon->ses->serverNOS)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000287 cERROR(1, "server %s of type %s returned"
Steve French64cc2c62009-03-04 19:54:08 +0000288 " unexpected error on SMB posix open"
289 ", disabling posix open support."
290 " Check if server update available.",
291 tcon->ses->serverName,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000292 tcon->ses->serverNOS);
Steve French64cc2c62009-03-04 19:54:08 +0000293 tcon->broken_posix_open = true;
Steve French276a74a2009-03-03 18:00:34 +0000294 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
295 (rc != -EOPNOTSUPP)) /* path not found or net err */
296 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000297 /* else fallthrough to retry open the old way on network i/o
298 or DFS errors */
Steve French276a74a2009-03-03 18:00:34 +0000299 }
300
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 desiredAccess = cifs_convert_flags(file->f_flags);
302
303/*********************************************************************
304 * open flag mapping table:
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000305 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 * POSIX Flag CIFS Disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000307 * ---------- ----------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 * O_CREAT FILE_OPEN_IF
309 * O_CREAT | O_EXCL FILE_CREATE
310 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
311 * O_TRUNC FILE_OVERWRITE
312 * none of the above FILE_OPEN
313 *
314 * Note that there is not a direct match between disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000315 * FILE_SUPERSEDE (ie create whether or not file exists although
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 * O_CREAT | O_TRUNC is similar but truncates the existing
317 * file rather than creating a new file as FILE_SUPERSEDE does
318 * (which uses the attributes / metadata passed in on open call)
319 *?
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000320 *? O_SYNC is a reasonable match to CIFS writethrough flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 *? and the read write flags match reasonably. O_LARGEFILE
322 *? is irrelevant because largefile support is always used
323 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
324 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
325 *********************************************************************/
326
327 disposition = cifs_get_disposition(file->f_flags);
328
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 /* BB pass O_SYNC flag through on file attributes .. BB */
330
331 /* Also refresh inode by passing in file_info buf returned by SMBOpen
332 and calling get_inode_info with returned buf (at least helps
333 non-Unix server case) */
334
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000335 /* BB we can not do this if this is the second open of a file
336 and the first handle has writebehind data, we might be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
338 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
339 if (!buf) {
340 rc = -ENOMEM;
341 goto out;
342 }
Steve French5bafd762006-06-07 00:18:43 +0000343
Jeff Laytona6e8a842010-09-20 16:01:33 -0700344 if (tcon->ses->capabilities & CAP_NT_SMBS)
Steve French276a74a2009-03-03 18:00:34 +0000345 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
Steve French5bafd762006-06-07 00:18:43 +0000346 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
Steve French737b7582005-04-28 22:41:06 -0700347 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
348 & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000349 else
350 rc = -EIO; /* no NT SMB support fall into legacy open below */
351
Steve Frencha9d02ad2005-08-24 23:06:05 -0700352 if (rc == -EIO) {
353 /* Old server, try legacy style OpenX */
Steve French276a74a2009-03-03 18:00:34 +0000354 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
Steve Frencha9d02ad2005-08-24 23:06:05 -0700355 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
356 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
357 & CIFS_MOUNT_MAP_SPECIAL_CHR);
358 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000360 cFYI(1, "cifs_open returned 0x%x", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 goto out;
362 }
Jeff Layton3321b792009-09-25 09:53:37 -0400363
Suresh Jayaramana347ecb2010-09-17 19:43:10 +0530364 rc = cifs_open_inode_helper(inode, tcon, oplock, buf, full_path, xid);
Jeff Layton47c78b72010-06-16 13:40:17 -0400365 if (rc != 0)
366 goto out;
367
Jeff Laytonabfe1ee2010-10-15 15:33:58 -0400368 pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400369 if (pCifsFile == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 rc = -ENOMEM;
371 goto out;
372 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530374 cifs_fscache_set_inode_cookie(inode, file);
375
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000376 if (oplock & CIFS_CREATE_ACTION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 /* time to set mode which we can not set earlier due to
378 problems creating new read-only files */
Steve French276a74a2009-03-03 18:00:34 +0000379 if (tcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400380 struct cifs_unix_set_info_args args = {
381 .mode = inode->i_mode,
382 .uid = NO_CHANGE_64,
383 .gid = NO_CHANGE_64,
384 .ctime = NO_CHANGE_64,
385 .atime = NO_CHANGE_64,
386 .mtime = NO_CHANGE_64,
387 .device = 0,
388 };
Jeff Layton01ea95e2009-07-09 20:02:49 -0400389 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
390 cifs_sb->local_nls,
391 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700392 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 }
394 }
395
396out:
397 kfree(buf);
398 kfree(full_path);
399 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400400 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 return rc;
402}
403
Adrian Bunk04187262006-06-30 18:23:04 +0200404/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405/* to server was lost */
406static int cifs_relock_file(struct cifsFileInfo *cifsFile)
407{
408 int rc = 0;
409
410/* BB list all locks open on this file and relock */
411
412 return rc;
413}
414
Steve French4b18f2a2008-04-29 00:06:05 +0000415static int cifs_reopen_file(struct file *file, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416{
417 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400418 int xid;
419 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 struct cifs_sb_info *cifs_sb;
Steve French7fc8f4e2009-02-23 20:43:11 +0000421 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 struct cifsFileInfo *pCifsFile;
423 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000424 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 char *full_path = NULL;
426 int desiredAccess;
427 int disposition = FILE_OPEN;
428 __u16 netfid;
429
Steve Frenchad7a2922008-02-07 23:25:02 +0000430 if (file->private_data)
Joe Perchesc21dfb62010-07-12 13:50:14 -0700431 pCifsFile = file->private_data;
Steve Frenchad7a2922008-02-07 23:25:02 +0000432 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 return -EBADF;
434
435 xid = GetXid();
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400436 mutex_lock(&pCifsFile->fh_mutex);
Steve French4b18f2a2008-04-29 00:06:05 +0000437 if (!pCifsFile->invalidHandle) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400438 mutex_unlock(&pCifsFile->fh_mutex);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530439 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530441 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 }
443
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800444 if (file->f_path.dentry == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000445 cERROR(1, "no valid name if dentry freed");
Steve French3a9f4622007-04-04 17:10:24 +0000446 dump_stack();
447 rc = -EBADF;
448 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 }
Steve French3a9f4622007-04-04 17:10:24 +0000450
451 inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000452 if (inode == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000453 cERROR(1, "inode not valid");
Steve French3a9f4622007-04-04 17:10:24 +0000454 dump_stack();
455 rc = -EBADF;
456 goto reopen_error_exit;
457 }
Steve French50c2f752007-07-13 00:33:32 +0000458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton13cfb732010-09-29 19:51:11 -0400460 tcon = tlink_tcon(pCifsFile->tlink);
Steve French3a9f4622007-04-04 17:10:24 +0000461
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462/* can not grab rename sem here because various ops, including
463 those that already have the rename sem can end up causing writepage
464 to get called and if the server was down that means we end up here,
465 and we can never tell if the caller already has the rename_sem */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800466 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000468 rc = -ENOMEM;
469reopen_error_exit:
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400470 mutex_unlock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000472 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 }
474
Joe Perchesb6b38f72010-04-21 03:50:45 +0000475 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
476 inode, file->f_flags, full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
478 if (oplockEnabled)
479 oplock = REQ_OPLOCK;
480 else
Steve French4b18f2a2008-04-29 00:06:05 +0000481 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
Steve French7fc8f4e2009-02-23 20:43:11 +0000483 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
484 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
485 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton608712f2010-10-15 15:33:56 -0400486
487 /*
488 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
489 * original open. Must mask them off for a reopen.
490 */
491 unsigned int oflags = file->f_flags & ~(O_CREAT|O_EXCL|O_TRUNC);
492
Jeff Layton2422f672010-06-16 13:40:16 -0400493 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
Steve Frenchfa588e02010-04-22 19:21:55 +0000494 cifs_sb->mnt_file_mode /* ignored */,
495 oflags, &oplock, &netfid, xid);
Steve French7fc8f4e2009-02-23 20:43:11 +0000496 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000497 cFYI(1, "posix reopen succeeded");
Steve French7fc8f4e2009-02-23 20:43:11 +0000498 goto reopen_success;
499 }
500 /* fallthrough to retry open the old way on errors, especially
501 in the reconnect path it is important to retry hard */
502 }
503
504 desiredAccess = cifs_convert_flags(file->f_flags);
505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000507 by SMBOpen and then calling get_inode_info with returned buf
508 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 and server version of file size can be stale. If we knew for sure
510 that inode was not dirty locally we could do this */
511
Steve French7fc8f4e2009-02-23 20:43:11 +0000512 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 CREATE_NOT_DIR, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000514 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700515 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 if (rc) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400517 mutex_unlock(&pCifsFile->fh_mutex);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000518 cFYI(1, "cifs_open returned 0x%x", rc);
519 cFYI(1, "oplock: %d", oplock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 } else {
Steve French7fc8f4e2009-02-23 20:43:11 +0000521reopen_success:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 pCifsFile->netfid = netfid;
Steve French4b18f2a2008-04-29 00:06:05 +0000523 pCifsFile->invalidHandle = false;
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400524 mutex_unlock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 pCifsInode = CIFS_I(inode);
526 if (pCifsInode) {
527 if (can_flush) {
Jeff Laytoncea21802007-11-20 23:19:03 +0000528 rc = filemap_write_and_wait(inode->i_mapping);
529 if (rc != 0)
530 CIFS_I(inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 /* temporarily disable caching while we
532 go to server to get inode info */
Steve French4b18f2a2008-04-29 00:06:05 +0000533 pCifsInode->clientCanCacheAll = false;
534 pCifsInode->clientCanCacheRead = false;
Steve French7fc8f4e2009-02-23 20:43:11 +0000535 if (tcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 rc = cifs_get_inode_info_unix(&inode,
537 full_path, inode->i_sb, xid);
538 else
539 rc = cifs_get_inode_info(&inode,
540 full_path, NULL, inode->i_sb,
Steve French8b1327f2008-03-14 22:37:16 +0000541 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 } /* else we are writing out data to server already
543 and could deadlock if we tried to flush data, and
544 since we do not know if we have data that would
545 invalidate the current end of file on the server
546 we can not go to the server to get the new inod
547 info */
548 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000549 pCifsInode->clientCanCacheAll = true;
550 pCifsInode->clientCanCacheRead = true;
Joe Perchesb6b38f72010-04-21 03:50:45 +0000551 cFYI(1, "Exclusive Oplock granted on inode %p",
552 file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 } else if ((oplock & 0xF) == OPLOCK_READ) {
Steve French4b18f2a2008-04-29 00:06:05 +0000554 pCifsInode->clientCanCacheRead = true;
555 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 } else {
Steve French4b18f2a2008-04-29 00:06:05 +0000557 pCifsInode->clientCanCacheRead = false;
558 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 }
560 cifs_relock_file(pCifsFile);
561 }
562 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 kfree(full_path);
564 FreeXid(xid);
565 return rc;
566}
567
568int cifs_close(struct inode *inode, struct file *file)
569{
570 int rc = 0;
Steve French15745322007-09-07 22:23:48 +0000571 int xid, timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 struct cifs_sb_info *cifs_sb;
573 struct cifsTconInfo *pTcon;
Joe Perchesc21dfb62010-07-12 13:50:14 -0700574 struct cifsFileInfo *pSMBFile = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
576 xid = GetXid();
577
578 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton13cfb732010-09-29 19:51:11 -0400579 pTcon = tlink_tcon(pSMBFile->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 if (pSMBFile) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000581 struct cifsLockInfo *li, *tmp;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000582 write_lock(&GlobalSMBSeslock);
Steve French4b18f2a2008-04-29 00:06:05 +0000583 pSMBFile->closePend = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 if (pTcon) {
585 /* no sense reconnecting to close a file that is
586 already closed */
Steve French3b795212008-11-13 19:45:32 +0000587 if (!pTcon->need_reconnect) {
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000588 write_unlock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +0000589 timeout = 2;
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400590 while ((atomic_read(&pSMBFile->count) != 1)
Steve French15745322007-09-07 22:23:48 +0000591 && (timeout <= 2048)) {
Steve French23e7dd72005-10-20 13:44:56 -0700592 /* Give write a better chance to get to
593 server ahead of the close. We do not
594 want to add a wait_q here as it would
595 increase the memory utilization as
596 the struct would be in each open file,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000597 but this should give enough time to
Steve French23e7dd72005-10-20 13:44:56 -0700598 clear the socket */
Joe Perchesb6b38f72010-04-21 03:50:45 +0000599 cFYI(DBG2, "close delay, write pending");
Steve French23e7dd72005-10-20 13:44:56 -0700600 msleep(timeout);
601 timeout *= 4;
Steve French4891d532006-11-07 16:31:16 +0000602 }
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000603 if (!pTcon->need_reconnect &&
604 !pSMBFile->invalidHandle)
605 rc = CIFSSMBClose(xid, pTcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 pSMBFile->netfid);
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000607 } else
608 write_unlock(&GlobalSMBSeslock);
609 } else
610 write_unlock(&GlobalSMBSeslock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000611
612 /* Delete any outstanding lock records.
613 We'll lose them when the file is closed anyway. */
Roland Dreier796e5662007-05-03 04:33:45 +0000614 mutex_lock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000615 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
616 list_del(&li->llist);
617 kfree(li);
618 }
Roland Dreier796e5662007-05-03 04:33:45 +0000619 mutex_unlock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000620
Steve Frenchcbe04762005-04-28 22:41:05 -0700621 write_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 list_del(&pSMBFile->flist);
623 list_del(&pSMBFile->tlist);
Steve Frenchcbe04762005-04-28 22:41:05 -0700624 write_unlock(&GlobalSMBSeslock);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -0400625 cifsFileInfo_put(file->private_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 file->private_data = NULL;
627 } else
628 rc = -EBADF;
629
Steve French4efa53f2007-09-11 05:50:53 +0000630 read_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 if (list_empty(&(CIFS_I(inode)->openFileList))) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000632 cFYI(1, "closing last open instance for inode %p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 /* if the file is not open we do not know if we can cache info
634 on this inode, much less write behind and read ahead */
Steve French4b18f2a2008-04-29 00:06:05 +0000635 CIFS_I(inode)->clientCanCacheRead = false;
636 CIFS_I(inode)->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 }
Steve French4efa53f2007-09-11 05:50:53 +0000638 read_unlock(&GlobalSMBSeslock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000639 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 rc = CIFS_I(inode)->write_behind_rc;
641 FreeXid(xid);
642 return rc;
643}
644
645int cifs_closedir(struct inode *inode, struct file *file)
646{
647 int rc = 0;
648 int xid;
Joe Perchesc21dfb62010-07-12 13:50:14 -0700649 struct cifsFileInfo *pCFileStruct = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 char *ptmp;
651
Joe Perchesb6b38f72010-04-21 03:50:45 +0000652 cFYI(1, "Closedir inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
654 xid = GetXid();
655
656 if (pCFileStruct) {
Jeff Layton13cfb732010-09-29 19:51:11 -0400657 struct cifsTconInfo *pTcon = tlink_tcon(pCFileStruct->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700658
Joe Perchesb6b38f72010-04-21 03:50:45 +0000659 cFYI(1, "Freeing private data in close dir");
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000660 write_lock(&GlobalSMBSeslock);
Steve French4b18f2a2008-04-29 00:06:05 +0000661 if (!pCFileStruct->srch_inf.endOfSearch &&
662 !pCFileStruct->invalidHandle) {
663 pCFileStruct->invalidHandle = true;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000664 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000666 cFYI(1, "Closing uncompleted readdir with rc %d",
667 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 /* not much we can do if it fails anyway, ignore rc */
669 rc = 0;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000670 } else
671 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
673 if (ptmp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000674 cFYI(1, "closedir free smb buf in srch struct");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000676 if (pCFileStruct->srch_inf.smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000677 cifs_small_buf_release(ptmp);
678 else
679 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 }
Jeff Layton13cfb732010-09-29 19:51:11 -0400681 cifs_put_tlink(pCFileStruct->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 kfree(file->private_data);
683 file->private_data = NULL;
684 }
685 /* BB can we lock the filestruct while this is going on? */
686 FreeXid(xid);
687 return rc;
688}
689
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000690static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
691 __u64 offset, __u8 lockType)
692{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000693 struct cifsLockInfo *li =
694 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000695 if (li == NULL)
696 return -ENOMEM;
697 li->offset = offset;
698 li->length = len;
699 li->type = lockType;
Roland Dreier796e5662007-05-03 04:33:45 +0000700 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000701 list_add(&li->llist, &fid->llist);
Roland Dreier796e5662007-05-03 04:33:45 +0000702 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000703 return 0;
704}
705
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
707{
708 int rc, xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 __u32 numLock = 0;
710 __u32 numUnlock = 0;
711 __u64 length;
Steve French4b18f2a2008-04-29 00:06:05 +0000712 bool wait_flag = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 struct cifs_sb_info *cifs_sb;
Steve French13a6e422008-12-02 17:24:33 +0000714 struct cifsTconInfo *tcon;
Steve French08547b02006-02-28 22:39:25 +0000715 __u16 netfid;
716 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
Steve French13a6e422008-12-02 17:24:33 +0000717 bool posix_locking = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718
719 length = 1 + pfLock->fl_end - pfLock->fl_start;
720 rc = -EACCES;
721 xid = GetXid();
722
Joe Perchesb6b38f72010-04-21 03:50:45 +0000723 cFYI(1, "Lock parm: 0x%x flockflags: "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 "0x%x flocktype: 0x%x start: %lld end: %lld",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000725 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000726 pfLock->fl_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
728 if (pfLock->fl_flags & FL_POSIX)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000729 cFYI(1, "Posix");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 if (pfLock->fl_flags & FL_FLOCK)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000731 cFYI(1, "Flock");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 if (pfLock->fl_flags & FL_SLEEP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000733 cFYI(1, "Blocking lock");
Steve French4b18f2a2008-04-29 00:06:05 +0000734 wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 }
736 if (pfLock->fl_flags & FL_ACCESS)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000737 cFYI(1, "Process suspended by mandatory locking - "
738 "not implemented yet");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 if (pfLock->fl_flags & FL_LEASE)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000740 cFYI(1, "Lease on file - not implemented yet");
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000741 if (pfLock->fl_flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
Joe Perchesb6b38f72010-04-21 03:50:45 +0000743 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
745 if (pfLock->fl_type == F_WRLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000746 cFYI(1, "F_WRLCK ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 numLock = 1;
748 } else if (pfLock->fl_type == F_UNLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000749 cFYI(1, "F_UNLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750 numUnlock = 1;
Steve Frenchd47d7c12006-02-28 03:45:48 +0000751 /* Check if unlock includes more than
752 one lock range */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 } else if (pfLock->fl_type == F_RDLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000754 cFYI(1, "F_RDLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 lockType |= LOCKING_ANDX_SHARED_LOCK;
756 numLock = 1;
757 } else if (pfLock->fl_type == F_EXLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000758 cFYI(1, "F_EXLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 numLock = 1;
760 } else if (pfLock->fl_type == F_SHLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000761 cFYI(1, "F_SHLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 lockType |= LOCKING_ANDX_SHARED_LOCK;
763 numLock = 1;
764 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +0000765 cFYI(1, "Unknown type of lock");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800767 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Jeff Layton13cfb732010-09-29 19:51:11 -0400768 tcon = tlink_tcon(((struct cifsFileInfo *)file->private_data)->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769
770 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530771 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530773 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700774 }
Steve French08547b02006-02-28 22:39:25 +0000775 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776
Steve French13a6e422008-12-02 17:24:33 +0000777 if ((tcon->ses->capabilities & CAP_UNIX) &&
778 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
Steve Frenchacc18aa2008-12-02 18:53:55 +0000779 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
Steve French13a6e422008-12-02 17:24:33 +0000780 posix_locking = 1;
Steve French08547b02006-02-28 22:39:25 +0000781 /* BB add code here to normalize offset and length to
782 account for negative length which we can not accept over the
783 wire */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784 if (IS_GETLK(cmd)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000785 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000786 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000787 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000788 posix_lock_type = CIFS_RDLCK;
789 else
790 posix_lock_type = CIFS_WRLCK;
Steve French13a6e422008-12-02 17:24:33 +0000791 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000792 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000793 posix_lock_type, wait_flag);
794 FreeXid(xid);
795 return rc;
796 }
797
798 /* BB we could chain these into one lock request BB */
Steve French13a6e422008-12-02 17:24:33 +0000799 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
Steve French08547b02006-02-28 22:39:25 +0000800 0, 1, lockType, 0 /* wait flag */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 if (rc == 0) {
Steve French13a6e422008-12-02 17:24:33 +0000802 rc = CIFSSMBLock(xid, tcon, netfid, length,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 pfLock->fl_start, 1 /* numUnlock */ ,
804 0 /* numLock */ , lockType,
805 0 /* wait flag */ );
806 pfLock->fl_type = F_UNLCK;
807 if (rc != 0)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000808 cERROR(1, "Error unlocking previously locked "
809 "range %d during test of lock", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 rc = 0;
811
812 } else {
813 /* if rc == ERR_SHARING_VIOLATION ? */
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400814 rc = 0;
815
816 if (lockType & LOCKING_ANDX_SHARED_LOCK) {
817 pfLock->fl_type = F_WRLCK;
818 } else {
819 rc = CIFSSMBLock(xid, tcon, netfid, length,
820 pfLock->fl_start, 0, 1,
821 lockType | LOCKING_ANDX_SHARED_LOCK,
822 0 /* wait flag */);
823 if (rc == 0) {
824 rc = CIFSSMBLock(xid, tcon, netfid,
825 length, pfLock->fl_start, 1, 0,
826 lockType |
827 LOCKING_ANDX_SHARED_LOCK,
828 0 /* wait flag */);
829 pfLock->fl_type = F_RDLCK;
830 if (rc != 0)
Steve Frenchf19159d2010-04-21 04:12:10 +0000831 cERROR(1, "Error unlocking "
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400832 "previously locked range %d "
Steve Frenchf19159d2010-04-21 04:12:10 +0000833 "during test of lock", rc);
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400834 rc = 0;
835 } else {
836 pfLock->fl_type = F_WRLCK;
837 rc = 0;
838 }
839 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 }
841
842 FreeXid(xid);
843 return rc;
844 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000845
846 if (!numLock && !numUnlock) {
847 /* if no lock or unlock then nothing
848 to do since we do not know what it is */
849 FreeXid(xid);
850 return -EOPNOTSUPP;
851 }
852
853 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000854 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000855 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000856 posix_lock_type = CIFS_RDLCK;
857 else
858 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +0000859
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000860 if (numUnlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +0000861 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000862
Steve French13a6e422008-12-02 17:24:33 +0000863 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000864 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000865 posix_lock_type, wait_flag);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000866 } else {
Joe Perchesc21dfb62010-07-12 13:50:14 -0700867 struct cifsFileInfo *fid = file->private_data;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000868
869 if (numLock) {
Steve French13a6e422008-12-02 17:24:33 +0000870 rc = CIFSSMBLock(xid, tcon, netfid, length,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000871 pfLock->fl_start,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000872 0, numLock, lockType, wait_flag);
873
874 if (rc == 0) {
875 /* For Windows locks we must store them. */
876 rc = store_file_lock(fid, length,
877 pfLock->fl_start, lockType);
878 }
879 } else if (numUnlock) {
880 /* For each stored lock that this unlock overlaps
881 completely, unlock it. */
882 int stored_rc = 0;
883 struct cifsLockInfo *li, *tmp;
884
Steve French6b70c952006-09-21 07:35:29 +0000885 rc = 0;
Roland Dreier796e5662007-05-03 04:33:45 +0000886 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000887 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
888 if (pfLock->fl_start <= li->offset &&
Steve Frenchc19eb712007-08-24 03:22:48 +0000889 (pfLock->fl_start + length) >=
Jeff Layton39db8102007-08-24 03:16:51 +0000890 (li->offset + li->length)) {
Steve French13a6e422008-12-02 17:24:33 +0000891 stored_rc = CIFSSMBLock(xid, tcon,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000892 netfid,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000893 li->length, li->offset,
Steve French4b18f2a2008-04-29 00:06:05 +0000894 1, 0, li->type, false);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000895 if (stored_rc)
896 rc = stored_rc;
Pavel Shilovsky2c964d12010-04-21 19:44:24 +0000897 else {
898 list_del(&li->llist);
899 kfree(li);
900 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000901 }
902 }
Roland Dreier796e5662007-05-03 04:33:45 +0000903 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000904 }
905 }
906
Steve Frenchd634cc12005-08-26 14:42:59 -0500907 if (pfLock->fl_flags & FL_POSIX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 posix_lock_file_wait(file, pfLock);
909 FreeXid(xid);
910 return rc;
911}
912
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400913/*
914 * Set the timeout on write requests past EOF. For some servers (Windows)
915 * these calls can be very long.
916 *
917 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
918 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
919 * The 10M cutoff is totally arbitrary. A better scheme for this would be
920 * welcome if someone wants to suggest one.
921 *
922 * We may be able to do a better job with this if there were some way to
923 * declare that a file should be sparse.
924 */
925static int
926cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
927{
928 if (offset <= cifsi->server_eof)
929 return CIFS_STD_OP;
930 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
931 return CIFS_VLONG_OP;
932 else
933 return CIFS_LONG_OP;
934}
935
936/* update the file size (if needed) after a write */
937static void
938cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
939 unsigned int bytes_written)
940{
941 loff_t end_of_write = offset + bytes_written;
942
943 if (end_of_write > cifsi->server_eof)
944 cifsi->server_eof = end_of_write;
945}
946
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947ssize_t cifs_user_write(struct file *file, const char __user *write_data,
948 size_t write_size, loff_t *poffset)
949{
950 int rc = 0;
951 unsigned int bytes_written = 0;
952 unsigned int total_written;
953 struct cifs_sb_info *cifs_sb;
954 struct cifsTconInfo *pTcon;
955 int xid, long_op;
956 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400957 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800959 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960
Joe Perchesb6b38f72010-04-21 03:50:45 +0000961 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
962 *poffset, file->f_path.dentry->d_name.name); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963
964 if (file->private_data == NULL)
965 return -EBADF;
Jeff Laytonba00ba62010-09-20 16:01:31 -0700966
Joe Perchesc21dfb62010-07-12 13:50:14 -0700967 open_file = file->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -0400968 pTcon = tlink_tcon(open_file->tlink);
Steve French50c2f752007-07-13 00:33:32 +0000969
Jeff Layton838726c2008-08-28 07:54:59 -0400970 rc = generic_write_checks(file, poffset, &write_size, 0);
971 if (rc)
972 return rc;
973
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400976 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 for (total_written = 0; write_size > total_written;
978 total_written += bytes_written) {
979 rc = -EAGAIN;
980 while (rc == -EAGAIN) {
981 if (file->private_data == NULL) {
982 /* file has been closed on us */
983 FreeXid(xid);
984 /* if we have gotten here we have written some data
985 and blocked, and the file has been freed on us while
986 we blocked so return what we managed to write */
987 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000988 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 if (open_file->closePend) {
990 FreeXid(xid);
991 if (total_written)
992 return total_written;
993 else
994 return -EBADF;
995 }
996 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 /* we could deadlock if we called
998 filemap_fdatawait from here so tell
999 reopen_file not to flush data to server
1000 now */
Steve French4b18f2a2008-04-29 00:06:05 +00001001 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 if (rc != 0)
1003 break;
1004 }
1005
1006 rc = CIFSSMBWrite(xid, pTcon,
1007 open_file->netfid,
1008 min_t(const int, cifs_sb->wsize,
1009 write_size - total_written),
1010 *poffset, &bytes_written,
1011 NULL, write_data + total_written, long_op);
1012 }
1013 if (rc || (bytes_written == 0)) {
1014 if (total_written)
1015 break;
1016 else {
1017 FreeXid(xid);
1018 return rc;
1019 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001020 } else {
1021 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001023 }
Steve French133672e2007-11-13 22:41:37 +00001024 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 15 seconds is plenty */
1026 }
1027
Steve Frencha4544342005-08-24 13:59:35 -07001028 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029
1030 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001031 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1032 struct inode *inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001033/* Do not update local mtime - server will set its actual value on write
1034 * inode->i_ctime = inode->i_mtime =
Steve French3677db12007-02-26 16:46:11 +00001035 * current_fs_time(inode->i_sb);*/
1036 if (total_written > 0) {
1037 spin_lock(&inode->i_lock);
1038 if (*poffset > file->f_path.dentry->d_inode->i_size)
1039 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 *poffset);
Steve French3677db12007-02-26 16:46:11 +00001041 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001043 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 }
1045 FreeXid(xid);
1046 return total_written;
1047}
1048
1049static ssize_t cifs_write(struct file *file, const char *write_data,
Nick Piggind9414772008-09-24 11:32:59 -04001050 size_t write_size, loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051{
1052 int rc = 0;
1053 unsigned int bytes_written = 0;
1054 unsigned int total_written;
1055 struct cifs_sb_info *cifs_sb;
1056 struct cifsTconInfo *pTcon;
1057 int xid, long_op;
1058 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001059 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001061 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062
Joe Perchesb6b38f72010-04-21 03:50:45 +00001063 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1064 *poffset, file->f_path.dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
1066 if (file->private_data == NULL)
1067 return -EBADF;
Joe Perchesc21dfb62010-07-12 13:50:14 -07001068 open_file = file->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -04001069 pTcon = tlink_tcon(open_file->tlink);
Steve French50c2f752007-07-13 00:33:32 +00001070
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001073 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 for (total_written = 0; write_size > total_written;
1075 total_written += bytes_written) {
1076 rc = -EAGAIN;
1077 while (rc == -EAGAIN) {
1078 if (file->private_data == NULL) {
1079 /* file has been closed on us */
1080 FreeXid(xid);
1081 /* if we have gotten here we have written some data
1082 and blocked, and the file has been freed on us
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001083 while we blocked so return what we managed to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 write */
1085 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001086 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 if (open_file->closePend) {
1088 FreeXid(xid);
1089 if (total_written)
1090 return total_written;
1091 else
1092 return -EBADF;
1093 }
1094 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 /* we could deadlock if we called
1096 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001097 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 server now */
Steve French4b18f2a2008-04-29 00:06:05 +00001099 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 if (rc != 0)
1101 break;
1102 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001103 if (experimEnabled || (pTcon->ses->server &&
1104 ((pTcon->ses->server->secMode &
Steve French08775832006-05-30 18:08:26 +00001105 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +00001106 == 0))) {
Steve French3e844692005-10-03 13:37:24 -07001107 struct kvec iov[2];
1108 unsigned int len;
1109
Steve French0ae0efa2005-10-10 10:57:19 -07001110 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -07001111 write_size - total_written);
1112 /* iov[0] is reserved for smb header */
1113 iov[1].iov_base = (char *)write_data +
1114 total_written;
1115 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001116 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -07001117 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001118 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -07001119 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001120 } else
Steve French60808232006-04-22 15:53:05 +00001121 rc = CIFSSMBWrite(xid, pTcon,
1122 open_file->netfid,
1123 min_t(const int, cifs_sb->wsize,
1124 write_size - total_written),
1125 *poffset, &bytes_written,
1126 write_data + total_written,
1127 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 }
1129 if (rc || (bytes_written == 0)) {
1130 if (total_written)
1131 break;
1132 else {
1133 FreeXid(xid);
1134 return rc;
1135 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001136 } else {
1137 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001139 }
Steve French133672e2007-11-13 22:41:37 +00001140 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 15 seconds is plenty */
1142 }
1143
Steve Frencha4544342005-08-24 13:59:35 -07001144 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145
1146 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001147 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
Steve French004c46b2007-02-17 04:34:13 +00001148/*BB We could make this contingent on superblock ATIME flag too */
Steve French3677db12007-02-26 16:46:11 +00001149/* file->f_path.dentry->d_inode->i_ctime =
1150 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1151 if (total_written > 0) {
1152 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1153 if (*poffset > file->f_path.dentry->d_inode->i_size)
1154 i_size_write(file->f_path.dentry->d_inode,
1155 *poffset);
1156 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 }
Steve French3677db12007-02-26 16:46:11 +00001158 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 }
1160 FreeXid(xid);
1161 return total_written;
1162}
1163
Steve French630f3f0c2007-10-25 21:17:17 +00001164#ifdef CONFIG_CIFS_EXPERIMENTAL
Jeff Layton6508d902010-09-29 19:51:11 -04001165struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1166 bool fsuid_only)
Steve French630f3f0c2007-10-25 21:17:17 +00001167{
1168 struct cifsFileInfo *open_file = NULL;
Jeff Layton6508d902010-09-29 19:51:11 -04001169 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1170
1171 /* only filter by fsuid on multiuser mounts */
1172 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1173 fsuid_only = false;
Steve French630f3f0c2007-10-25 21:17:17 +00001174
1175 read_lock(&GlobalSMBSeslock);
1176 /* we could simply get the first_list_entry since write-only entries
1177 are always at the end of the list but since the first entry might
1178 have a close pending, we go through the whole list */
1179 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1180 if (open_file->closePend)
1181 continue;
Jeff Layton6508d902010-09-29 19:51:11 -04001182 if (fsuid_only && open_file->uid != current_fsuid())
1183 continue;
Steve French630f3f0c2007-10-25 21:17:17 +00001184 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1185 (open_file->pfile->f_flags & O_RDONLY))) {
1186 if (!open_file->invalidHandle) {
1187 /* found a good file */
1188 /* lock it so it will not be closed on us */
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001189 cifsFileInfo_get(open_file);
Steve French630f3f0c2007-10-25 21:17:17 +00001190 read_unlock(&GlobalSMBSeslock);
1191 return open_file;
1192 } /* else might as well continue, and look for
1193 another, or simply have the caller reopen it
1194 again rather than trying to fix this handle */
1195 } else /* write only file */
1196 break; /* write only files are last so must be done */
1197 }
1198 read_unlock(&GlobalSMBSeslock);
1199 return NULL;
1200}
1201#endif
1202
Jeff Layton6508d902010-09-29 19:51:11 -04001203struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1204 bool fsuid_only)
Steve French6148a742005-10-05 12:23:19 -07001205{
1206 struct cifsFileInfo *open_file;
Jeff Layton6508d902010-09-29 19:51:11 -04001207 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
Jeff Layton2846d382008-09-22 21:33:33 -04001208 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001209 int rc;
Steve French6148a742005-10-05 12:23:19 -07001210
Steve French60808232006-04-22 15:53:05 +00001211 /* Having a null inode here (because mapping->host was set to zero by
1212 the VFS or MM) should not happen but we had reports of on oops (due to
1213 it being zero) during stress testcases so we need to check for it */
1214
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001215 if (cifs_inode == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001216 cERROR(1, "Null inode passed to cifs_writeable_file");
Steve French60808232006-04-22 15:53:05 +00001217 dump_stack();
1218 return NULL;
1219 }
1220
Jeff Layton6508d902010-09-29 19:51:11 -04001221 /* only filter by fsuid on multiuser mounts */
1222 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1223 fsuid_only = false;
1224
Steve French6148a742005-10-05 12:23:19 -07001225 read_lock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001226refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001227 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton6508d902010-09-29 19:51:11 -04001228 if (open_file->closePend)
Steve French6148a742005-10-05 12:23:19 -07001229 continue;
Jeff Layton6508d902010-09-29 19:51:11 -04001230 if (!any_available && open_file->pid != current->tgid)
1231 continue;
1232 if (fsuid_only && open_file->uid != current_fsuid())
1233 continue;
Steve French6148a742005-10-05 12:23:19 -07001234 if (open_file->pfile &&
1235 ((open_file->pfile->f_flags & O_RDWR) ||
1236 (open_file->pfile->f_flags & O_WRONLY))) {
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001237 cifsFileInfo_get(open_file);
Steve French9b22b0b2007-10-02 01:11:08 +00001238
1239 if (!open_file->invalidHandle) {
1240 /* found a good writable file */
1241 read_unlock(&GlobalSMBSeslock);
1242 return open_file;
1243 }
Steve French8840dee2007-11-16 23:05:52 +00001244
Steve French6148a742005-10-05 12:23:19 -07001245 read_unlock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001246 /* Had to unlock since following call can block */
Steve French4b18f2a2008-04-29 00:06:05 +00001247 rc = cifs_reopen_file(open_file->pfile, false);
Steve French8840dee2007-11-16 23:05:52 +00001248 if (!rc) {
Steve French9b22b0b2007-10-02 01:11:08 +00001249 if (!open_file->closePend)
1250 return open_file;
1251 else { /* start over in case this was deleted */
1252 /* since the list could be modified */
Steve French37c0eb42005-10-05 14:50:29 -07001253 read_lock(&GlobalSMBSeslock);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001254 cifsFileInfo_put(open_file);
Steve French9b22b0b2007-10-02 01:11:08 +00001255 goto refind_writable;
Steve French37c0eb42005-10-05 14:50:29 -07001256 }
1257 }
Steve French9b22b0b2007-10-02 01:11:08 +00001258
1259 /* if it fails, try another handle if possible -
1260 (we can not do this if closePending since
1261 loop could be modified - in which case we
1262 have to start at the beginning of the list
1263 again. Note that it would be bad
1264 to hold up writepages here (rather than
1265 in caller) with continuous retries */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001266 cFYI(1, "wp failed on reopen file");
Steve French9b22b0b2007-10-02 01:11:08 +00001267 read_lock(&GlobalSMBSeslock);
1268 /* can not use this handle, no write
1269 pending on this one after all */
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001270 cifsFileInfo_put(open_file);
Steve French8840dee2007-11-16 23:05:52 +00001271
Steve French9b22b0b2007-10-02 01:11:08 +00001272 if (open_file->closePend) /* list could have changed */
1273 goto refind_writable;
1274 /* else we simply continue to the next entry. Thus
1275 we do not loop on reopen errors. If we
1276 can not reopen the file, for example if we
1277 reconnected to a server with another client
1278 racing to delete or lock the file we would not
1279 make progress if we restarted before the beginning
1280 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001281 }
1282 }
Jeff Layton2846d382008-09-22 21:33:33 -04001283 /* couldn't find useable FH with same pid, try any available */
1284 if (!any_available) {
1285 any_available = true;
1286 goto refind_writable;
1287 }
Steve French6148a742005-10-05 12:23:19 -07001288 read_unlock(&GlobalSMBSeslock);
1289 return NULL;
1290}
1291
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1293{
1294 struct address_space *mapping = page->mapping;
1295 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1296 char *write_data;
1297 int rc = -EFAULT;
1298 int bytes_written = 0;
1299 struct cifs_sb_info *cifs_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001301 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
1303 if (!mapping || !mapping->host)
1304 return -EFAULT;
1305
1306 inode = page->mapping->host;
1307 cifs_sb = CIFS_SB(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308
1309 offset += (loff_t)from;
1310 write_data = kmap(page);
1311 write_data += from;
1312
1313 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1314 kunmap(page);
1315 return -EIO;
1316 }
1317
1318 /* racing with truncate? */
1319 if (offset > mapping->host->i_size) {
1320 kunmap(page);
1321 return 0; /* don't care */
1322 }
1323
1324 /* check to make sure that we are not extending the file */
1325 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001326 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327
Jeff Layton6508d902010-09-29 19:51:11 -04001328 open_file = find_writable_file(CIFS_I(mapping->host), false);
Steve French6148a742005-10-05 12:23:19 -07001329 if (open_file) {
1330 bytes_written = cifs_write(open_file->pfile, write_data,
1331 to-from, &offset);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001332 cifsFileInfo_put(open_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001334 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001335 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001336 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001337 else if (bytes_written < 0)
1338 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001339 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001340 cFYI(1, "No writeable filehandles for inode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 rc = -EIO;
1342 }
1343
1344 kunmap(page);
1345 return rc;
1346}
1347
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001349 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350{
Steve French37c0eb42005-10-05 14:50:29 -07001351 struct backing_dev_info *bdi = mapping->backing_dev_info;
1352 unsigned int bytes_to_write;
1353 unsigned int bytes_written;
1354 struct cifs_sb_info *cifs_sb;
1355 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001356 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001357 pgoff_t index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001358 int range_whole = 0;
1359 struct kvec *iov;
Steve French84d2f072005-10-12 15:32:05 -07001360 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001361 int n_iov = 0;
1362 pgoff_t next;
1363 int nr_pages;
1364 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001365 struct cifsFileInfo *open_file;
Jeff Laytonba00ba62010-09-20 16:01:31 -07001366 struct cifsTconInfo *tcon;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001367 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
Steve French37c0eb42005-10-05 14:50:29 -07001368 struct page *page;
1369 struct pagevec pvec;
1370 int rc = 0;
1371 int scanned = 0;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001372 int xid, long_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001373
Jeff Laytonf3983c22010-09-22 16:17:40 -07001374 /*
1375 * BB: Is this meaningful for a non-block-device file system?
1376 * If it is, we should test it again after we do I/O
1377 */
1378 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1379 wbc->encountered_congestion = 1;
1380 return 0;
1381 }
1382
Steve French37c0eb42005-10-05 14:50:29 -07001383 cifs_sb = CIFS_SB(mapping->host->i_sb);
Steve French50c2f752007-07-13 00:33:32 +00001384
Steve French37c0eb42005-10-05 14:50:29 -07001385 /*
1386 * If wsize is smaller that the page cache size, default to writing
1387 * one page at a time via cifs_writepage
1388 */
1389 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1390 return generic_writepages(mapping, wbc);
1391
Steve French9a0c8232007-02-02 04:21:57 +00001392 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001393 if (iov == NULL)
Steve French9a0c8232007-02-02 04:21:57 +00001394 return generic_writepages(mapping, wbc);
1395
Steve French37c0eb42005-10-05 14:50:29 -07001396 /*
Jeff Laytonf3983c22010-09-22 16:17:40 -07001397 * if there's no open file, then this is likely to fail too,
1398 * but it'll at least handle the return. Maybe it should be
1399 * a BUG() instead?
Steve French37c0eb42005-10-05 14:50:29 -07001400 */
Jeff Layton6508d902010-09-29 19:51:11 -04001401 open_file = find_writable_file(CIFS_I(mapping->host), false);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001402 if (!open_file) {
Steve French9a0c8232007-02-02 04:21:57 +00001403 kfree(iov);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001404 return generic_writepages(mapping, wbc);
Steve French37c0eb42005-10-05 14:50:29 -07001405 }
1406
Jeff Layton13cfb732010-09-29 19:51:11 -04001407 tcon = tlink_tcon(open_file->tlink);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001408 if (!experimEnabled && tcon->ses->server->secMode &
1409 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1410 cifsFileInfo_put(open_file);
1411 return generic_writepages(mapping, wbc);
1412 }
1413 cifsFileInfo_put(open_file);
1414
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 xid = GetXid();
1416
Steve French37c0eb42005-10-05 14:50:29 -07001417 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001418 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001419 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001420 end = -1;
1421 } else {
1422 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1423 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1424 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1425 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001426 scanned = 1;
1427 }
1428retry:
1429 while (!done && (index <= end) &&
1430 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1431 PAGECACHE_TAG_DIRTY,
1432 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1433 int first;
1434 unsigned int i;
1435
Steve French37c0eb42005-10-05 14:50:29 -07001436 first = -1;
1437 next = 0;
1438 n_iov = 0;
1439 bytes_to_write = 0;
1440
1441 for (i = 0; i < nr_pages; i++) {
1442 page = pvec.pages[i];
1443 /*
1444 * At this point we hold neither mapping->tree_lock nor
1445 * lock on the page itself: the page may be truncated or
1446 * invalidated (changing page->mapping to NULL), or even
1447 * swizzled back from swapper_space to tmpfs file
1448 * mapping
1449 */
1450
1451 if (first < 0)
1452 lock_page(page);
Nick Piggin529ae9a2008-08-02 12:01:03 +02001453 else if (!trylock_page(page))
Steve French37c0eb42005-10-05 14:50:29 -07001454 break;
1455
1456 if (unlikely(page->mapping != mapping)) {
1457 unlock_page(page);
1458 break;
1459 }
1460
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001461 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001462 done = 1;
1463 unlock_page(page);
1464 break;
1465 }
1466
1467 if (next && (page->index != next)) {
1468 /* Not next consecutive page */
1469 unlock_page(page);
1470 break;
1471 }
1472
1473 if (wbc->sync_mode != WB_SYNC_NONE)
1474 wait_on_page_writeback(page);
1475
1476 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001477 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001478 unlock_page(page);
1479 break;
1480 }
Steve French84d2f072005-10-12 15:32:05 -07001481
Linus Torvaldscb876f42006-12-23 16:19:07 -08001482 /*
1483 * This actually clears the dirty bit in the radix tree.
1484 * See cifs_writepage() for more commentary.
1485 */
1486 set_page_writeback(page);
1487
Steve French84d2f072005-10-12 15:32:05 -07001488 if (page_offset(page) >= mapping->host->i_size) {
1489 done = 1;
1490 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001491 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001492 break;
1493 }
1494
Steve French37c0eb42005-10-05 14:50:29 -07001495 /*
1496 * BB can we get rid of this? pages are held by pvec
1497 */
1498 page_cache_get(page);
1499
Steve French84d2f072005-10-12 15:32:05 -07001500 len = min(mapping->host->i_size - page_offset(page),
1501 (loff_t)PAGE_CACHE_SIZE);
1502
Steve French37c0eb42005-10-05 14:50:29 -07001503 /* reserve iov[0] for the smb header */
1504 n_iov++;
1505 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001506 iov[n_iov].iov_len = len;
1507 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001508
1509 if (first < 0) {
1510 first = i;
1511 offset = page_offset(page);
1512 }
1513 next = page->index + 1;
1514 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1515 break;
1516 }
1517 if (n_iov) {
Jeff Layton6508d902010-09-29 19:51:11 -04001518 open_file = find_writable_file(CIFS_I(mapping->host),
1519 false);
Steve French23e7dd72005-10-20 13:44:56 -07001520 if (!open_file) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001521 cERROR(1, "No writable handles for inode");
Steve French23e7dd72005-10-20 13:44:56 -07001522 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001523 } else {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001524 long_op = cifs_write_timeout(cifsi, offset);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001525 rc = CIFSSMBWrite2(xid, tcon, open_file->netfid,
Steve French23e7dd72005-10-20 13:44:56 -07001526 bytes_to_write, offset,
1527 &bytes_written, iov, n_iov,
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001528 long_op);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001529 cifsFileInfo_put(open_file);
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001530 cifs_update_eof(cifsi, offset, bytes_written);
Steve French37c0eb42005-10-05 14:50:29 -07001531 }
Jeff Laytonf3983c22010-09-22 16:17:40 -07001532
1533 if (rc || bytes_written < bytes_to_write) {
1534 cERROR(1, "Write2 ret %d, wrote %d",
1535 rc, bytes_written);
1536 /* BB what if continued retry is
1537 requested via mount flags? */
1538 if (rc == -ENOSPC)
1539 set_bit(AS_ENOSPC, &mapping->flags);
1540 else
1541 set_bit(AS_EIO, &mapping->flags);
1542 } else {
1543 cifs_stats_bytes_written(tcon, bytes_written);
1544 }
1545
Steve French37c0eb42005-10-05 14:50:29 -07001546 for (i = 0; i < n_iov; i++) {
1547 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001548 /* Should we also set page error on
1549 success rc but too little data written? */
1550 /* BB investigate retry logic on temporary
1551 server crash cases and how recovery works
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001552 when page marked as error */
1553 if (rc)
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001554 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001555 kunmap(page);
1556 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001557 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001558 page_cache_release(page);
1559 }
1560 if ((wbc->nr_to_write -= n_iov) <= 0)
1561 done = 1;
1562 index = next;
Dave Kleikampb066a482008-11-18 03:49:05 +00001563 } else
1564 /* Need to re-find the pages we skipped */
1565 index = pvec.pages[0]->index + 1;
1566
Steve French37c0eb42005-10-05 14:50:29 -07001567 pagevec_release(&pvec);
1568 }
1569 if (!scanned && !done) {
1570 /*
1571 * We hit the last page and there is more work to be done: wrap
1572 * back to the start of the file
1573 */
1574 scanned = 1;
1575 index = 0;
1576 goto retry;
1577 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001578 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001579 mapping->writeback_index = index;
1580
Linus Torvalds1da177e2005-04-16 15:20:36 -07001581 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001582 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 return rc;
1584}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001586static int cifs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587{
1588 int rc = -EFAULT;
1589 int xid;
1590
1591 xid = GetXid();
1592/* BB add check for wbc flags */
1593 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001594 if (!PageUptodate(page))
Joe Perchesb6b38f72010-04-21 03:50:45 +00001595 cFYI(1, "ppw - page not up to date");
Linus Torvaldscb876f42006-12-23 16:19:07 -08001596
1597 /*
1598 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1599 *
1600 * A writepage() implementation always needs to do either this,
1601 * or re-dirty the page with "redirty_page_for_writepage()" in
1602 * the case of a failure.
1603 *
1604 * Just unlocking the page will cause the radix tree tag-bits
1605 * to fail to update with the state of the page correctly.
1606 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001607 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1609 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1610 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001611 end_page_writeback(page);
1612 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 FreeXid(xid);
1614 return rc;
1615}
1616
Nick Piggind9414772008-09-24 11:32:59 -04001617static int cifs_write_end(struct file *file, struct address_space *mapping,
1618 loff_t pos, unsigned len, unsigned copied,
1619 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620{
Nick Piggind9414772008-09-24 11:32:59 -04001621 int rc;
1622 struct inode *inode = mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623
Joe Perchesb6b38f72010-04-21 03:50:45 +00001624 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1625 page, pos, copied);
Steve Frenchad7a2922008-02-07 23:25:02 +00001626
Jeff Laytona98ee8c2008-11-26 19:32:33 +00001627 if (PageChecked(page)) {
1628 if (copied == len)
1629 SetPageUptodate(page);
1630 ClearPageChecked(page);
1631 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04001632 SetPageUptodate(page);
1633
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04001635 char *page_data;
1636 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1637 int xid;
1638
1639 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 /* this is probably better than directly calling
1641 partialpage_write since in this function the file handle is
1642 known which we might as well leverage */
1643 /* BB check if anything else missing out of ppw
1644 such as updating last write time */
1645 page_data = kmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001646 rc = cifs_write(file, page_data + offset, copied, &pos);
1647 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001649
1650 FreeXid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001651 } else {
Nick Piggind9414772008-09-24 11:32:59 -04001652 rc = copied;
1653 pos += copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654 set_page_dirty(page);
1655 }
1656
Nick Piggind9414772008-09-24 11:32:59 -04001657 if (rc > 0) {
1658 spin_lock(&inode->i_lock);
1659 if (pos > inode->i_size)
1660 i_size_write(inode, pos);
1661 spin_unlock(&inode->i_lock);
1662 }
1663
1664 unlock_page(page);
1665 page_cache_release(page);
1666
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 return rc;
1668}
1669
Christoph Hellwig7ea80852010-05-26 17:53:25 +02001670int cifs_fsync(struct file *file, int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671{
1672 int xid;
1673 int rc = 0;
Steve Frenchb298f222009-02-21 21:17:43 +00001674 struct cifsTconInfo *tcon;
Joe Perchesc21dfb62010-07-12 13:50:14 -07001675 struct cifsFileInfo *smbfile = file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001676 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677
1678 xid = GetXid();
1679
Joe Perchesb6b38f72010-04-21 03:50:45 +00001680 cFYI(1, "Sync file - name: %s datasync: 0x%x",
Christoph Hellwig7ea80852010-05-26 17:53:25 +02001681 file->f_path.dentry->d_name.name, datasync);
Steve French50c2f752007-07-13 00:33:32 +00001682
Jeff Laytoncea21802007-11-20 23:19:03 +00001683 rc = filemap_write_and_wait(inode->i_mapping);
1684 if (rc == 0) {
1685 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 CIFS_I(inode)->write_behind_rc = 0;
Jeff Layton13cfb732010-09-29 19:51:11 -04001687 tcon = tlink_tcon(smbfile->tlink);
Steve Frenchbe652442009-02-23 15:21:59 +00001688 if (!rc && tcon && smbfile &&
Steve French4717bed2009-02-24 14:44:19 +00001689 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
Steve Frenchb298f222009-02-21 21:17:43 +00001690 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
Jeff Laytoncea21802007-11-20 23:19:03 +00001691 }
Steve Frenchb298f222009-02-21 21:17:43 +00001692
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 FreeXid(xid);
1694 return rc;
1695}
1696
NeilBrown3978d7172006-03-26 01:37:17 -08001697/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698{
1699 struct address_space *mapping;
1700 struct inode *inode;
1701 unsigned long index = page->index;
1702 unsigned int rpages = 0;
1703 int rc = 0;
1704
Steve Frenchf19159d2010-04-21 04:12:10 +00001705 cFYI(1, "sync page %p", page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 mapping = page->mapping;
1707 if (!mapping)
1708 return 0;
1709 inode = mapping->host;
1710 if (!inode)
NeilBrown3978d7172006-03-26 01:37:17 -08001711 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001713/* fill in rpages then
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1715
Joe Perchesb6b38f72010-04-21 03:50:45 +00001716/* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717
NeilBrown3978d7172006-03-26 01:37:17 -08001718#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 if (rc < 0)
1720 return rc;
1721 return 0;
NeilBrown3978d7172006-03-26 01:37:17 -08001722#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723} */
1724
1725/*
1726 * As file closes, flush all cached write data for this inode checking
1727 * for write behind errors.
1728 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001729int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001731 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 int rc = 0;
1733
1734 /* Rather than do the steps manually:
1735 lock the inode for writing
1736 loop through pages looking for write behind data (dirty pages)
1737 coalesce into contiguous 16K (or smaller) chunks to write to server
1738 send to server (prefer in parallel)
1739 deal with writebehind errors
1740 unlock inode for writing
1741 filemapfdatawrite appears easier for the time being */
1742
1743 rc = filemap_fdatawrite(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +00001744 /* reset wb rc if we were able to write out dirty pages */
1745 if (!rc) {
1746 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001748 }
Steve French50c2f752007-07-13 00:33:32 +00001749
Joe Perchesb6b38f72010-04-21 03:50:45 +00001750 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751
1752 return rc;
1753}
1754
1755ssize_t cifs_user_read(struct file *file, char __user *read_data,
1756 size_t read_size, loff_t *poffset)
1757{
1758 int rc = -EACCES;
1759 unsigned int bytes_read = 0;
1760 unsigned int total_read = 0;
1761 unsigned int current_read_size;
1762 struct cifs_sb_info *cifs_sb;
1763 struct cifsTconInfo *pTcon;
1764 int xid;
1765 struct cifsFileInfo *open_file;
1766 char *smb_read_data;
1767 char __user *current_offset;
1768 struct smb_com_read_rsp *pSMBr;
1769
1770 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001771 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772
1773 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301774 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301776 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07001778 open_file = file->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -04001779 pTcon = tlink_tcon(open_file->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780
Steve Frenchad7a2922008-02-07 23:25:02 +00001781 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001782 cFYI(1, "attempting read on write only file instance");
Steve Frenchad7a2922008-02-07 23:25:02 +00001783
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 for (total_read = 0, current_offset = read_data;
1785 read_size > total_read;
1786 total_read += bytes_read, current_offset += bytes_read) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001787 current_read_size = min_t(const int, read_size - total_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 cifs_sb->rsize);
1789 rc = -EAGAIN;
1790 smb_read_data = NULL;
1791 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001792 int buf_type = CIFS_NO_BUFFER;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001793 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001795 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 if (rc != 0)
1797 break;
1798 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001799 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001800 open_file->netfid,
1801 current_read_size, *poffset,
1802 &bytes_read, &smb_read_data,
1803 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001806 if (copy_to_user(current_offset,
1807 smb_read_data +
1808 4 /* RFC1001 length field */ +
1809 le16_to_cpu(pSMBr->DataOffset),
Steve Frenchad7a2922008-02-07 23:25:02 +00001810 bytes_read))
Steve French93544cc2006-02-14 22:30:52 -06001811 rc = -EFAULT;
Steve French93544cc2006-02-14 22:30:52 -06001812
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001813 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001814 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001815 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001816 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 smb_read_data = NULL;
1818 }
1819 }
1820 if (rc || (bytes_read == 0)) {
1821 if (total_read) {
1822 break;
1823 } else {
1824 FreeXid(xid);
1825 return rc;
1826 }
1827 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001828 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 *poffset += bytes_read;
1830 }
1831 }
1832 FreeXid(xid);
1833 return total_read;
1834}
1835
1836
1837static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1838 loff_t *poffset)
1839{
1840 int rc = -EACCES;
1841 unsigned int bytes_read = 0;
1842 unsigned int total_read;
1843 unsigned int current_read_size;
1844 struct cifs_sb_info *cifs_sb;
1845 struct cifsTconInfo *pTcon;
1846 int xid;
1847 char *current_offset;
1848 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001849 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850
1851 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001852 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853
1854 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301855 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301857 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001858 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07001859 open_file = file->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -04001860 pTcon = tlink_tcon(open_file->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861
1862 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001863 cFYI(1, "attempting read on write only file instance");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001865 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 read_size > total_read;
1867 total_read += bytes_read, current_offset += bytes_read) {
1868 current_read_size = min_t(const int, read_size - total_read,
1869 cifs_sb->rsize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001870 /* For windows me and 9x we do not want to request more
1871 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001872 if ((pTcon->ses) &&
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001873 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1874 current_read_size = min_t(const int, current_read_size,
1875 pTcon->ses->server->maxBuf - 128);
1876 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 rc = -EAGAIN;
1878 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001879 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001881 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 if (rc != 0)
1883 break;
1884 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001885 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001886 open_file->netfid,
1887 current_read_size, *poffset,
1888 &bytes_read, &current_offset,
1889 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 }
1891 if (rc || (bytes_read == 0)) {
1892 if (total_read) {
1893 break;
1894 } else {
1895 FreeXid(xid);
1896 return rc;
1897 }
1898 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001899 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001900 *poffset += bytes_read;
1901 }
1902 }
1903 FreeXid(xid);
1904 return total_read;
1905}
1906
1907int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1908{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 int rc, xid;
1910
1911 xid = GetXid();
Jeff Laytonabab0952010-02-12 07:44:18 -05001912 rc = cifs_revalidate_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001914 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 FreeXid(xid);
1916 return rc;
1917 }
1918 rc = generic_file_mmap(file, vma);
1919 FreeXid(xid);
1920 return rc;
1921}
1922
1923
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001924static void cifs_copy_cache_pages(struct address_space *mapping,
Nick Piggin315e9952010-04-21 03:18:28 +00001925 struct list_head *pages, int bytes_read, char *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926{
1927 struct page *page;
1928 char *target;
1929
1930 while (bytes_read > 0) {
1931 if (list_empty(pages))
1932 break;
1933
1934 page = list_entry(pages->prev, struct page, lru);
1935 list_del(&page->lru);
1936
Nick Piggin315e9952010-04-21 03:18:28 +00001937 if (add_to_page_cache_lru(page, mapping, page->index,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938 GFP_KERNEL)) {
1939 page_cache_release(page);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001940 cFYI(1, "Add page cache failed");
Steve French3079ca62005-06-09 14:44:07 -07001941 data += PAGE_CACHE_SIZE;
1942 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 continue;
1944 }
Jeff Layton06b43672010-06-01 10:54:45 -04001945 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001947 target = kmap_atomic(page, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948
1949 if (PAGE_CACHE_SIZE > bytes_read) {
1950 memcpy(target, data, bytes_read);
1951 /* zero the tail end of this partial page */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001952 memset(target + bytes_read, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 PAGE_CACHE_SIZE - bytes_read);
1954 bytes_read = 0;
1955 } else {
1956 memcpy(target, data, PAGE_CACHE_SIZE);
1957 bytes_read -= PAGE_CACHE_SIZE;
1958 }
1959 kunmap_atomic(target, KM_USER0);
1960
1961 flush_dcache_page(page);
1962 SetPageUptodate(page);
1963 unlock_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 data += PAGE_CACHE_SIZE;
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05301965
1966 /* add page to FS-Cache */
1967 cifs_readpage_to_fscache(mapping->host, page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968 }
1969 return;
1970}
1971
1972static int cifs_readpages(struct file *file, struct address_space *mapping,
1973 struct list_head *page_list, unsigned num_pages)
1974{
1975 int rc = -EACCES;
1976 int xid;
1977 loff_t offset;
1978 struct page *page;
1979 struct cifs_sb_info *cifs_sb;
1980 struct cifsTconInfo *pTcon;
Steve French2c2130e2007-10-12 19:10:28 +00001981 unsigned int bytes_read = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001982 unsigned int read_size, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 char *smb_read_data = NULL;
1984 struct smb_com_read_rsp *pSMBr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001986 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987
1988 xid = GetXid();
1989 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301990 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301992 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07001994 open_file = file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001995 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Jeff Layton13cfb732010-09-29 19:51:11 -04001996 pTcon = tlink_tcon(open_file->tlink);
Steve Frenchbfa0d752005-08-31 21:50:37 -07001997
Suresh Jayaraman56698232010-07-05 18:13:25 +05301998 /*
1999 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2000 * immediately if the cookie is negative
2001 */
2002 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2003 &num_pages);
2004 if (rc == 0)
2005 goto read_complete;
2006
Steve Frenchf19159d2010-04-21 04:12:10 +00002007 cFYI(DBG2, "rpages: num pages %d", num_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 for (i = 0; i < num_pages; ) {
2009 unsigned contig_pages;
2010 struct page *tmp_page;
2011 unsigned long expected_index;
2012
2013 if (list_empty(page_list))
2014 break;
2015
2016 page = list_entry(page_list->prev, struct page, lru);
2017 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2018
2019 /* count adjacent pages that we will read into */
2020 contig_pages = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002021 expected_index =
Linus Torvalds1da177e2005-04-16 15:20:36 -07002022 list_entry(page_list->prev, struct page, lru)->index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002023 list_for_each_entry_reverse(tmp_page, page_list, lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 if (tmp_page->index == expected_index) {
2025 contig_pages++;
2026 expected_index++;
2027 } else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002028 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 }
2030 if (contig_pages + i > num_pages)
2031 contig_pages = num_pages - i;
2032
2033 /* for reads over a certain size could initiate async
2034 read ahead */
2035
2036 read_size = contig_pages * PAGE_CACHE_SIZE;
2037 /* Read size needs to be in multiples of one page */
2038 read_size = min_t(const unsigned int, read_size,
2039 cifs_sb->rsize & PAGE_CACHE_MASK);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002040 cFYI(DBG2, "rpages: read size 0x%x contiguous pages %d",
2041 read_size, contig_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 rc = -EAGAIN;
2043 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002044 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00002046 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 if (rc != 0)
2048 break;
2049 }
2050
Steve Frenchbfa0d752005-08-31 21:50:37 -07002051 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08002052 open_file->netfid,
2053 read_size, offset,
2054 &bytes_read, &smb_read_data,
2055 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07002056 /* BB more RC checks ? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002057 if (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002059 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002060 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002061 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002062 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 smb_read_data = NULL;
2064 }
2065 }
2066 }
2067 if ((rc < 0) || (smb_read_data == NULL)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002068 cFYI(1, "Read error in readpages: %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069 break;
2070 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08002071 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2073 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2074 smb_read_data + 4 /* RFC1001 hdr */ +
Nick Piggin315e9952010-04-21 03:18:28 +00002075 le16_to_cpu(pSMBr->DataOffset));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076
2077 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha4544342005-08-24 13:59:35 -07002078 cifs_stats_bytes_read(pTcon, bytes_read);
Steve French2c2130e2007-10-12 19:10:28 +00002079 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 i++; /* account for partial page */
2081
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002082 /* server copy of file can have smaller size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 than client */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002084 /* BB do we need to verify this common case ?
2085 this case is ok - if we are at server EOF
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 we will hit it on next read */
2087
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08002088 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 }
2090 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002091 cFYI(1, "No bytes read (%d) at offset %lld . "
Steve Frenchf19159d2010-04-21 04:12:10 +00002092 "Cleaning remaining pages from readahead list",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002093 bytes_read, offset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002094 /* BB turn off caching and do new lookup on
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 break;
2097 }
2098 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002099 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002100 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002101 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002102 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 smb_read_data = NULL;
2104 }
2105 bytes_read = 0;
2106 }
2107
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108/* need to free smb_read_data buf before exit */
2109 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002110 if (buf_type == CIFS_SMALL_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002111 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002112 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002113 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002114 smb_read_data = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002115 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116
Suresh Jayaraman56698232010-07-05 18:13:25 +05302117read_complete:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 FreeXid(xid);
2119 return rc;
2120}
2121
2122static int cifs_readpage_worker(struct file *file, struct page *page,
2123 loff_t *poffset)
2124{
2125 char *read_data;
2126 int rc;
2127
Suresh Jayaraman56698232010-07-05 18:13:25 +05302128 /* Is the page cached? */
2129 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2130 if (rc == 0)
2131 goto read_complete;
2132
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133 page_cache_get(page);
2134 read_data = kmap(page);
2135 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002136
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002138
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139 if (rc < 0)
2140 goto io_error;
2141 else
Joe Perchesb6b38f72010-04-21 03:50:45 +00002142 cFYI(1, "Bytes read %d", rc);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002143
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002144 file->f_path.dentry->d_inode->i_atime =
2145 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002146
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147 if (PAGE_CACHE_SIZE > rc)
2148 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2149
2150 flush_dcache_page(page);
2151 SetPageUptodate(page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05302152
2153 /* send this page to the cache */
2154 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2155
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002157
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002159 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002160 page_cache_release(page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05302161
2162read_complete:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 return rc;
2164}
2165
2166static int cifs_readpage(struct file *file, struct page *page)
2167{
2168 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2169 int rc = -EACCES;
2170 int xid;
2171
2172 xid = GetXid();
2173
2174 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302175 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302177 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178 }
2179
Joe Perchesb6b38f72010-04-21 03:50:45 +00002180 cFYI(1, "readpage %p at offset %d 0x%x\n",
2181 page, (int)offset, (int)offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182
2183 rc = cifs_readpage_worker(file, page, &offset);
2184
2185 unlock_page(page);
2186
2187 FreeXid(xid);
2188 return rc;
2189}
2190
Steve Frencha403a0a2007-07-26 15:54:16 +00002191static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2192{
2193 struct cifsFileInfo *open_file;
2194
2195 read_lock(&GlobalSMBSeslock);
2196 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2197 if (open_file->closePend)
2198 continue;
2199 if (open_file->pfile &&
2200 ((open_file->pfile->f_flags & O_RDWR) ||
2201 (open_file->pfile->f_flags & O_WRONLY))) {
2202 read_unlock(&GlobalSMBSeslock);
2203 return 1;
2204 }
2205 }
2206 read_unlock(&GlobalSMBSeslock);
2207 return 0;
2208}
2209
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210/* We do not want to update the file size from server for inodes
2211 open for write - to avoid races with writepage extending
2212 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002213 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214 but this is tricky to do without racing with writebehind
2215 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00002216bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002217{
Steve Frencha403a0a2007-07-26 15:54:16 +00002218 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00002219 return true;
Steve French23e7dd72005-10-20 13:44:56 -07002220
Steve Frencha403a0a2007-07-26 15:54:16 +00002221 if (is_inode_writable(cifsInode)) {
2222 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08002223 struct cifs_sb_info *cifs_sb;
2224
Steve Frenchc32a0b62006-01-12 14:41:28 -08002225 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00002226 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002227 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08002228 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00002229 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08002230 }
2231
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002232 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00002233 return true;
Steve French7ba52632007-02-08 18:14:13 +00002234
Steve French4b18f2a2008-04-29 00:06:05 +00002235 return false;
Steve French23e7dd72005-10-20 13:44:56 -07002236 } else
Steve French4b18f2a2008-04-29 00:06:05 +00002237 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238}
2239
Nick Piggind9414772008-09-24 11:32:59 -04002240static int cifs_write_begin(struct file *file, struct address_space *mapping,
2241 loff_t pos, unsigned len, unsigned flags,
2242 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243{
Nick Piggind9414772008-09-24 11:32:59 -04002244 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2245 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002246 loff_t page_start = pos & PAGE_MASK;
2247 loff_t i_size;
2248 struct page *page;
2249 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250
Joe Perchesb6b38f72010-04-21 03:50:45 +00002251 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
Nick Piggind9414772008-09-24 11:32:59 -04002252
Nick Piggin54566b22009-01-04 12:00:53 -08002253 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002254 if (!page) {
2255 rc = -ENOMEM;
2256 goto out;
2257 }
Nick Piggind9414772008-09-24 11:32:59 -04002258
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002259 if (PageUptodate(page))
2260 goto out;
Steve French8a236262007-03-06 00:31:00 +00002261
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002262 /*
2263 * If we write a full page it will be up to date, no need to read from
2264 * the server. If the write is short, we'll end up doing a sync write
2265 * instead.
2266 */
2267 if (len == PAGE_CACHE_SIZE)
2268 goto out;
2269
2270 /*
2271 * optimize away the read when we have an oplock, and we're not
2272 * expecting to use any of the data we'd be reading in. That
2273 * is, when the page lies beyond the EOF, or straddles the EOF
2274 * and the write will cover all of the existing data.
2275 */
2276 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2277 i_size = i_size_read(mapping->host);
2278 if (page_start >= i_size ||
2279 (offset == 0 && (pos + len) >= i_size)) {
2280 zero_user_segments(page, 0, offset,
2281 offset + len,
2282 PAGE_CACHE_SIZE);
2283 /*
2284 * PageChecked means that the parts of the page
2285 * to which we're not writing are considered up
2286 * to date. Once the data is copied to the
2287 * page, it can be set uptodate.
2288 */
2289 SetPageChecked(page);
2290 goto out;
2291 }
2292 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002293
Nick Piggind9414772008-09-24 11:32:59 -04002294 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002295 /*
2296 * might as well read a page, it is fast enough. If we get
2297 * an error, we don't need to return it. cifs_write_end will
2298 * do a sync write instead since PG_uptodate isn't set.
2299 */
2300 cifs_readpage_worker(file, page, &page_start);
Steve French8a236262007-03-06 00:31:00 +00002301 } else {
2302 /* we could try using another file handle if there is one -
2303 but how would we lock it to prevent close of that handle
2304 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04002305 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00002306 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002307out:
2308 *pagep = page;
2309 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002310}
2311
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05302312static int cifs_release_page(struct page *page, gfp_t gfp)
2313{
2314 if (PagePrivate(page))
2315 return 0;
2316
2317 return cifs_fscache_release_page(page, gfp);
2318}
2319
2320static void cifs_invalidate_page(struct page *page, unsigned long offset)
2321{
2322 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2323
2324 if (offset == 0)
2325 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2326}
2327
Tejun Heo9b646972010-07-20 22:09:02 +02002328void cifs_oplock_break(struct work_struct *work)
Jeff Layton3bc303c2009-09-21 06:47:50 -04002329{
2330 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2331 oplock_break);
Jeff Laytona5e18bc2010-10-11 15:07:18 -04002332 struct inode *inode = cfile->dentry->d_inode;
Jeff Layton3bc303c2009-09-21 06:47:50 -04002333 struct cifsInodeInfo *cinode = CIFS_I(inode);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002334 int rc, waitrc = 0;
2335
2336 if (inode && S_ISREG(inode->i_mode)) {
Steve Frenchd54ff732010-04-27 04:38:15 +00002337 if (cinode->clientCanCacheRead)
Al Viro8737c932009-12-24 06:47:55 -05002338 break_lease(inode, O_RDONLY);
Steve Frenchd54ff732010-04-27 04:38:15 +00002339 else
Al Viro8737c932009-12-24 06:47:55 -05002340 break_lease(inode, O_WRONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002341 rc = filemap_fdatawrite(inode->i_mapping);
2342 if (cinode->clientCanCacheRead == 0) {
2343 waitrc = filemap_fdatawait(inode->i_mapping);
2344 invalidate_remote_inode(inode);
2345 }
2346 if (!rc)
2347 rc = waitrc;
2348 if (rc)
2349 cinode->write_behind_rc = rc;
Joe Perchesb6b38f72010-04-21 03:50:45 +00002350 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002351 }
2352
2353 /*
2354 * releasing stale oplock after recent reconnect of smb session using
2355 * a now incorrect file handle is not a data integrity issue but do
2356 * not bother sending an oplock release if session to server still is
2357 * disconnected since oplock already released by the server
2358 */
2359 if (!cfile->closePend && !cfile->oplock_break_cancelled) {
Jeff Layton13cfb732010-09-29 19:51:11 -04002360 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
2361 0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002362 cFYI(1, "Oplock release rc = %d", rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002363 }
Tejun Heo9b646972010-07-20 22:09:02 +02002364
2365 /*
2366 * We might have kicked in before is_valid_oplock_break()
2367 * finished grabbing reference for us. Make sure it's done by
2368 * waiting for GlobalSMSSeslock.
2369 */
2370 write_lock(&GlobalSMBSeslock);
2371 write_unlock(&GlobalSMBSeslock);
2372
2373 cifs_oplock_break_put(cfile);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002374}
2375
Tejun Heo9b646972010-07-20 22:09:02 +02002376void cifs_oplock_break_get(struct cifsFileInfo *cfile)
Jeff Layton3bc303c2009-09-21 06:47:50 -04002377{
Jeff Laytond7c86ff2010-10-11 15:07:19 -04002378 cifs_sb_active(cfile->dentry->d_sb);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002379 cifsFileInfo_get(cfile);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002380}
2381
Tejun Heo9b646972010-07-20 22:09:02 +02002382void cifs_oplock_break_put(struct cifsFileInfo *cfile)
Jeff Layton3bc303c2009-09-21 06:47:50 -04002383{
Jeff Layton3bc303c2009-09-21 06:47:50 -04002384 cifsFileInfo_put(cfile);
Jeff Laytond7c86ff2010-10-11 15:07:19 -04002385 cifs_sb_deactive(cfile->dentry->d_sb);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002386}
2387
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002388const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002389 .readpage = cifs_readpage,
2390 .readpages = cifs_readpages,
2391 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002392 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002393 .write_begin = cifs_write_begin,
2394 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05302396 .releasepage = cifs_release_page,
2397 .invalidatepage = cifs_invalidate_page,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002398 /* .sync_page = cifs_sync_page, */
2399 /* .direct_IO = */
2400};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002401
2402/*
2403 * cifs_readpages requires the server to support a buffer large enough to
2404 * contain the header plus one complete page of data. Otherwise, we need
2405 * to leave cifs_readpages out of the address space operations.
2406 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002407const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002408 .readpage = cifs_readpage,
2409 .writepage = cifs_writepage,
2410 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002411 .write_begin = cifs_write_begin,
2412 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002413 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05302414 .releasepage = cifs_release_page,
2415 .invalidatepage = cifs_invalidate_page,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002416 /* .sync_page = cifs_sync_page, */
2417 /* .direct_IO = */
2418};