]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/cifs/file.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:


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