1 /*
2 * fs/cifs/file.c
3 *
4 * vfs operations that deal with files
5 *
6 * Copyright (C) International Business Machines Corp., 2002,2007
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 * Jeremy Allison (jra@samba.org)
9 *
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>
25 #include <linux/backing-dev.h>
26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
28 #include <linux/pagemap.h>
29 #include <linux/pagevec.h>
30 #include <linux/writeback.h>
31 #include <linux/task_io_accounting_ops.h>
32 #include <linux/delay.h>
33 #include <asm/div64.h>
34 #include "cifsfs.h"
35 #include "cifspdu.h"
36 #include "cifsglob.h"
37 #include "cifsproto.h"
38 #include "cifs_unicode.h"
39 #include "cifs_debug.h"
40 #include "cifs_fs_sb.h"
41
42 static inline struct cifsFileInfo *cifs_init_private(
43 struct cifsFileInfo *private_data, struct inode *inode,
44 struct file *file, __u16 netfid)
45 {
46 memset(private_data, 0, sizeof(struct cifsFileInfo));
47 private_data->netfid = netfid;
48 private_data->pid = current->tgid;
49 mutex_init(&private_data->fh_mutex);
50 mutex_init(&private_data->lock_mutex);
51 INIT_LIST_HEAD(&private_data->llist);
52 private_data->pfile = file; /* needed for writepage */
53 private_data->pInode = inode;
54 private_data->invalidHandle = false;
55 private_data->closePend = false;
56 /* we have to track num writers to the inode, since writepages
57 does not tell us which handle the write is for so there can
58 be a close (overlapping with write) of the filehandle that
59 cifs_writepages chose to use */
60 atomic_set(&private_data->wrtPending, 0);
61
62 return private_data;
63 }
64
65 static inline int cifs_convert_flags(unsigned int flags)
66 {
67 if ((flags & O_ACCMODE) == O_RDONLY)
68 return GENERIC_READ;
69 else if ((flags & O_ACCMODE) == O_WRONLY)
70 return GENERIC_WRITE;
71 else if ((flags & O_ACCMODE) == O_RDWR) {
72 /* GENERIC_ALL is too much permission to request
73 can cause unnecessary access denied on create */
74 /* return GENERIC_ALL; */
75 return (GENERIC_READ | GENERIC_WRITE);
76 }
77
78 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
79 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
80 FILE_READ_DATA);
81 }
82
83 static inline fmode_t cifs_posix_convert_flags(unsigned int flags)
84 {
85 fmode_t posix_flags = 0;
86
87 if ((flags & O_ACCMODE) == O_RDONLY)
88 posix_flags = FMODE_READ;
89 else if ((flags & O_ACCMODE) == O_WRONLY)
90 posix_flags = FMODE_WRITE;
91 else if ((flags & O_ACCMODE) == O_RDWR) {
92 /* GENERIC_ALL is too much permission to request
93 can cause unnecessary access denied on create */
94 /* return GENERIC_ALL; */
95 posix_flags = FMODE_READ | FMODE_WRITE;
96 }
97 /* can not map O_CREAT or O_EXCL or O_TRUNC flags when
98 reopening a file. They had their effect on the original open */
99 if (flags & O_APPEND)
100 posix_flags |= (fmode_t)O_APPEND;
101 if (flags & O_SYNC)
102 posix_flags |= (fmode_t)O_SYNC;
103 if (flags & O_DIRECTORY)
104 posix_flags |= (fmode_t)O_DIRECTORY;
105 if (flags & O_NOFOLLOW)
106 posix_flags |= (fmode_t)O_NOFOLLOW;
107 if (flags & O_DIRECT)
108 posix_flags |= (fmode_t)O_DIRECT;
109
110 return posix_flags;
111 }
112
113 static inline int cifs_get_disposition(unsigned int flags)
114 {
115 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
116 return FILE_CREATE;
117 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
118 return FILE_OVERWRITE_IF;
119 else if ((flags & O_CREAT) == O_CREAT)
120 return FILE_OPEN_IF;
121 else if ((flags & O_TRUNC) == O_TRUNC)
122 return FILE_OVERWRITE;
123 else
124 return FILE_OPEN;
125 }
126
127 /* all arguments to this function must be checked for validity in caller */
128 static inline int cifs_posix_open_inode_helper(struct inode *inode,
129 struct file *file, struct cifsInodeInfo *pCifsInode,
130 struct cifsFileInfo *pCifsFile, int oplock, u16 netfid)
131 {
132
133 write_lock(&GlobalSMBSeslock);
134
135 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
136 if (pCifsInode == NULL) {
137 write_unlock(&GlobalSMBSeslock);
138 return -EINVAL;
139 }
140
141 if (pCifsInode->clientCanCacheRead) {
142 /* we have the inode open somewhere else
143 no need to discard cache data */
144 goto psx_client_can_cache;
145 }
146
147 /* BB FIXME need to fix this check to move it earlier into posix_open
148 BB fIX following section BB FIXME */
149
150 /* if not oplocked, invalidate inode pages if mtime or file
151 size changed */
152 /* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
153 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
154 (file->f_path.dentry->d_inode->i_size ==
155 (loff_t)le64_to_cpu(buf->EndOfFile))) {
156 cFYI(1, ("inode unchanged on server"));
157 } else {
158 if (file->f_path.dentry->d_inode->i_mapping) {
159 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
160 if (rc != 0)
161 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
162 }
163 cFYI(1, ("invalidating remote inode since open detected it "
164 "changed"));
165 invalidate_remote_inode(file->f_path.dentry->d_inode);
166 } */
167
168 psx_client_can_cache:
169 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
170 pCifsInode->clientCanCacheAll = true;
171 pCifsInode->clientCanCacheRead = true;
172 cFYI(1, ("Exclusive Oplock granted on inode %p",
173 file->f_path.dentry->d_inode));
174 } else if ((oplock & 0xF) == OPLOCK_READ)
175 pCifsInode->clientCanCacheRead = true;
176
177 /* will have to change the unlock if we reenable the
178 filemap_fdatawrite (which does not seem necessary */
179 write_unlock(&GlobalSMBSeslock);
180 return 0;
181 }
182
183 static struct cifsFileInfo *
184 cifs_fill_filedata(struct file *file)
185 {
186 struct list_head *tmp;
187 struct cifsFileInfo *pCifsFile = NULL;
188 struct cifsInodeInfo *pCifsInode = NULL;
189
190 /* search inode for this file and fill in file->private_data */
191 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
192 read_lock(&GlobalSMBSeslock);
193 list_for_each(tmp, &pCifsInode->openFileList) {
194 pCifsFile = list_entry(tmp, struct cifsFileInfo, flist);
195 if ((pCifsFile->pfile == NULL) &&
196 (pCifsFile->pid == current->tgid)) {
197 /* mode set in cifs_create */
198
199 /* needed for writepage */
200 pCifsFile->pfile = file;
201 file->private_data = pCifsFile;
202 break;
203 }
204 }
205 read_unlock(&GlobalSMBSeslock);
206
207 if (file->private_data != NULL) {
208 return pCifsFile;
209 } else if ((file->f_flags & O_CREAT) && (file->f_flags & O_EXCL))
210 cERROR(1, ("could not find file instance for "
211 "new file %p", file));
212 return NULL;
213 }
214
215 /* all arguments to this function must be checked for validity in caller */
216 static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
217 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
218 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
219 char *full_path, int xid)
220 {
221 struct timespec temp;
222 int rc;
223
224 /* want handles we can use to read with first
225 in the list so we do not have to walk the
226 list to search for one in write_begin */
227 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
228 list_add_tail(&pCifsFile->flist,
229 &pCifsInode->openFileList);
230 } else {
231 list_add(&pCifsFile->flist,
232 &pCifsInode->openFileList);
233 }
234 write_unlock(&GlobalSMBSeslock);
235 if (pCifsInode->clientCanCacheRead) {
236 /* we have the inode open somewhere else
237 no need to discard cache data */
238 goto client_can_cache;
239 }
240
241 /* BB need same check in cifs_create too? */
242 /* if not oplocked, invalidate inode pages if mtime or file
243 size changed */
244 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
245 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
246 (file->f_path.dentry->d_inode->i_size ==
247 (loff_t)le64_to_cpu(buf->EndOfFile))) {
248 cFYI(1, ("inode unchanged on server"));
249 } else {
250 if (file->f_path.dentry->d_inode->i_mapping) {
251 /* BB no need to lock inode until after invalidate
252 since namei code should already have it locked? */
253 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
254 if (rc != 0)
255 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
256 }
257 cFYI(1, ("invalidating remote inode since open detected it "
258 "changed"));
259 invalidate_remote_inode(file->f_path.dentry->d_inode);
260 }
261
262 client_can_cache:
263 if (pTcon->unix_ext)
264 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
265 full_path, inode->i_sb, xid);
266 else
267 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
268 full_path, buf, inode->i_sb, xid, NULL);
269
270 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
271 pCifsInode->clientCanCacheAll = true;
272 pCifsInode->clientCanCacheRead = true;
273 cFYI(1, ("Exclusive Oplock granted on inode %p",
274 file->f_path.dentry->d_inode));
275 } else if ((*oplock & 0xF) == OPLOCK_READ)
276 pCifsInode->clientCanCacheRead = true;
277
278 return rc;
279 }
280
281 int cifs_open(struct inode *inode, struct file *file)
282 {
283 int rc = -EACCES;
284 int xid, oplock;
285 struct cifs_sb_info *cifs_sb;
286 struct cifsTconInfo *tcon;
287 struct cifsFileInfo *pCifsFile;
288 struct cifsInodeInfo *pCifsInode;
289 char *full_path = NULL;
290 int desiredAccess;
291 int disposition;
292 __u16 netfid;
293 FILE_ALL_INFO *buf = NULL;
294
295 xid = GetXid();
296
297 cifs_sb = CIFS_SB(inode->i_sb);
298 tcon = cifs_sb->tcon;
299
300 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
301 pCifsFile = cifs_fill_filedata(file);
302 if (pCifsFile) {
303 rc = 0;
304 FreeXid(xid);
305 return rc;
306 }
307
308 full_path = build_path_from_dentry(file->f_path.dentry);
309 if (full_path == NULL) {
310 rc = -ENOMEM;
311 FreeXid(xid);
312 return rc;
313 }
314
315 cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
316 inode, file->f_flags, full_path));
317
318 if (oplockEnabled)
319 oplock = REQ_OPLOCK;
320 else
321 oplock = 0;
322
323 if (!tcon->broken_posix_open && tcon->unix_ext &&
324 (tcon->ses->capabilities & CAP_UNIX) &&
325 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
326 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
327 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
328 /* can not refresh inode info since size could be stale */
329 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
330 cifs_sb->mnt_file_mode /* ignored */,
331 oflags, &oplock, &netfid, xid);
332 if (rc == 0) {
333 cFYI(1, ("posix open succeeded"));
334 /* no need for special case handling of setting mode
335 on read only files needed here */
336
337 pCifsFile = cifs_fill_filedata(file);
338 cifs_posix_open_inode_helper(inode, file, pCifsInode,
339 pCifsFile, oplock, netfid);
340 goto out;
341 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
342 if (tcon->ses->serverNOS)
343 cERROR(1, ("server %s of type %s returned"
344 " unexpected error on SMB posix open"
345 ", disabling posix open support."
346 " Check if server update available.",
347 tcon->ses->serverName,
348 tcon->ses->serverNOS));
349 tcon->broken_posix_open = true;
350 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
351 (rc != -EOPNOTSUPP)) /* path not found or net err */
352 goto out;
353 /* else fallthrough to retry open the old way on network i/o
354 or DFS errors */
355 }
356
357 desiredAccess = cifs_convert_flags(file->f_flags);
358
359 /*********************************************************************
360 * open flag mapping table:
361 *
362 * POSIX Flag CIFS Disposition
363 * ---------- ----------------
364 * O_CREAT FILE_OPEN_IF
365 * O_CREAT | O_EXCL FILE_CREATE
366 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
367 * O_TRUNC FILE_OVERWRITE
368 * none of the above FILE_OPEN
369 *
370 * Note that there is not a direct match between disposition
371 * FILE_SUPERSEDE (ie create whether or not file exists although
372 * O_CREAT | O_TRUNC is similar but truncates the existing
373 * file rather than creating a new file as FILE_SUPERSEDE does
374 * (which uses the attributes / metadata passed in on open call)
375 *?
376 *? O_SYNC is a reasonable match to CIFS writethrough flag
377 *? and the read write flags match reasonably. O_LARGEFILE
378 *? is irrelevant because largefile support is always used
379 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
380 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
381 *********************************************************************/
382
383 disposition = cifs_get_disposition(file->f_flags);
384
385 /* BB pass O_SYNC flag through on file attributes .. BB */
386
387 /* Also refresh inode by passing in file_info buf returned by SMBOpen
388 and calling get_inode_info with returned buf (at least helps
389 non-Unix server case) */
390
391 /* BB we can not do this if this is the second open of a file
392 and the first handle has writebehind data, we might be
393 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
394 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
395 if (!buf) {
396 rc = -ENOMEM;
397 goto out;
398 }
399
400 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
401 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
402 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
403 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
404 & CIFS_MOUNT_MAP_SPECIAL_CHR);
405 else
406 rc = -EIO; /* no NT SMB support fall into legacy open below */
407
408 if (rc == -EIO) {
409 /* Old server, try legacy style OpenX */
410 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
411 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
412 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
413 & CIFS_MOUNT_MAP_SPECIAL_CHR);
414 }
415 if (rc) {
416 cFYI(1, ("cifs_open returned 0x%x", rc));
417 goto out;
418 }
419 file->private_data =
420 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
421 if (file->private_data == NULL) {
422 rc = -ENOMEM;
423 goto out;
424 }
425 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
426 write_lock(&GlobalSMBSeslock);
427 list_add(&pCifsFile->tlist, &tcon->openFileList);
428
429 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
430 if (pCifsInode) {
431 rc = cifs_open_inode_helper(inode, file, pCifsInode,
432 pCifsFile, tcon,
433 &oplock, buf, full_path, xid);
434 } else {
435 write_unlock(&GlobalSMBSeslock);
436 }
437
438 if (oplock & CIFS_CREATE_ACTION) {
439 /* time to set mode which we can not set earlier due to
440 problems creating new read-only files */
441 if (tcon->unix_ext) {
442 struct cifs_unix_set_info_args args = {
443 .mode = inode->i_mode,
444 .uid = NO_CHANGE_64,
445 .gid = NO_CHANGE_64,
446 .ctime = NO_CHANGE_64,
447 .atime = NO_CHANGE_64,
448 .mtime = NO_CHANGE_64,
449 .device = 0,
450 };
451 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
452 cifs_sb->local_nls,
453 cifs_sb->mnt_cifs_flags &
454 CIFS_MOUNT_MAP_SPECIAL_CHR);
455 }
456 }
457
458 out:
459 kfree(buf);
460 kfree(full_path);
461 FreeXid(xid);
462 return rc;
463 }
464
465 /* Try to reacquire byte range locks that were released when session */
466 /* to server was lost */
467 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
468 {
469 int rc = 0;
470
471 /* BB list all locks open on this file and relock */
472
473 return rc;
474 }
475
476 static int cifs_reopen_file(struct file *file, bool can_flush)
477 {
478 int rc = -EACCES;
479 int xid, oplock;
480 struct cifs_sb_info *cifs_sb;
481 struct cifsTconInfo *tcon;
482 struct cifsFileInfo *pCifsFile;
483 struct cifsInodeInfo *pCifsInode;
484 struct inode *inode;
485 char *full_path = NULL;
486 int desiredAccess;
487 int disposition = FILE_OPEN;
488 __u16 netfid;
489
490 if (file->private_data)
491 pCifsFile = (struct cifsFileInfo *)file->private_data;
492 else
493 return -EBADF;
494
495 xid = GetXid();
496 mutex_lock(&pCifsFile->fh_mutex);
497 if (!pCifsFile->invalidHandle) {
498 mutex_unlock(&pCifsFile->fh_mutex);
499 rc = 0;
500 FreeXid(xid);
501 return rc;
502 }
503
504 if (file->f_path.dentry == NULL) {
505 cERROR(1, ("no valid name if dentry freed"));
506 dump_stack();
507 rc = -EBADF;
508 goto reopen_error_exit;
509 }
510
511 inode = file->f_path.dentry->d_inode;
512 if (inode == NULL) {
513 cERROR(1, ("inode not valid"));
514 dump_stack();
515 rc = -EBADF;
516 goto reopen_error_exit;
517 }
518
519 cifs_sb = CIFS_SB(inode->i_sb);
520 tcon = cifs_sb->tcon;
521
522 /* can not grab rename sem here because various ops, including
523 those that already have the rename sem can end up causing writepage
524 to get called and if the server was down that means we end up here,
525 and we can never tell if the caller already has the rename_sem */
526 full_path = build_path_from_dentry(file->f_path.dentry);
527 if (full_path == NULL) {
528 rc = -ENOMEM;
529 reopen_error_exit:
530 mutex_unlock(&pCifsFile->fh_mutex);
531 FreeXid(xid);
532 return rc;
533 }
534
535 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
536 inode, file->f_flags, full_path));
537
538 if (oplockEnabled)
539 oplock = REQ_OPLOCK;
540 else
541 oplock = 0;
542
543 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
544 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
545 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
546 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
547 /* can not refresh inode info since size could be stale */
548 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
549 cifs_sb->mnt_file_mode /* ignored */,
550 oflags, &oplock, &netfid, xid);
551 if (rc == 0) {
552 cFYI(1, ("posix reopen succeeded"));
553 goto reopen_success;
554 }
555 /* fallthrough to retry open the old way on errors, especially
556 in the reconnect path it is important to retry hard */
557 }
558
559 desiredAccess = cifs_convert_flags(file->f_flags);
560
561 /* Can not refresh inode by passing in file_info buf to be returned
562 by SMBOpen and then calling get_inode_info with returned buf
563 since file might have write behind data that needs to be flushed
564 and server version of file size can be stale. If we knew for sure
565 that inode was not dirty locally we could do this */
566
567 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
568 CREATE_NOT_DIR, &netfid, &oplock, NULL,
569 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
570 CIFS_MOUNT_MAP_SPECIAL_CHR);
571 if (rc) {
572 mutex_unlock(&pCifsFile->fh_mutex);
573 cFYI(1, ("cifs_open returned 0x%x", rc));
574 cFYI(1, ("oplock: %d", oplock));
575 } else {
576 reopen_success:
577 pCifsFile->netfid = netfid;
578 pCifsFile->invalidHandle = false;
579 mutex_unlock(&pCifsFile->fh_mutex);
580 pCifsInode = CIFS_I(inode);
581 if (pCifsInode) {
582 if (can_flush) {
583 rc = filemap_write_and_wait(inode->i_mapping);
584 if (rc != 0)
585 CIFS_I(inode)->write_behind_rc = rc;
586 /* temporarily disable caching while we
587 go to server to get inode info */
588 pCifsInode->clientCanCacheAll = false;
589 pCifsInode->clientCanCacheRead = false;
590 if (tcon->unix_ext)
591 rc = cifs_get_inode_info_unix(&inode,
592 full_path, inode->i_sb, xid);
593 else
594 rc = cifs_get_inode_info(&inode,
595 full_path, NULL, inode->i_sb,
596 xid, NULL);
597 } /* else we are writing out data to server already
598 and could deadlock if we tried to flush data, and
599 since we do not know if we have data that would
600 invalidate the current end of file on the server
601 we can not go to the server to get the new inod
602 info */
603 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
604 pCifsInode->clientCanCacheAll = true;
605 pCifsInode->clientCanCacheRead = true;
606 cFYI(1, ("Exclusive Oplock granted on inode %p",
607 file->f_path.dentry->d_inode));
608 } else if ((oplock & 0xF) == OPLOCK_READ) {
609 pCifsInode->clientCanCacheRead = true;
610 pCifsInode->clientCanCacheAll = false;
611 } else {
612 pCifsInode->clientCanCacheRead = false;
613 pCifsInode->clientCanCacheAll = false;
614 }
615 cifs_relock_file(pCifsFile);
616 }
617 }
618 kfree(full_path);
619 FreeXid(xid);
620 return rc;
621 }
622
623 int cifs_close(struct inode *inode, struct file *file)
624 {
625 int rc = 0;
626 int xid, timeout;
627 struct cifs_sb_info *cifs_sb;
628 struct cifsTconInfo *pTcon;
629 struct cifsFileInfo *pSMBFile =
630 (struct cifsFileInfo *)file->private_data;
631
632 xid = GetXid();
633
634 cifs_sb = CIFS_SB(inode->i_sb);
635 pTcon = cifs_sb->tcon;
636 if (pSMBFile) {
637 struct cifsLockInfo *li, *tmp;
638 write_lock(&GlobalSMBSeslock);
639 pSMBFile->closePend = true;
640 if (pTcon) {
641 /* no sense reconnecting to close a file that is
642 already closed */
643 if (!pTcon->need_reconnect) {
644 write_unlock(&GlobalSMBSeslock);
645 timeout = 2;
646 while ((atomic_read(&pSMBFile->wrtPending) != 0)
647 && (timeout <= 2048)) {
648 /* Give write a better chance to get to
649 server ahead of the close. We do not
650 want to add a wait_q here as it would
651 increase the memory utilization as
652 the struct would be in each open file,
653 but this should give enough time to
654 clear the socket */
655 cFYI(DBG2,
656 ("close delay, write pending"));
657 msleep(timeout);
658 timeout *= 4;
659 }
660 if (atomic_read(&pSMBFile->wrtPending))
661 cERROR(1, ("close with pending write"));
662 if (!pTcon->need_reconnect &&
663 !pSMBFile->invalidHandle)
664 rc = CIFSSMBClose(xid, pTcon,
665 pSMBFile->netfid);
666 } else
667 write_unlock(&GlobalSMBSeslock);
668 } else
669 write_unlock(&GlobalSMBSeslock);
670
671 /* Delete any outstanding lock records.
672 We'll lose them when the file is closed anyway. */
673 mutex_lock(&pSMBFile->lock_mutex);
674 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
675 list_del(&li->llist);
676 kfree(li);
677 }
678 mutex_unlock(&pSMBFile->lock_mutex);
679
680 write_lock(&GlobalSMBSeslock);
681 list_del(&pSMBFile->flist);
682 list_del(&pSMBFile->tlist);
683 write_unlock(&GlobalSMBSeslock);
684 timeout = 10;
685 /* We waited above to give the SMBWrite a chance to issue
686 on the wire (so we do not get SMBWrite returning EBADF
687 if writepages is racing with close. Note that writepages
688 does not specify a file handle, so it is possible for a file
689 to be opened twice, and the application close the "wrong"
690 file handle - in these cases we delay long enough to allow
691 the SMBWrite to get on the wire before the SMB Close.
692 We allow total wait here over 45 seconds, more than
693 oplock break time, and more than enough to allow any write
694 to complete on the server, or to time out on the client */
695 while ((atomic_read(&pSMBFile->wrtPending) != 0)
696 && (timeout <= 50000)) {
697 cERROR(1, ("writes pending, delay free of handle"));
698 msleep(timeout);
699 timeout *= 8;
700 }
701 kfree(file->private_data);
702 file->private_data = NULL;
703 } else
704 rc = -EBADF;
705
706 read_lock(&GlobalSMBSeslock);
707 if (list_empty(&(CIFS_I(inode)->openFileList))) {
708 cFYI(1, ("closing last open instance for inode %p", inode));
709 /* if the file is not open we do not know if we can cache info
710 on this inode, much less write behind and read ahead */
711 CIFS_I(inode)->clientCanCacheRead = false;
712 CIFS_I(inode)->clientCanCacheAll = false;
713 }
714 read_unlock(&GlobalSMBSeslock);
715 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
716 rc = CIFS_I(inode)->write_behind_rc;
717 FreeXid(xid);
718 return rc;
719 }
720
721 int cifs_closedir(struct inode *inode, struct file *file)
722 {
723 int rc = 0;
724 int xid;
725 struct cifsFileInfo *pCFileStruct =
726 (struct cifsFileInfo *)file->private_data;
727 char *ptmp;
728
729 cFYI(1, ("Closedir inode = 0x%p", inode));
730
731 xid = GetXid();
732
733 if (pCFileStruct) {
734 struct cifsTconInfo *pTcon;
735 struct cifs_sb_info *cifs_sb =
736 CIFS_SB(file->f_path.dentry->d_sb);
737
738 pTcon = cifs_sb->tcon;
739
740 cFYI(1, ("Freeing private data in close dir"));
741 write_lock(&GlobalSMBSeslock);
742 if (!pCFileStruct->srch_inf.endOfSearch &&
743 !pCFileStruct->invalidHandle) {
744 pCFileStruct->invalidHandle = true;
745 write_unlock(&GlobalSMBSeslock);
746 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
747 cFYI(1, ("Closing uncompleted readdir with rc %d",
748 rc));
749 /* not much we can do if it fails anyway, ignore rc */
750 rc = 0;
751 } else
752 write_unlock(&GlobalSMBSeslock);
753 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
754 if (ptmp) {
755 cFYI(1, ("closedir free smb buf in srch struct"));
756 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
757 if (pCFileStruct->srch_inf.smallBuf)
758 cifs_small_buf_release(ptmp);
759 else
760 cifs_buf_release(ptmp);
761 }
762 kfree(file->private_data);
763 file->private_data = NULL;
764 }
765 /* BB can we lock the filestruct while this is going on? */
766 FreeXid(xid);
767 return rc;
768 }
769
770 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
771 __u64 offset, __u8 lockType)
772 {
773 struct cifsLockInfo *li =
774 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
775 if (li == NULL)
776 return -ENOMEM;
777 li->offset = offset;
778 li->length = len;
779 li->type = lockType;
780 mutex_lock(&fid->lock_mutex);
781 list_add(&li->llist, &fid->llist);
782 mutex_unlock(&fid->lock_mutex);
783 return 0;
784 }
785
786 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
787 {
788 int rc, xid;
789 __u32 numLock = 0;
790 __u32 numUnlock = 0;
791 __u64 length;
792 bool wait_flag = false;
793 struct cifs_sb_info *cifs_sb;
794 struct cifsTconInfo *tcon;
795 __u16 netfid;
796 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
797 bool posix_locking = 0;
798
799 length = 1 + pfLock->fl_end - pfLock->fl_start;
800 rc = -EACCES;
801 xid = GetXid();
802
803 cFYI(1, ("Lock parm: 0x%x flockflags: "
804 "0x%x flocktype: 0x%x start: %lld end: %lld",
805 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
806 pfLock->fl_end));
807
808 if (pfLock->fl_flags & FL_POSIX)
809 cFYI(1, ("Posix"));
810 if (pfLock->fl_flags & FL_FLOCK)
811 cFYI(1, ("Flock"));
812 if (pfLock->fl_flags & FL_SLEEP) {
813 cFYI(1, ("Blocking lock"));
814 wait_flag = true;
815 }
816 if (pfLock->fl_flags & FL_ACCESS)
817 cFYI(1, ("Process suspended by mandatory locking - "
818 "not implemented yet"));
819 if (pfLock->fl_flags & FL_LEASE)
820 cFYI(1, ("Lease on file - not implemented yet"));
821 if (pfLock->fl_flags &
822 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
823 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
824
825 if (pfLock->fl_type == F_WRLCK) {
826 cFYI(1, ("F_WRLCK "));
827 numLock = 1;
828 } else if (pfLock->fl_type == F_UNLCK) {
829 cFYI(1, ("F_UNLCK"));
830 numUnlock = 1;
831 /* Check if unlock includes more than
832 one lock range */
833 } else if (pfLock->fl_type == F_RDLCK) {
834 cFYI(1, ("F_RDLCK"));
835 lockType |= LOCKING_ANDX_SHARED_LOCK;
836 numLock = 1;
837 } else if (pfLock->fl_type == F_EXLCK) {
838 cFYI(1, ("F_EXLCK"));
839 numLock = 1;
840 } else if (pfLock->fl_type == F_SHLCK) {
841 cFYI(1, ("F_SHLCK"));
842 lockType |= LOCKING_ANDX_SHARED_LOCK;
843 numLock = 1;
844 } else
845 cFYI(1, ("Unknown type of lock"));
846
847 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
848 tcon = cifs_sb->tcon;
849
850 if (file->private_data == NULL) {
851 rc = -EBADF;
852 FreeXid(xid);
853 return rc;
854 }
855 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
856
857 if ((tcon->ses->capabilities & CAP_UNIX) &&
858 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
859 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
860 posix_locking = 1;
861 /* BB add code here to normalize offset and length to
862 account for negative length which we can not accept over the
863 wire */
864 if (IS_GETLK(cmd)) {
865 if (posix_locking) {
866 int posix_lock_type;
867 if (lockType & LOCKING_ANDX_SHARED_LOCK)
868 posix_lock_type = CIFS_RDLCK;
869 else
870 posix_lock_type = CIFS_WRLCK;
871 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
872 length, pfLock,
873 posix_lock_type, wait_flag);
874 FreeXid(xid);
875 return rc;
876 }
877
878 /* BB we could chain these into one lock request BB */
879 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
880 0, 1, lockType, 0 /* wait flag */ );
881 if (rc == 0) {
882 rc = CIFSSMBLock(xid, tcon, netfid, length,
883 pfLock->fl_start, 1 /* numUnlock */ ,
884 0 /* numLock */ , lockType,
885 0 /* wait flag */ );
886 pfLock->fl_type = F_UNLCK;
887 if (rc != 0)
888 cERROR(1, ("Error unlocking previously locked "
889 "range %d during test of lock", rc));
890 rc = 0;
891
892 } else {
893 /* if rc == ERR_SHARING_VIOLATION ? */
894 rc = 0; /* do not change lock type to unlock
895 since range in use */
896 }
897
898 FreeXid(xid);
899 return rc;
900 }
901
902 if (!numLock && !numUnlock) {
903 /* if no lock or unlock then nothing
904 to do since we do not know what it is */
905 FreeXid(xid);
906 return -EOPNOTSUPP;
907 }
908
909 if (posix_locking) {
910 int posix_lock_type;
911 if (lockType & LOCKING_ANDX_SHARED_LOCK)
912 posix_lock_type = CIFS_RDLCK;
913 else
914 posix_lock_type = CIFS_WRLCK;
915
916 if (numUnlock == 1)
917 posix_lock_type = CIFS_UNLCK;
918
919 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
920 length, pfLock,
921 posix_lock_type, wait_flag);
922 } else {
923 struct cifsFileInfo *fid =
924 (struct cifsFileInfo *)file->private_data;
925
926 if (numLock) {
927 rc = CIFSSMBLock(xid, tcon, netfid, length,
928 pfLock->fl_start,
929 0, numLock, lockType, wait_flag);
930
931 if (rc == 0) {
932 /* For Windows locks we must store them. */
933 rc = store_file_lock(fid, length,
934 pfLock->fl_start, lockType);
935 }
936 } else if (numUnlock) {
937 /* For each stored lock that this unlock overlaps
938 completely, unlock it. */
939 int stored_rc = 0;
940 struct cifsLockInfo *li, *tmp;
941
942 rc = 0;
943 mutex_lock(&fid->lock_mutex);
944 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
945 if (pfLock->fl_start <= li->offset &&
946 (pfLock->fl_start + length) >=
947 (li->offset + li->length)) {
948 stored_rc = CIFSSMBLock(xid, tcon,
949 netfid,
950 li->length, li->offset,
951 1, 0, li->type, false);
952 if (stored_rc)
953 rc = stored_rc;
954
955 list_del(&li->llist);
956 kfree(li);
957 }
958 }
959 mutex_unlock(&fid->lock_mutex);
960 }
961 }
962
963 if (pfLock->fl_flags & FL_POSIX)
964 posix_lock_file_wait(file, pfLock);
965 FreeXid(xid);
966 return rc;
967 }
968
969 /*
970 * Set the timeout on write requests past EOF. For some servers (Windows)
971 * these calls can be very long.
972 *
973 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
974 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
975 * The 10M cutoff is totally arbitrary. A better scheme for this would be
976 * welcome if someone wants to suggest one.
977 *
978 * We may be able to do a better job with this if there were some way to
979 * declare that a file should be sparse.
980 */
981 static int
982 cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
983 {
984 if (offset <= cifsi->server_eof)
985 return CIFS_STD_OP;
986 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
987 return CIFS_VLONG_OP;
988 else
989 return CIFS_LONG_OP;
990 }
991
992 /* update the file size (if needed) after a write */
993 static void
994 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
995 unsigned int bytes_written)
996 {
997 loff_t end_of_write = offset + bytes_written;
998
999 if (end_of_write > cifsi->server_eof)
1000 cifsi->server_eof = end_of_write;
1001 }
1002
1003 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
1004 size_t write_size, loff_t *poffset)
1005 {
1006 int rc = 0;
1007 unsigned int bytes_written = 0;
1008 unsigned int total_written;
1009 struct cifs_sb_info *cifs_sb;
1010 struct cifsTconInfo *pTcon;
1011 int xid, long_op;
1012 struct cifsFileInfo *open_file;
1013 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
1014
1015 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1016
1017 pTcon = cifs_sb->tcon;
1018
1019 /* cFYI(1,
1020 (" write %d bytes to offset %lld of %s", write_size,
1021 *poffset, file->f_path.dentry->d_name.name)); */
1022
1023 if (file->private_data == NULL)
1024 return -EBADF;
1025 open_file = (struct cifsFileInfo *) file->private_data;
1026
1027 rc = generic_write_checks(file, poffset, &write_size, 0);
1028 if (rc)
1029 return rc;
1030
1031 xid = GetXid();
1032
1033 long_op = cifs_write_timeout(cifsi, *poffset);
1034 for (total_written = 0; write_size > total_written;
1035 total_written += bytes_written) {
1036 rc = -EAGAIN;
1037 while (rc == -EAGAIN) {
1038 if (file->private_data == NULL) {
1039 /* file has been closed on us */
1040 FreeXid(xid);
1041 /* if we have gotten here we have written some data
1042 and blocked, and the file has been freed on us while
1043 we blocked so return what we managed to write */
1044 return total_written;
1045 }
1046 if (open_file->closePend) {
1047 FreeXid(xid);
1048 if (total_written)
1049 return total_written;
1050 else
1051 return -EBADF;
1052 }
1053 if (open_file->invalidHandle) {
1054 /* we could deadlock if we called
1055 filemap_fdatawait from here so tell
1056 reopen_file not to flush data to server
1057 now */
1058 rc = cifs_reopen_file(file, false);
1059 if (rc != 0)
1060 break;
1061 }
1062
1063 rc = CIFSSMBWrite(xid, pTcon,
1064 open_file->netfid,
1065 min_t(const int, cifs_sb->wsize,
1066 write_size - total_written),
1067 *poffset, &bytes_written,
1068 NULL, write_data + total_written, long_op);
1069 }
1070 if (rc || (bytes_written == 0)) {
1071 if (total_written)
1072 break;
1073 else {
1074 FreeXid(xid);
1075 return rc;
1076 }
1077 } else {
1078 cifs_update_eof(cifsi, *poffset, bytes_written);
1079 *poffset += bytes_written;
1080 }
1081 long_op = CIFS_STD_OP; /* subsequent writes fast -
1082 15 seconds is plenty */
1083 }
1084
1085 cifs_stats_bytes_written(pTcon, total_written);
1086
1087 /* since the write may have blocked check these pointers again */
1088 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1089 struct inode *inode = file->f_path.dentry->d_inode;
1090 /* Do not update local mtime - server will set its actual value on write
1091 * inode->i_ctime = inode->i_mtime =
1092 * current_fs_time(inode->i_sb);*/
1093 if (total_written > 0) {
1094 spin_lock(&inode->i_lock);
1095 if (*poffset > file->f_path.dentry->d_inode->i_size)
1096 i_size_write(file->f_path.dentry->d_inode,
1097 *poffset);
1098 spin_unlock(&inode->i_lock);
1099 }
1100 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1101 }
1102 FreeXid(xid);
1103 return total_written;
1104 }
1105
1106 static ssize_t cifs_write(struct file *file, const char *write_data,
1107 size_t write_size, loff_t *poffset)
1108 {
1109 int rc = 0;
1110 unsigned int bytes_written = 0;
1111 unsigned int total_written;
1112 struct cifs_sb_info *cifs_sb;
1113 struct cifsTconInfo *pTcon;
1114 int xid, long_op;
1115 struct cifsFileInfo *open_file;
1116 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
1117
1118 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1119
1120 pTcon = cifs_sb->tcon;
1121
1122 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
1123 *poffset, file->f_path.dentry->d_name.name));
1124
1125 if (file->private_data == NULL)
1126 return -EBADF;
1127 open_file = (struct cifsFileInfo *)file->private_data;
1128
1129 xid = GetXid();
1130
1131 long_op = cifs_write_timeout(cifsi, *poffset);
1132 for (total_written = 0; write_size > total_written;
1133 total_written += bytes_written) {
1134 rc = -EAGAIN;
1135 while (rc == -EAGAIN) {
1136 if (file->private_data == NULL) {
1137 /* file has been closed on us */
1138 FreeXid(xid);
1139 /* if we have gotten here we have written some data
1140 and blocked, and the file has been freed on us
1141 while we blocked so return what we managed to
1142 write */
1143 return total_written;
1144 }
1145 if (open_file->closePend) {
1146 FreeXid(xid);
1147 if (total_written)
1148 return total_written;
1149 else
1150 return -EBADF;
1151 }
1152 if (open_file->invalidHandle) {
1153 /* we could deadlock if we called
1154 filemap_fdatawait from here so tell
1155 reopen_file not to flush data to
1156 server now */
1157 rc = cifs_reopen_file(file, false);
1158 if (rc != 0)
1159 break;
1160 }
1161 if (experimEnabled || (pTcon->ses->server &&
1162 ((pTcon->ses->server->secMode &
1163 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1164 == 0))) {
1165 struct kvec iov[2];
1166 unsigned int len;
1167
1168 len = min((size_t)cifs_sb->wsize,
1169 write_size - total_written);
1170 /* iov[0] is reserved for smb header */
1171 iov[1].iov_base = (char *)write_data +
1172 total_written;
1173 iov[1].iov_len = len;
1174 rc = CIFSSMBWrite2(xid, pTcon,
1175 open_file->netfid, len,
1176 *poffset, &bytes_written,
1177 iov, 1, long_op);
1178 } else
1179 rc = CIFSSMBWrite(xid, pTcon,
1180 open_file->netfid,
1181 min_t(const int, cifs_sb->wsize,
1182 write_size - total_written),
1183 *poffset, &bytes_written,
1184 write_data + total_written,
1185 NULL, long_op);
1186 }
1187 if (rc || (bytes_written == 0)) {
1188 if (total_written)
1189 break;
1190 else {
1191 FreeXid(xid);
1192 return rc;
1193 }
1194 } else {
1195 cifs_update_eof(cifsi, *poffset, bytes_written);
1196 *poffset += bytes_written;
1197 }
1198 long_op = CIFS_STD_OP; /* subsequent writes fast -
1199 15 seconds is plenty */
1200 }
1201
1202 cifs_stats_bytes_written(pTcon, total_written);
1203
1204 /* since the write may have blocked check these pointers again */
1205 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1206 /*BB We could make this contingent on superblock ATIME flag too */
1207 /* file->f_path.dentry->d_inode->i_ctime =
1208 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1209 if (total_written > 0) {
1210 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1211 if (*poffset > file->f_path.dentry->d_inode->i_size)
1212 i_size_write(file->f_path.dentry->d_inode,
1213 *poffset);
1214 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
1215 }
1216 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1217 }
1218 FreeXid(xid);
1219 return total_written;
1220 }
1221
1222 #ifdef CONFIG_CIFS_EXPERIMENTAL
1223 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1224 {
1225 struct cifsFileInfo *open_file = NULL;
1226
1227 read_lock(&GlobalSMBSeslock);
1228 /* we could simply get the first_list_entry since write-only entries
1229 are always at the end of the list but since the first entry might
1230 have a close pending, we go through the whole list */
1231 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1232 if (open_file->closePend)
1233 continue;
1234 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1235 (open_file->pfile->f_flags & O_RDONLY))) {
1236 if (!open_file->invalidHandle) {
1237 /* found a good file */
1238 /* lock it so it will not be closed on us */
1239 atomic_inc(&open_file->wrtPending);
1240 read_unlock(&GlobalSMBSeslock);
1241 return open_file;
1242 } /* else might as well continue, and look for
1243 another, or simply have the caller reopen it
1244 again rather than trying to fix this handle */
1245 } else /* write only file */
1246 break; /* write only files are last so must be done */
1247 }
1248 read_unlock(&GlobalSMBSeslock);
1249 return NULL;
1250 }
1251 #endif
1252
1253 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1254 {
1255 struct cifsFileInfo *open_file;
1256 bool any_available = false;
1257 int rc;
1258
1259 /* Having a null inode here (because mapping->host was set to zero by
1260 the VFS or MM) should not happen but we had reports of on oops (due to
1261 it being zero) during stress testcases so we need to check for it */
1262
1263 if (cifs_inode == NULL) {
1264 cERROR(1, ("Null inode passed to cifs_writeable_file"));
1265 dump_stack();
1266 return NULL;
1267 }
1268
1269 read_lock(&GlobalSMBSeslock);
1270 refind_writable:
1271 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1272 if (open_file->closePend ||
1273 (!any_available && open_file->pid != current->tgid))
1274 continue;
1275
1276 if (open_file->pfile &&
1277 ((open_file->pfile->f_flags & O_RDWR) ||
1278 (open_file->pfile->f_flags & O_WRONLY))) {
1279 atomic_inc(&open_file->wrtPending);
1280
1281 if (!open_file->invalidHandle) {
1282 /* found a good writable file */
1283 read_unlock(&GlobalSMBSeslock);
1284 return open_file;
1285 }
1286
1287 read_unlock(&GlobalSMBSeslock);
1288 /* Had to unlock since following call can block */
1289 rc = cifs_reopen_file(open_file->pfile, false);
1290 if (!rc) {
1291 if (!open_file->closePend)
1292 return open_file;
1293 else { /* start over in case this was deleted */
1294 /* since the list could be modified */
1295 read_lock(&GlobalSMBSeslock);
1296 atomic_dec(&open_file->wrtPending);
1297 goto refind_writable;
1298 }
1299 }
1300
1301 /* if it fails, try another handle if possible -
1302 (we can not do this if closePending since
1303 loop could be modified - in which case we
1304 have to start at the beginning of the list
1305 again. Note that it would be bad
1306 to hold up writepages here (rather than
1307 in caller) with continuous retries */
1308 cFYI(1, ("wp failed on reopen file"));
1309 read_lock(&GlobalSMBSeslock);
1310 /* can not use this handle, no write
1311 pending on this one after all */
1312 atomic_dec(&open_file->wrtPending);
1313
1314 if (open_file->closePend) /* list could have changed */
1315 goto refind_writable;
1316 /* else we simply continue to the next entry. Thus
1317 we do not loop on reopen errors. If we
1318 can not reopen the file, for example if we
1319 reconnected to a server with another client
1320 racing to delete or lock the file we would not
1321 make progress if we restarted before the beginning
1322 of the loop here. */
1323 }
1324 }
1325 /* couldn't find useable FH with same pid, try any available */
1326 if (!any_available) {
1327 any_available = true;
1328 goto refind_writable;
1329 }
1330 read_unlock(&GlobalSMBSeslock);
1331 return NULL;
1332 }
1333
1334 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1335 {
1336 struct address_space *mapping = page->mapping;
1337 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1338 char *write_data;
1339 int rc = -EFAULT;
1340 int bytes_written = 0;
1341 struct cifs_sb_info *cifs_sb;
1342 struct cifsTconInfo *pTcon;
1343 struct inode *inode;
1344 struct cifsFileInfo *open_file;
1345
1346 if (!mapping || !mapping->host)
1347 return -EFAULT;
1348
1349 inode = page->mapping->host;
1350 cifs_sb = CIFS_SB(inode->i_sb);
1351 pTcon = cifs_sb->tcon;
1352
1353 offset += (loff_t)from;
1354 write_data = kmap(page);
1355 write_data += from;
1356
1357 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1358 kunmap(page);
1359 return -EIO;
1360 }
1361
1362 /* racing with truncate? */
1363 if (offset > mapping->host->i_size) {
1364 kunmap(page);
1365 return 0; /* don't care */
1366 }
1367
1368 /* check to make sure that we are not extending the file */
1369 if (mapping->host->i_size - offset < (loff_t)to)
1370 to = (unsigned)(mapping->host->i_size - offset);
1371
1372 open_file = find_writable_file(CIFS_I(mapping->host));
1373 if (open_file) {
1374 bytes_written = cifs_write(open_file->pfile, write_data,
1375 to-from, &offset);
1376 atomic_dec(&open_file->wrtPending);
1377 /* Does mm or vfs already set times? */
1378 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1379 if ((bytes_written > 0) && (offset))
1380 rc = 0;
1381 else if (bytes_written < 0)
1382 rc = bytes_written;
1383 } else {
1384 cFYI(1, ("No writeable filehandles for inode"));
1385 rc = -EIO;
1386 }
1387
1388 kunmap(page);
1389 return rc;
1390 }
1391
1392 static int cifs_writepages(struct address_space *mapping,
1393 struct writeback_control *wbc)
1394 {
1395 struct backing_dev_info *bdi = mapping->backing_dev_info;
1396 unsigned int bytes_to_write;
1397 unsigned int bytes_written;
1398 struct cifs_sb_info *cifs_sb;
1399 int done = 0;
1400 pgoff_t end;
1401 pgoff_t index;
1402 int range_whole = 0;
1403 struct kvec *iov;
1404 int len;
1405 int n_iov = 0;
1406 pgoff_t next;
1407 int nr_pages;
1408 __u64 offset = 0;
1409 struct cifsFileInfo *open_file;
1410 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1411 struct page *page;
1412 struct pagevec pvec;
1413 int rc = 0;
1414 int scanned = 0;
1415 int xid, long_op;
1416
1417 cifs_sb = CIFS_SB(mapping->host->i_sb);
1418
1419 /*
1420 * If wsize is smaller that the page cache size, default to writing
1421 * one page at a time via cifs_writepage
1422 */
1423 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1424 return generic_writepages(mapping, wbc);
1425
1426 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1427 if (cifs_sb->tcon->ses->server->secMode &
1428 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1429 if (!experimEnabled)
1430 return generic_writepages(mapping, wbc);
1431
1432 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1433 if (iov == NULL)
1434 return generic_writepages(mapping, wbc);
1435
1436
1437 /*
1438 * BB: Is this meaningful for a non-block-device file system?
1439 * If it is, we should test it again after we do I/O
1440 */
1441 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1442 wbc->encountered_congestion = 1;
1443 kfree(iov);
1444 return 0;
1445 }
1446
1447 xid = GetXid();
1448
1449 pagevec_init(&pvec, 0);
1450 if (wbc->range_cyclic) {
1451 index = mapping->writeback_index; /* Start from prev offset */
1452 end = -1;
1453 } else {
1454 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1455 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1456 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1457 range_whole = 1;
1458 scanned = 1;
1459 }
1460 retry:
1461 while (!done && (index <= end) &&
1462 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1463 PAGECACHE_TAG_DIRTY,
1464 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1465 int first;
1466 unsigned int i;
1467
1468 first = -1;
1469 next = 0;
1470 n_iov = 0;
1471 bytes_to_write = 0;
1472
1473 for (i = 0; i < nr_pages; i++) {
1474 page = pvec.pages[i];
1475 /*
1476 * At this point we hold neither mapping->tree_lock nor
1477 * lock on the page itself: the page may be truncated or
1478 * invalidated (changing page->mapping to NULL), or even
1479 * swizzled back from swapper_space to tmpfs file
1480 * mapping
1481 */
1482
1483 if (first < 0)
1484 lock_page(page);
1485 else if (!trylock_page(page))
1486 break;
1487
1488 if (unlikely(page->mapping != mapping)) {
1489 unlock_page(page);
1490 break;
1491 }
1492
1493 if (!wbc->range_cyclic && page->index > end) {
1494 done = 1;
1495 unlock_page(page);
1496 break;
1497 }
1498
1499 if (next && (page->index != next)) {
1500 /* Not next consecutive page */
1501 unlock_page(page);
1502 break;
1503 }
1504
1505 if (wbc->sync_mode != WB_SYNC_NONE)
1506 wait_on_page_writeback(page);
1507
1508 if (PageWriteback(page) ||
1509 !clear_page_dirty_for_io(page)) {
1510 unlock_page(page);
1511 break;
1512 }
1513
1514 /*
1515 * This actually clears the dirty bit in the radix tree.
1516 * See cifs_writepage() for more commentary.
1517 */
1518 set_page_writeback(page);
1519
1520 if (page_offset(page) >= mapping->host->i_size) {
1521 done = 1;
1522 unlock_page(page);
1523 end_page_writeback(page);
1524 break;
1525 }
1526
1527 /*
1528 * BB can we get rid of this? pages are held by pvec
1529 */
1530 page_cache_get(page);
1531
1532 len = min(mapping->host->i_size - page_offset(page),
1533 (loff_t)PAGE_CACHE_SIZE);
1534
1535 /* reserve iov[0] for the smb header */
1536 n_iov++;
1537 iov[n_iov].iov_base = kmap(page);
1538 iov[n_iov].iov_len = len;
1539 bytes_to_write += len;
1540
1541 if (first < 0) {
1542 first = i;
1543 offset = page_offset(page);
1544 }
1545 next = page->index + 1;
1546 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1547 break;
1548 }
1549 if (n_iov) {
1550 /* Search for a writable handle every time we call
1551 * CIFSSMBWrite2. We can't rely on the last handle
1552 * we used to still be valid
1553 */
1554 open_file = find_writable_file(CIFS_I(mapping->host));
1555 if (!open_file) {
1556 cERROR(1, ("No writable handles for inode"));
1557 rc = -EBADF;
1558 } else {
1559 long_op = cifs_write_timeout(cifsi, offset);
1560 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1561 open_file->netfid,
1562 bytes_to_write, offset,
1563 &bytes_written, iov, n_iov,
1564 long_op);
1565 atomic_dec(&open_file->wrtPending);
1566 cifs_update_eof(cifsi, offset, bytes_written);
1567
1568 if (rc || bytes_written < bytes_to_write) {
1569 cERROR(1, ("Write2 ret %d, wrote %d",
1570 rc, bytes_written));
1571 /* BB what if continued retry is
1572 requested via mount flags? */
1573 if (rc == -ENOSPC)
1574 set_bit(AS_ENOSPC, &mapping->flags);
1575 else
1576 set_bit(AS_EIO, &mapping->flags);
1577 } else {
1578 cifs_stats_bytes_written(cifs_sb->tcon,
1579 bytes_written);
1580 }
1581 }
1582 for (i = 0; i < n_iov; i++) {
1583 page = pvec.pages[first + i];
1584 /* Should we also set page error on
1585 success rc but too little data written? */
1586 /* BB investigate retry logic on temporary
1587 server crash cases and how recovery works
1588 when page marked as error */
1589 if (rc)
1590 SetPageError(page);
1591 kunmap(page);
1592 unlock_page(page);
1593 end_page_writeback(page);
1594 page_cache_release(page);
1595 }
1596 if ((wbc->nr_to_write -= n_iov) <= 0)
1597 done = 1;
1598 index = next;
1599 } else
1600 /* Need to re-find the pages we skipped */
1601 index = pvec.pages[0]->index + 1;
1602
1603 pagevec_release(&pvec);
1604 }
1605 if (!scanned && !done) {
1606 /*
1607 * We hit the last page and there is more work to be done: wrap
1608 * back to the start of the file
1609 */
1610 scanned = 1;
1611 index = 0;
1612 goto retry;
1613 }
1614 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1615 mapping->writeback_index = index;
1616
1617 FreeXid(xid);
1618 kfree(iov);
1619 return rc;
1620 }
1621
1622 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1623 {
1624 int rc = -EFAULT;
1625 int xid;
1626
1627 xid = GetXid();
1628 /* BB add check for wbc flags */
1629 page_cache_get(page);
1630 if (!PageUptodate(page))
1631 cFYI(1, ("ppw - page not up to date"));
1632
1633 /*
1634 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1635 *
1636 * A writepage() implementation always needs to do either this,
1637 * or re-dirty the page with "redirty_page_for_writepage()" in
1638 * the case of a failure.
1639 *
1640 * Just unlocking the page will cause the radix tree tag-bits
1641 * to fail to update with the state of the page correctly.
1642 */
1643 set_page_writeback(page);
1644 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1645 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1646 unlock_page(page);
1647 end_page_writeback(page);
1648 page_cache_release(page);
1649 FreeXid(xid);
1650 return rc;
1651 }
1652
1653 static int cifs_write_end(struct file *file, struct address_space *mapping,
1654 loff_t pos, unsigned len, unsigned copied,
1655 struct page *page, void *fsdata)
1656 {
1657 int rc;
1658 struct inode *inode = mapping->host;
1659
1660 cFYI(1, ("write_end for page %p from pos %lld with %d bytes",
1661 page, pos, copied));
1662
1663 if (PageChecked(page)) {
1664 if (copied == len)
1665 SetPageUptodate(page);
1666 ClearPageChecked(page);
1667 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1668 SetPageUptodate(page);
1669
1670 if (!PageUptodate(page)) {
1671 char *page_data;
1672 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1673 int xid;
1674
1675 xid = GetXid();
1676 /* this is probably better than directly calling
1677 partialpage_write since in this function the file handle is
1678 known which we might as well leverage */
1679 /* BB check if anything else missing out of ppw
1680 such as updating last write time */
1681 page_data = kmap(page);
1682 rc = cifs_write(file, page_data + offset, copied, &pos);
1683 /* if (rc < 0) should we set writebehind rc? */
1684 kunmap(page);
1685
1686 FreeXid(xid);
1687 } else {
1688 rc = copied;
1689 pos += copied;
1690 set_page_dirty(page);
1691 }
1692
1693 if (rc > 0) {
1694 spin_lock(&inode->i_lock);
1695 if (pos > inode->i_size)
1696 i_size_write(inode, pos);
1697 spin_unlock(&inode->i_lock);
1698 }
1699
1700 unlock_page(page);
1701 page_cache_release(page);
1702
1703 return rc;
1704 }
1705
1706 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1707 {
1708 int xid;
1709 int rc = 0;
1710 struct cifsTconInfo *tcon;
1711 struct cifsFileInfo *smbfile =
1712 (struct cifsFileInfo *)file->private_data;
1713 struct inode *inode = file->f_path.dentry->d_inode;
1714
1715 xid = GetXid();
1716
1717 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
1718 dentry->d_name.name, datasync));
1719
1720 rc = filemap_write_and_wait(inode->i_mapping);
1721 if (rc == 0) {
1722 rc = CIFS_I(inode)->write_behind_rc;
1723 CIFS_I(inode)->write_behind_rc = 0;
1724 tcon = CIFS_SB(inode->i_sb)->tcon;
1725 if (!rc && tcon && smbfile &&
1726 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1727 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1728 }
1729
1730 FreeXid(xid);
1731 return rc;
1732 }
1733
1734 /* static void cifs_sync_page(struct page *page)
1735 {
1736 struct address_space *mapping;
1737 struct inode *inode;
1738 unsigned long index = page->index;
1739 unsigned int rpages = 0;
1740 int rc = 0;
1741
1742 cFYI(1, ("sync page %p",page));
1743 mapping = page->mapping;
1744 if (!mapping)
1745 return 0;
1746 inode = mapping->host;
1747 if (!inode)
1748 return; */
1749
1750 /* fill in rpages then
1751 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1752
1753 /* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
1754
1755 #if 0
1756 if (rc < 0)
1757 return rc;
1758 return 0;
1759 #endif
1760 } */
1761
1762 /*
1763 * As file closes, flush all cached write data for this inode checking
1764 * for write behind errors.
1765 */
1766 int cifs_flush(struct file *file, fl_owner_t id)
1767 {
1768 struct inode *inode = file->f_path.dentry->d_inode;
1769 int rc = 0;
1770
1771 /* Rather than do the steps manually:
1772 lock the inode for writing
1773 loop through pages looking for write behind data (dirty pages)
1774 coalesce into contiguous 16K (or smaller) chunks to write to server
1775 send to server (prefer in parallel)
1776 deal with writebehind errors
1777 unlock inode for writing
1778 filemapfdatawrite appears easier for the time being */
1779
1780 rc = filemap_fdatawrite(inode->i_mapping);
1781 /* reset wb rc if we were able to write out dirty pages */
1782 if (!rc) {
1783 rc = CIFS_I(inode)->write_behind_rc;
1784 CIFS_I(inode)->write_behind_rc = 0;
1785 }
1786
1787 cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
1788
1789 return rc;
1790 }
1791
1792 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1793 size_t read_size, loff_t *poffset)
1794 {
1795 int rc = -EACCES;
1796 unsigned int bytes_read = 0;
1797 unsigned int total_read = 0;
1798 unsigned int current_read_size;
1799 struct cifs_sb_info *cifs_sb;
1800 struct cifsTconInfo *pTcon;
1801 int xid;
1802 struct cifsFileInfo *open_file;
1803 char *smb_read_data;
1804 char __user *current_offset;
1805 struct smb_com_read_rsp *pSMBr;
1806
1807 xid = GetXid();
1808 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1809 pTcon = cifs_sb->tcon;
1810
1811 if (file->private_data == NULL) {
1812 rc = -EBADF;
1813 FreeXid(xid);
1814 return rc;
1815 }
1816 open_file = (struct cifsFileInfo *)file->private_data;
1817
1818 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1819 cFYI(1, ("attempting read on write only file instance"));
1820
1821 for (total_read = 0, current_offset = read_data;
1822 read_size > total_read;
1823 total_read += bytes_read, current_offset += bytes_read) {
1824 current_read_size = min_t(const int, read_size - total_read,
1825 cifs_sb->rsize);
1826 rc = -EAGAIN;
1827 smb_read_data = NULL;
1828 while (rc == -EAGAIN) {
1829 int buf_type = CIFS_NO_BUFFER;
1830 if ((open_file->invalidHandle) &&
1831 (!open_file->closePend)) {
1832 rc = cifs_reopen_file(file, true);
1833 if (rc != 0)
1834 break;
1835 }
1836 rc = CIFSSMBRead(xid, pTcon,
1837 open_file->netfid,
1838 current_read_size, *poffset,
1839 &bytes_read, &smb_read_data,
1840 &buf_type);
1841 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1842 if (smb_read_data) {
1843 if (copy_to_user(current_offset,
1844 smb_read_data +
1845 4 /* RFC1001 length field */ +
1846 le16_to_cpu(pSMBr->DataOffset),
1847 bytes_read))
1848 rc = -EFAULT;
1849
1850 if (buf_type == CIFS_SMALL_BUFFER)
1851 cifs_small_buf_release(smb_read_data);
1852 else if (buf_type == CIFS_LARGE_BUFFER)
1853 cifs_buf_release(smb_read_data);
1854 smb_read_data = NULL;
1855 }
1856 }
1857 if (rc || (bytes_read == 0)) {
1858 if (total_read) {
1859 break;
1860 } else {
1861 FreeXid(xid);
1862 return rc;
1863 }
1864 } else {
1865 cifs_stats_bytes_read(pTcon, bytes_read);
1866 *poffset += bytes_read;
1867 }
1868 }
1869 FreeXid(xid);
1870 return total_read;
1871 }
1872
1873
1874 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1875 loff_t *poffset)
1876 {
1877 int rc = -EACCES;
1878 unsigned int bytes_read = 0;
1879 unsigned int total_read;
1880 unsigned int current_read_size;
1881 struct cifs_sb_info *cifs_sb;
1882 struct cifsTconInfo *pTcon;
1883 int xid;
1884 char *current_offset;
1885 struct cifsFileInfo *open_file;
1886 int buf_type = CIFS_NO_BUFFER;
1887
1888 xid = GetXid();
1889 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1890 pTcon = cifs_sb->tcon;
1891
1892 if (file->private_data == NULL) {
1893 rc = -EBADF;
1894 FreeXid(xid);
1895 return rc;
1896 }
1897 open_file = (struct cifsFileInfo *)file->private_data;
1898
1899 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1900 cFYI(1, ("attempting read on write only file instance"));
1901
1902 for (total_read = 0, current_offset = read_data;
1903 read_size > total_read;
1904 total_read += bytes_read, current_offset += bytes_read) {
1905 current_read_size = min_t(const int, read_size - total_read,
1906 cifs_sb->rsize);
1907 /* For windows me and 9x we do not want to request more
1908 than it negotiated since it will refuse the read then */
1909 if ((pTcon->ses) &&
1910 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1911 current_read_size = min_t(const int, current_read_size,
1912 pTcon->ses->server->maxBuf - 128);
1913 }
1914 rc = -EAGAIN;
1915 while (rc == -EAGAIN) {
1916 if ((open_file->invalidHandle) &&
1917 (!open_file->closePend)) {
1918 rc = cifs_reopen_file(file, true);
1919 if (rc != 0)
1920 break;
1921 }
1922 rc = CIFSSMBRead(xid, pTcon,
1923 open_file->netfid,
1924 current_read_size, *poffset,
1925 &bytes_read, ¤t_offset,
1926 &buf_type);
1927 }
1928 if (rc || (bytes_read == 0)) {
1929 if (total_read) {
1930 break;
1931 } else {
1932 FreeXid(xid);
1933 return rc;
1934 }
1935 } else {
1936 cifs_stats_bytes_read(pTcon, total_read);
1937 *poffset += bytes_read;
1938 }
1939 }
1940 FreeXid(xid);
1941 return total_read;
1942 }
1943
1944 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1945 {
1946 struct dentry *dentry = file->f_path.dentry;
1947 int rc, xid;
1948
1949 xid = GetXid();
1950 rc = cifs_revalidate(dentry);
1951 if (rc) {
1952 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1953 FreeXid(xid);
1954 return rc;
1955 }
1956 rc = generic_file_mmap(file, vma);
1957 FreeXid(xid);
1958 return rc;
1959 }
1960
1961
1962 static void cifs_copy_cache_pages(struct address_space *mapping,
1963 struct list_head *pages, int bytes_read, char *data,
1964 struct pagevec *plru_pvec)
1965 {
1966 struct page *page;
1967 char *target;
1968
1969 while (bytes_read > 0) {
1970 if (list_empty(pages))
1971 break;
1972
1973 page = list_entry(pages->prev, struct page, lru);
1974 list_del(&page->lru);
1975
1976 if (add_to_page_cache(page, mapping, page->index,
1977 GFP_KERNEL)) {
1978 page_cache_release(page);
1979 cFYI(1, ("Add page cache failed"));
1980 data += PAGE_CACHE_SIZE;
1981 bytes_read -= PAGE_CACHE_SIZE;
1982 continue;
1983 }
1984
1985 target = kmap_atomic(page, KM_USER0);
1986
1987 if (PAGE_CACHE_SIZE > bytes_read) {
1988 memcpy(target, data, bytes_read);
1989 /* zero the tail end of this partial page */
1990 memset(target + bytes_read, 0,
1991 PAGE_CACHE_SIZE - bytes_read);
1992 bytes_read = 0;
1993 } else {
1994 memcpy(target, data, PAGE_CACHE_SIZE);
1995 bytes_read -= PAGE_CACHE_SIZE;
1996 }
1997 kunmap_atomic(target, KM_USER0);
1998
1999 flush_dcache_page(page);
2000 SetPageUptodate(page);
2001 unlock_page(page);
2002 if (!pagevec_add(plru_pvec, page))
2003 __pagevec_lru_add_file(plru_pvec);
2004 data += PAGE_CACHE_SIZE;
2005 }
2006 return;
2007 }
2008
2009 static int cifs_readpages(struct file *file, struct address_space *mapping,
2010 struct list_head *page_list, unsigned num_pages)
2011 {
2012 int rc = -EACCES;
2013 int xid;
2014 loff_t offset;
2015 struct page *page;
2016 struct cifs_sb_info *cifs_sb;
2017 struct cifsTconInfo *pTcon;
2018 unsigned int bytes_read = 0;
2019 unsigned int read_size, i;
2020 char *smb_read_data = NULL;
2021 struct smb_com_read_rsp *pSMBr;
2022 struct pagevec lru_pvec;
2023 struct cifsFileInfo *open_file;
2024 int buf_type = CIFS_NO_BUFFER;
2025
2026 xid = GetXid();
2027 if (file->private_data == NULL) {
2028 rc = -EBADF;
2029 FreeXid(xid);
2030 return rc;
2031 }
2032 open_file = (struct cifsFileInfo *)file->private_data;
2033 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2034 pTcon = cifs_sb->tcon;
2035
2036 pagevec_init(&lru_pvec, 0);
2037 cFYI(DBG2, ("rpages: num pages %d", num_pages));
2038 for (i = 0; i < num_pages; ) {
2039 unsigned contig_pages;
2040 struct page *tmp_page;
2041 unsigned long expected_index;
2042
2043 if (list_empty(page_list))
2044 break;
2045
2046 page = list_entry(page_list->prev, struct page, lru);
2047 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2048
2049 /* count adjacent pages that we will read into */
2050 contig_pages = 0;
2051 expected_index =
2052 list_entry(page_list->prev, struct page, lru)->index;
2053 list_for_each_entry_reverse(tmp_page, page_list, lru) {
2054 if (tmp_page->index == expected_index) {
2055 contig_pages++;
2056 expected_index++;
2057 } else
2058 break;
2059 }
2060 if (contig_pages + i > num_pages)
2061 contig_pages = num_pages - i;
2062
2063 /* for reads over a certain size could initiate async
2064 read ahead */
2065
2066 read_size = contig_pages * PAGE_CACHE_SIZE;
2067 /* Read size needs to be in multiples of one page */
2068 read_size = min_t(const unsigned int, read_size,
2069 cifs_sb->rsize & PAGE_CACHE_MASK);
2070 cFYI(DBG2, ("rpages: read size 0x%x contiguous pages %d",
2071 read_size, contig_pages));
2072 rc = -EAGAIN;
2073 while (rc == -EAGAIN) {
2074 if ((open_file->invalidHandle) &&
2075 (!open_file->closePend)) {
2076 rc = cifs_reopen_file(file, true);
2077 if (rc != 0)
2078 break;
2079 }
2080
2081 rc = CIFSSMBRead(xid, pTcon,
2082 open_file->netfid,
2083 read_size, offset,
2084 &bytes_read, &smb_read_data,
2085 &buf_type);
2086 /* BB more RC checks ? */
2087 if (rc == -EAGAIN) {
2088 if (smb_read_data) {
2089 if (buf_type == CIFS_SMALL_BUFFER)
2090 cifs_small_buf_release(smb_read_data);
2091 else if (buf_type == CIFS_LARGE_BUFFER)
2092 cifs_buf_release(smb_read_data);
2093 smb_read_data = NULL;
2094 }
2095 }
2096 }
2097 if ((rc < 0) || (smb_read_data == NULL)) {
2098 cFYI(1, ("Read error in readpages: %d", rc));
2099 break;
2100 } else if (bytes_read > 0) {
2101 task_io_account_read(bytes_read);
2102 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2103 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2104 smb_read_data + 4 /* RFC1001 hdr */ +
2105 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
2106
2107 i += bytes_read >> PAGE_CACHE_SHIFT;
2108 cifs_stats_bytes_read(pTcon, bytes_read);
2109 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2110 i++; /* account for partial page */
2111
2112 /* server copy of file can have smaller size
2113 than client */
2114 /* BB do we need to verify this common case ?
2115 this case is ok - if we are at server EOF
2116 we will hit it on next read */
2117
2118 /* break; */
2119 }
2120 } else {
2121 cFYI(1, ("No bytes read (%d) at offset %lld . "
2122 "Cleaning remaining pages from readahead list",
2123 bytes_read, offset));
2124 /* BB turn off caching and do new lookup on
2125 file size at server? */
2126 break;
2127 }
2128 if (smb_read_data) {
2129 if (buf_type == CIFS_SMALL_BUFFER)
2130 cifs_small_buf_release(smb_read_data);
2131 else if (buf_type == CIFS_LARGE_BUFFER)
2132 cifs_buf_release(smb_read_data);
2133 smb_read_data = NULL;
2134 }
2135 bytes_read = 0;
2136 }
2137
2138 pagevec_lru_add_file(&lru_pvec);
2139
2140 /* need to free smb_read_data buf before exit */
2141 if (smb_read_data) {
2142 if (buf_type == CIFS_SMALL_BUFFER)
2143 cifs_small_buf_release(smb_read_data);
2144 else if (buf_type == CIFS_LARGE_BUFFER)
2145 cifs_buf_release(smb_read_data);
2146 smb_read_data = NULL;
2147 }
2148
2149 FreeXid(xid);
2150 return rc;
2151 }
2152
2153 static int cifs_readpage_worker(struct file *file, struct page *page,
2154 loff_t *poffset)
2155 {
2156 char *read_data;
2157 int rc;
2158
2159 page_cache_get(page);
2160 read_data = kmap(page);
2161 /* for reads over a certain size could initiate async read ahead */
2162
2163 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2164
2165 if (rc < 0)
2166 goto io_error;
2167 else
2168 cFYI(1, ("Bytes read %d", rc));
2169
2170 file->f_path.dentry->d_inode->i_atime =
2171 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2172
2173 if (PAGE_CACHE_SIZE > rc)
2174 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2175
2176 flush_dcache_page(page);
2177 SetPageUptodate(page);
2178 rc = 0;
2179
2180 io_error:
2181 kunmap(page);
2182 page_cache_release(page);
2183 return rc;
2184 }
2185
2186 static int cifs_readpage(struct file *file, struct page *page)
2187 {
2188 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2189 int rc = -EACCES;
2190 int xid;
2191
2192 xid = GetXid();
2193
2194 if (file->private_data == NULL) {
2195 rc = -EBADF;
2196 FreeXid(xid);
2197 return rc;
2198 }
2199
2200 cFYI(1, ("readpage %p at offset %d 0x%x\n",
2201 page, (int)offset, (int)offset));
2202
2203 rc = cifs_readpage_worker(file, page, &offset);
2204
2205 unlock_page(page);
2206
2207 FreeXid(xid);
2208 return rc;
2209 }
2210
2211 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2212 {
2213 struct cifsFileInfo *open_file;
2214
2215 read_lock(&GlobalSMBSeslock);
2216 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2217 if (open_file->closePend)
2218 continue;
2219 if (open_file->pfile &&
2220 ((open_file->pfile->f_flags & O_RDWR) ||
2221 (open_file->pfile->f_flags & O_WRONLY))) {
2222 read_unlock(&GlobalSMBSeslock);
2223 return 1;
2224 }
2225 }
2226 read_unlock(&GlobalSMBSeslock);
2227 return 0;
2228 }
2229
2230 /* We do not want to update the file size from server for inodes
2231 open for write - to avoid races with writepage extending
2232 the file - in the future we could consider allowing
2233 refreshing the inode only on increases in the file size
2234 but this is tricky to do without racing with writebehind
2235 page caching in the current Linux kernel design */
2236 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2237 {
2238 if (!cifsInode)
2239 return true;
2240
2241 if (is_inode_writable(cifsInode)) {
2242 /* This inode is open for write at least once */
2243 struct cifs_sb_info *cifs_sb;
2244
2245 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2246 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2247 /* since no page cache to corrupt on directio
2248 we can change size safely */
2249 return true;
2250 }
2251
2252 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2253 return true;
2254
2255 return false;
2256 } else
2257 return true;
2258 }
2259
2260 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2261 loff_t pos, unsigned len, unsigned flags,
2262 struct page **pagep, void **fsdata)
2263 {
2264 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2265 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2266 loff_t page_start = pos & PAGE_MASK;
2267 loff_t i_size;
2268 struct page *page;
2269 int rc = 0;
2270
2271 cFYI(1, ("write_begin from %lld len %d", (long long)pos, len));
2272
2273 page = grab_cache_page_write_begin(mapping, index, flags);
2274 if (!page) {
2275 rc = -ENOMEM;
2276 goto out;
2277 }
2278
2279 if (PageUptodate(page))
2280 goto out;
2281
2282 /*
2283 * If we write a full page it will be up to date, no need to read from
2284 * the server. If the write is short, we'll end up doing a sync write
2285 * instead.
2286 */
2287 if (len == PAGE_CACHE_SIZE)
2288 goto out;
2289
2290 /*
2291 * optimize away the read when we have an oplock, and we're not
2292 * expecting to use any of the data we'd be reading in. That
2293 * is, when the page lies beyond the EOF, or straddles the EOF
2294 * and the write will cover all of the existing data.
2295 */
2296 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2297 i_size = i_size_read(mapping->host);
2298 if (page_start >= i_size ||
2299 (offset == 0 && (pos + len) >= i_size)) {
2300 zero_user_segments(page, 0, offset,
2301 offset + len,
2302 PAGE_CACHE_SIZE);
2303 /*
2304 * PageChecked means that the parts of the page
2305 * to which we're not writing are considered up
2306 * to date. Once the data is copied to the
2307 * page, it can be set uptodate.
2308 */
2309 SetPageChecked(page);
2310 goto out;
2311 }
2312 }
2313
2314 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2315 /*
2316 * might as well read a page, it is fast enough. If we get
2317 * an error, we don't need to return it. cifs_write_end will
2318 * do a sync write instead since PG_uptodate isn't set.
2319 */
2320 cifs_readpage_worker(file, page, &page_start);
2321 } else {
2322 /* we could try using another file handle if there is one -
2323 but how would we lock it to prevent close of that handle
2324 racing with this read? In any case
2325 this will be written out by write_end so is fine */
2326 }
2327 out:
2328 *pagep = page;
2329 return rc;
2330 }
2331
2332 const struct address_space_operations cifs_addr_ops = {
2333 .readpage = cifs_readpage,
2334 .readpages = cifs_readpages,
2335 .writepage = cifs_writepage,
2336 .writepages = cifs_writepages,
2337 .write_begin = cifs_write_begin,
2338 .write_end = cifs_write_end,
2339 .set_page_dirty = __set_page_dirty_nobuffers,
2340 /* .sync_page = cifs_sync_page, */
2341 /* .direct_IO = */
2342 };
2343
2344 /*
2345 * cifs_readpages requires the server to support a buffer large enough to
2346 * contain the header plus one complete page of data. Otherwise, we need
2347 * to leave cifs_readpages out of the address space operations.
2348 */
2349 const struct address_space_operations cifs_addr_ops_smallbuf = {
2350 .readpage = cifs_readpage,
2351 .writepage = cifs_writepage,
2352 .writepages = cifs_writepages,
2353 .write_begin = cifs_write_begin,
2354 .write_end = cifs_write_end,
2355 .set_page_dirty = __set_page_dirty_nobuffers,
2356 /* .sync_page = cifs_sync_page, */
2357 /* .direct_IO = */
2358 };
2359
|
This page was automatically generated by the
LXR engine.
|