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