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