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