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