1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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 <asm/div64.h>
35#include "cifsfs.h"
36#include "cifspdu.h"
37#include "cifsglob.h"
38#include "cifsproto.h"
39#include "cifs_unicode.h"
40#include "cifs_debug.h"
41#include "cifs_fs_sb.h"
42
43static inline int cifs_convert_flags(unsigned int flags)
44{
45 if ((flags & O_ACCMODE) == O_RDONLY)
46 return GENERIC_READ;
47 else if ((flags & O_ACCMODE) == O_WRONLY)
48 return GENERIC_WRITE;
49 else if ((flags & O_ACCMODE) == O_RDWR) {
50
51
52
53 return (GENERIC_READ | GENERIC_WRITE);
54 }
55
56 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
57 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
58 FILE_READ_DATA);
59}
60
61static inline fmode_t cifs_posix_convert_flags(unsigned int flags)
62{
63 fmode_t posix_flags = 0;
64
65 if ((flags & O_ACCMODE) == O_RDONLY)
66 posix_flags = FMODE_READ;
67 else if ((flags & O_ACCMODE) == O_WRONLY)
68 posix_flags = FMODE_WRITE;
69 else if ((flags & O_ACCMODE) == O_RDWR) {
70
71
72
73 posix_flags = FMODE_READ | FMODE_WRITE;
74 }
75
76
77 if (flags & O_APPEND)
78 posix_flags |= (fmode_t)O_APPEND;
79 if (flags & O_SYNC)
80 posix_flags |= (fmode_t)O_SYNC;
81 if (flags & O_DIRECTORY)
82 posix_flags |= (fmode_t)O_DIRECTORY;
83 if (flags & O_NOFOLLOW)
84 posix_flags |= (fmode_t)O_NOFOLLOW;
85 if (flags & O_DIRECT)
86 posix_flags |= (fmode_t)O_DIRECT;
87
88 return posix_flags;
89}
90
91static inline int cifs_get_disposition(unsigned int flags)
92{
93 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
94 return FILE_CREATE;
95 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
96 return FILE_OVERWRITE_IF;
97 else if ((flags & O_CREAT) == O_CREAT)
98 return FILE_OPEN_IF;
99 else if ((flags & O_TRUNC) == O_TRUNC)
100 return FILE_OVERWRITE;
101 else
102 return FILE_OPEN;
103}
104
105
106static inline int
107cifs_posix_open_inode_helper(struct inode *inode, struct file *file,
108 struct cifsInodeInfo *pCifsInode,
109 struct cifsFileInfo *pCifsFile, __u32 oplock,
110 u16 netfid)
111{
112
113 write_lock(&GlobalSMBSeslock);
114
115 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
116 if (pCifsInode == NULL) {
117 write_unlock(&GlobalSMBSeslock);
118 return -EINVAL;
119 }
120
121 if (pCifsInode->clientCanCacheRead) {
122
123
124 goto psx_client_can_cache;
125 }
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148psx_client_can_cache:
149 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
150 pCifsInode->clientCanCacheAll = true;
151 pCifsInode->clientCanCacheRead = true;
152 cFYI(1, ("Exclusive Oplock granted on inode %p",
153 file->f_path.dentry->d_inode));
154 } else if ((oplock & 0xF) == OPLOCK_READ)
155 pCifsInode->clientCanCacheRead = true;
156
157
158
159 write_unlock(&GlobalSMBSeslock);
160 return 0;
161}
162
163static struct cifsFileInfo *
164cifs_fill_filedata(struct file *file)
165{
166 struct list_head *tmp;
167 struct cifsFileInfo *pCifsFile = NULL;
168 struct cifsInodeInfo *pCifsInode = NULL;
169
170
171 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
172 read_lock(&GlobalSMBSeslock);
173 list_for_each(tmp, &pCifsInode->openFileList) {
174 pCifsFile = list_entry(tmp, struct cifsFileInfo, flist);
175 if ((pCifsFile->pfile == NULL) &&
176 (pCifsFile->pid == current->tgid)) {
177
178
179
180 pCifsFile->pfile = file;
181 file->private_data = pCifsFile;
182 break;
183 }
184 }
185 read_unlock(&GlobalSMBSeslock);
186
187 if (file->private_data != NULL) {
188 return pCifsFile;
189 } else if ((file->f_flags & O_CREAT) && (file->f_flags & O_EXCL))
190 cERROR(1, ("could not find file instance for "
191 "new file %p", file));
192 return NULL;
193}
194
195
196static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
197 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
198 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
199 char *full_path, int xid)
200{
201 struct timespec temp;
202 int rc;
203
204 if (pCifsInode->clientCanCacheRead) {
205
206
207 goto client_can_cache;
208 }
209
210
211
212
213 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
214 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
215 (file->f_path.dentry->d_inode->i_size ==
216 (loff_t)le64_to_cpu(buf->EndOfFile))) {
217 cFYI(1, ("inode unchanged on server"));
218 } else {
219 if (file->f_path.dentry->d_inode->i_mapping) {
220
221
222 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
223 if (rc != 0)
224 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
225 }
226 cFYI(1, ("invalidating remote inode since open detected it "
227 "changed"));
228 invalidate_remote_inode(file->f_path.dentry->d_inode);
229 }
230
231client_can_cache:
232 if (pTcon->unix_ext)
233 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
234 full_path, inode->i_sb, xid);
235 else
236 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
237 full_path, buf, inode->i_sb, xid, NULL);
238
239 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
240 pCifsInode->clientCanCacheAll = true;
241 pCifsInode->clientCanCacheRead = true;
242 cFYI(1, ("Exclusive Oplock granted on inode %p",
243 file->f_path.dentry->d_inode));
244 } else if ((*oplock & 0xF) == OPLOCK_READ)
245 pCifsInode->clientCanCacheRead = true;
246
247 return rc;
248}
249
250int cifs_open(struct inode *inode, struct file *file)
251{
252 int rc = -EACCES;
253 int xid;
254 __u32 oplock;
255 struct cifs_sb_info *cifs_sb;
256 struct cifsTconInfo *tcon;
257 struct cifsFileInfo *pCifsFile;
258 struct cifsInodeInfo *pCifsInode;
259 char *full_path = NULL;
260 int desiredAccess;
261 int disposition;
262 __u16 netfid;
263 FILE_ALL_INFO *buf = NULL;
264
265 xid = GetXid();
266
267 cifs_sb = CIFS_SB(inode->i_sb);
268 tcon = cifs_sb->tcon;
269
270 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
271 pCifsFile = cifs_fill_filedata(file);
272 if (pCifsFile) {
273 rc = 0;
274 FreeXid(xid);
275 return rc;
276 }
277
278 full_path = build_path_from_dentry(file->f_path.dentry);
279 if (full_path == NULL) {
280 rc = -ENOMEM;
281 FreeXid(xid);
282 return rc;
283 }
284
285 cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
286 inode, file->f_flags, full_path));
287
288 if (oplockEnabled)
289 oplock = REQ_OPLOCK;
290 else
291 oplock = 0;
292
293 if (!tcon->broken_posix_open && tcon->unix_ext &&
294 (tcon->ses->capabilities & CAP_UNIX) &&
295 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
296 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
297 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
298
299 rc = cifs_posix_open(full_path, &inode, file->f_path.mnt,
300 cifs_sb->mnt_file_mode ,
301 oflags, &oplock, &netfid, xid);
302 if (rc == 0) {
303 cFYI(1, ("posix open succeeded"));
304
305
306
307 pCifsFile = cifs_fill_filedata(file);
308 cifs_posix_open_inode_helper(inode, file, pCifsInode,
309 pCifsFile, oplock, netfid);
310 goto out;
311 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
312 if (tcon->ses->serverNOS)
313 cERROR(1, ("server %s of type %s returned"
314 " unexpected error on SMB posix open"
315 ", disabling posix open support."
316 " Check if server update available.",
317 tcon->ses->serverName,
318 tcon->ses->serverNOS));
319 tcon->broken_posix_open = true;
320 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
321 (rc != -EOPNOTSUPP))
322 goto out;
323
324
325 }
326
327 desiredAccess = cifs_convert_flags(file->f_flags);
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353 disposition = cifs_get_disposition(file->f_flags);
354
355
356
357
358
359
360
361
362
363
364 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
365 if (!buf) {
366 rc = -ENOMEM;
367 goto out;
368 }
369
370 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
371 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
372 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
373 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
374 & CIFS_MOUNT_MAP_SPECIAL_CHR);
375 else
376 rc = -EIO;
377
378 if (rc == -EIO) {
379
380 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
381 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
382 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
383 & CIFS_MOUNT_MAP_SPECIAL_CHR);
384 }
385 if (rc) {
386 cFYI(1, ("cifs_open returned 0x%x", rc));
387 goto out;
388 }
389
390 pCifsFile = cifs_new_fileinfo(inode, netfid, file, file->f_path.mnt,
391 file->f_flags);
392 file->private_data = pCifsFile;
393 if (file->private_data == NULL) {
394 rc = -ENOMEM;
395 goto out;
396 }
397
398 rc = cifs_open_inode_helper(inode, file, pCifsInode, pCifsFile, tcon,
399 &oplock, buf, full_path, xid);
400
401 if (oplock & CIFS_CREATE_ACTION) {
402
403
404 if (tcon->unix_ext) {
405 struct cifs_unix_set_info_args args = {
406 .mode = inode->i_mode,
407 .uid = NO_CHANGE_64,
408 .gid = NO_CHANGE_64,
409 .ctime = NO_CHANGE_64,
410 .atime = NO_CHANGE_64,
411 .mtime = NO_CHANGE_64,
412 .device = 0,
413 };
414 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
415 cifs_sb->local_nls,
416 cifs_sb->mnt_cifs_flags &
417 CIFS_MOUNT_MAP_SPECIAL_CHR);
418 }
419 }
420
421out:
422 kfree(buf);
423 kfree(full_path);
424 FreeXid(xid);
425 return rc;
426}
427
428
429
430static int cifs_relock_file(struct cifsFileInfo *cifsFile)
431{
432 int rc = 0;
433
434
435
436 return rc;
437}
438
439static int cifs_reopen_file(struct file *file, bool can_flush)
440{
441 int rc = -EACCES;
442 int xid;
443 __u32 oplock;
444 struct cifs_sb_info *cifs_sb;
445 struct cifsTconInfo *tcon;
446 struct cifsFileInfo *pCifsFile;
447 struct cifsInodeInfo *pCifsInode;
448 struct inode *inode;
449 char *full_path = NULL;
450 int desiredAccess;
451 int disposition = FILE_OPEN;
452 __u16 netfid;
453
454 if (file->private_data)
455 pCifsFile = (struct cifsFileInfo *)file->private_data;
456 else
457 return -EBADF;
458
459 xid = GetXid();
460 mutex_lock(&pCifsFile->fh_mutex);
461 if (!pCifsFile->invalidHandle) {
462 mutex_unlock(&pCifsFile->fh_mutex);
463 rc = 0;
464 FreeXid(xid);
465 return rc;
466 }
467
468 if (file->f_path.dentry == NULL) {
469 cERROR(1, ("no valid name if dentry freed"));
470 dump_stack();
471 rc = -EBADF;
472 goto reopen_error_exit;
473 }
474
475 inode = file->f_path.dentry->d_inode;
476 if (inode == NULL) {
477 cERROR(1, ("inode not valid"));
478 dump_stack();
479 rc = -EBADF;
480 goto reopen_error_exit;
481 }
482
483 cifs_sb = CIFS_SB(inode->i_sb);
484 tcon = cifs_sb->tcon;
485
486
487
488
489
490 full_path = build_path_from_dentry(file->f_path.dentry);
491 if (full_path == NULL) {
492 rc = -ENOMEM;
493reopen_error_exit:
494 mutex_unlock(&pCifsFile->fh_mutex);
495 FreeXid(xid);
496 return rc;
497 }
498
499 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
500 inode, file->f_flags, full_path));
501
502 if (oplockEnabled)
503 oplock = REQ_OPLOCK;
504 else
505 oplock = 0;
506
507 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
508 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
509 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
510 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
511
512 rc = cifs_posix_open(full_path, NULL, file->f_path.mnt,
513 cifs_sb->mnt_file_mode ,
514 oflags, &oplock, &netfid, xid);
515 if (rc == 0) {
516 cFYI(1, ("posix reopen succeeded"));
517 goto reopen_success;
518 }
519
520
521 }
522
523 desiredAccess = cifs_convert_flags(file->f_flags);
524
525
526
527
528
529
530
531 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
532 CREATE_NOT_DIR, &netfid, &oplock, NULL,
533 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
534 CIFS_MOUNT_MAP_SPECIAL_CHR);
535 if (rc) {
536 mutex_unlock(&pCifsFile->fh_mutex);
537 cFYI(1, ("cifs_open returned 0x%x", rc));
538 cFYI(1, ("oplock: %d", oplock));
539 } else {
540reopen_success:
541 pCifsFile->netfid = netfid;
542 pCifsFile->invalidHandle = false;
543 mutex_unlock(&pCifsFile->fh_mutex);
544 pCifsInode = CIFS_I(inode);
545 if (pCifsInode) {
546 if (can_flush) {
547 rc = filemap_write_and_wait(inode->i_mapping);
548 if (rc != 0)
549 CIFS_I(inode)->write_behind_rc = rc;
550
551
552 pCifsInode->clientCanCacheAll = false;
553 pCifsInode->clientCanCacheRead = false;
554 if (tcon->unix_ext)
555 rc = cifs_get_inode_info_unix(&inode,
556 full_path, inode->i_sb, xid);
557 else
558 rc = cifs_get_inode_info(&inode,
559 full_path, NULL, inode->i_sb,
560 xid, NULL);
561 }
562
563
564
565
566
567 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
568 pCifsInode->clientCanCacheAll = true;
569 pCifsInode->clientCanCacheRead = true;
570 cFYI(1, ("Exclusive Oplock granted on inode %p",
571 file->f_path.dentry->d_inode));
572 } else if ((oplock & 0xF) == OPLOCK_READ) {
573 pCifsInode->clientCanCacheRead = true;
574 pCifsInode->clientCanCacheAll = false;
575 } else {
576 pCifsInode->clientCanCacheRead = false;
577 pCifsInode->clientCanCacheAll = false;
578 }
579 cifs_relock_file(pCifsFile);
580 }
581 }
582 kfree(full_path);
583 FreeXid(xid);
584 return rc;
585}
586
587int cifs_close(struct inode *inode, struct file *file)
588{
589 int rc = 0;
590 int xid, timeout;
591 struct cifs_sb_info *cifs_sb;
592 struct cifsTconInfo *pTcon;
593 struct cifsFileInfo *pSMBFile =
594 (struct cifsFileInfo *)file->private_data;
595
596 xid = GetXid();
597
598 cifs_sb = CIFS_SB(inode->i_sb);
599 pTcon = cifs_sb->tcon;
600 if (pSMBFile) {
601 struct cifsLockInfo *li, *tmp;
602 write_lock(&GlobalSMBSeslock);
603 pSMBFile->closePend = true;
604 if (pTcon) {
605
606
607 if (!pTcon->need_reconnect) {
608 write_unlock(&GlobalSMBSeslock);
609 timeout = 2;
610 while ((atomic_read(&pSMBFile->count) != 1)
611 && (timeout <= 2048)) {
612
613
614
615
616
617
618
619 cFYI(DBG2,
620 ("close delay, write pending"));
621 msleep(timeout);
622 timeout *= 4;
623 }
624 if (!pTcon->need_reconnect &&
625 !pSMBFile->invalidHandle)
626 rc = CIFSSMBClose(xid, pTcon,
627 pSMBFile->netfid);
628 } else
629 write_unlock(&GlobalSMBSeslock);
630 } else
631 write_unlock(&GlobalSMBSeslock);
632
633
634
635 mutex_lock(&pSMBFile->lock_mutex);
636 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
637 list_del(&li->llist);
638 kfree(li);
639 }
640 mutex_unlock(&pSMBFile->lock_mutex);
641
642 write_lock(&GlobalSMBSeslock);
643 list_del(&pSMBFile->flist);
644 list_del(&pSMBFile->tlist);
645 write_unlock(&GlobalSMBSeslock);
646 cifsFileInfo_put(file->private_data);
647 file->private_data = NULL;
648 } else
649 rc = -EBADF;
650
651 read_lock(&GlobalSMBSeslock);
652 if (list_empty(&(CIFS_I(inode)->openFileList))) {
653 cFYI(1, ("closing last open instance for inode %p", inode));
654
655
656 CIFS_I(inode)->clientCanCacheRead = false;
657 CIFS_I(inode)->clientCanCacheAll = false;
658 }
659 read_unlock(&GlobalSMBSeslock);
660 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
661 rc = CIFS_I(inode)->write_behind_rc;
662 FreeXid(xid);
663 return rc;
664}
665
666int cifs_closedir(struct inode *inode, struct file *file)
667{
668 int rc = 0;
669 int xid;
670 struct cifsFileInfo *pCFileStruct =
671 (struct cifsFileInfo *)file->private_data;
672 char *ptmp;
673
674 cFYI(1, ("Closedir inode = 0x%p", inode));
675
676 xid = GetXid();
677
678 if (pCFileStruct) {
679 struct cifsTconInfo *pTcon;
680 struct cifs_sb_info *cifs_sb =
681 CIFS_SB(file->f_path.dentry->d_sb);
682
683 pTcon = cifs_sb->tcon;
684
685 cFYI(1, ("Freeing private data in close dir"));
686 write_lock(&GlobalSMBSeslock);
687 if (!pCFileStruct->srch_inf.endOfSearch &&
688 !pCFileStruct->invalidHandle) {
689 pCFileStruct->invalidHandle = true;
690 write_unlock(&GlobalSMBSeslock);
691 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
692 cFYI(1, ("Closing uncompleted readdir with rc %d",
693 rc));
694
695 rc = 0;
696 } else
697 write_unlock(&GlobalSMBSeslock);
698 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
699 if (ptmp) {
700 cFYI(1, ("closedir free smb buf in srch struct"));
701 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
702 if (pCFileStruct->srch_inf.smallBuf)
703 cifs_small_buf_release(ptmp);
704 else
705 cifs_buf_release(ptmp);
706 }
707 kfree(file->private_data);
708 file->private_data = NULL;
709 }
710
711 FreeXid(xid);
712 return rc;
713}
714
715static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
716 __u64 offset, __u8 lockType)
717{
718 struct cifsLockInfo *li =
719 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
720 if (li == NULL)
721 return -ENOMEM;
722 li->offset = offset;
723 li->length = len;
724 li->type = lockType;
725 mutex_lock(&fid->lock_mutex);
726 list_add(&li->llist, &fid->llist);
727 mutex_unlock(&fid->lock_mutex);
728 return 0;
729}
730
731int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
732{
733 int rc, xid;
734 __u32 numLock = 0;
735 __u32 numUnlock = 0;
736 __u64 length;
737 bool wait_flag = false;
738 struct cifs_sb_info *cifs_sb;
739 struct cifsTconInfo *tcon;
740 __u16 netfid;
741 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
742 bool posix_locking = 0;
743
744 length = 1 + pfLock->fl_end - pfLock->fl_start;
745 rc = -EACCES;
746 xid = GetXid();
747
748 cFYI(1, ("Lock parm: 0x%x flockflags: "
749 "0x%x flocktype: 0x%x start: %lld end: %lld",
750 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
751 pfLock->fl_end));
752
753 if (pfLock->fl_flags & FL_POSIX)
754 cFYI(1, ("Posix"));
755 if (pfLock->fl_flags & FL_FLOCK)
756 cFYI(1, ("Flock"));
757 if (pfLock->fl_flags & FL_SLEEP) {
758 cFYI(1, ("Blocking lock"));
759 wait_flag = true;
760 }
761 if (pfLock->fl_flags & FL_ACCESS)
762 cFYI(1, ("Process suspended by mandatory locking - "
763 "not implemented yet"));
764 if (pfLock->fl_flags & FL_LEASE)
765 cFYI(1, ("Lease on file - not implemented yet"));
766 if (pfLock->fl_flags &
767 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
768 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
769
770 if (pfLock->fl_type == F_WRLCK) {
771 cFYI(1, ("F_WRLCK "));
772 numLock = 1;
773 } else if (pfLock->fl_type == F_UNLCK) {
774 cFYI(1, ("F_UNLCK"));
775 numUnlock = 1;
776
777
778 } else if (pfLock->fl_type == F_RDLCK) {
779 cFYI(1, ("F_RDLCK"));
780 lockType |= LOCKING_ANDX_SHARED_LOCK;
781 numLock = 1;
782 } else if (pfLock->fl_type == F_EXLCK) {
783 cFYI(1, ("F_EXLCK"));
784 numLock = 1;
785 } else if (pfLock->fl_type == F_SHLCK) {
786 cFYI(1, ("F_SHLCK"));
787 lockType |= LOCKING_ANDX_SHARED_LOCK;
788 numLock = 1;
789 } else
790 cFYI(1, ("Unknown type of lock"));
791
792 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
793 tcon = cifs_sb->tcon;
794
795 if (file->private_data == NULL) {
796 rc = -EBADF;
797 FreeXid(xid);
798 return rc;
799 }
800 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
801
802 if ((tcon->ses->capabilities & CAP_UNIX) &&
803 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
804 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
805 posix_locking = 1;
806
807
808
809 if (IS_GETLK(cmd)) {
810 if (posix_locking) {
811 int posix_lock_type;
812 if (lockType & LOCKING_ANDX_SHARED_LOCK)
813 posix_lock_type = CIFS_RDLCK;
814 else
815 posix_lock_type = CIFS_WRLCK;
816 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 ,
817 length, pfLock,
818 posix_lock_type, wait_flag);
819 FreeXid(xid);
820 return rc;
821 }
822
823
824 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
825 0, 1, lockType, 0 );
826 if (rc == 0) {
827 rc = CIFSSMBLock(xid, tcon, netfid, length,
828 pfLock->fl_start, 1 ,
829 0 , lockType,
830 0 );
831 pfLock->fl_type = F_UNLCK;
832 if (rc != 0)
833 cERROR(1, ("Error unlocking previously locked "
834 "range %d during test of lock", rc));
835 rc = 0;
836
837 } else {
838
839 rc = 0;
840
841 }
842
843 FreeXid(xid);
844 return rc;
845 }
846
847 if (!numLock && !numUnlock) {
848
849
850 FreeXid(xid);
851 return -EOPNOTSUPP;
852 }
853
854 if (posix_locking) {
855 int posix_lock_type;
856 if (lockType & LOCKING_ANDX_SHARED_LOCK)
857 posix_lock_type = CIFS_RDLCK;
858 else
859 posix_lock_type = CIFS_WRLCK;
860
861 if (numUnlock == 1)
862 posix_lock_type = CIFS_UNLCK;
863
864 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 ,
865 length, pfLock,
866 posix_lock_type, wait_flag);
867 } else {
868 struct cifsFileInfo *fid =
869 (struct cifsFileInfo *)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
878 rc = store_file_lock(fid, length,
879 pfLock->fl_start, lockType);
880 }
881 } else if (numUnlock) {
882
883
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
900 list_del(&li->llist);
901 kfree(li);
902 }
903 }
904 mutex_unlock(&fid->lock_mutex);
905 }
906 }
907
908 if (pfLock->fl_flags & FL_POSIX)
909 posix_lock_file_wait(file, pfLock);
910 FreeXid(xid);
911 return rc;
912}
913
914
915
916
917
918
919
920
921
922
923
924
925
926static int
927cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
928{
929 if (offset <= cifsi->server_eof)
930 return CIFS_STD_OP;
931 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
932 return CIFS_VLONG_OP;
933 else
934 return CIFS_LONG_OP;
935}
936
937
938static void
939cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
940 unsigned int bytes_written)
941{
942 loff_t end_of_write = offset + bytes_written;
943
944 if (end_of_write > cifsi->server_eof)
945 cifsi->server_eof = end_of_write;
946}
947
948ssize_t cifs_user_write(struct file *file, const char __user *write_data,
949 size_t write_size, loff_t *poffset)
950{
951 int rc = 0;
952 unsigned int bytes_written = 0;
953 unsigned int total_written;
954 struct cifs_sb_info *cifs_sb;
955 struct cifsTconInfo *pTcon;
956 int xid, long_op;
957 struct cifsFileInfo *open_file;
958 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
959
960 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
961
962 pTcon = cifs_sb->tcon;
963
964
965
966
967
968 if (file->private_data == NULL)
969 return -EBADF;
970 open_file = (struct cifsFileInfo *) 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
985 FreeXid(xid);
986
987
988
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
1000
1001
1002
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;
1027
1028 }
1029
1030 cifs_stats_bytes_written(pTcon, total_written);
1031
1032
1033 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1034 struct inode *inode = file->f_path.dentry->d_inode;
1035
1036
1037
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
1051static 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 = (struct cifsFileInfo *)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
1083 FreeXid(xid);
1084
1085
1086
1087
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
1099
1100
1101
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
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;
1144
1145 }
1146
1147 cifs_stats_bytes_written(pTcon, total_written);
1148
1149
1150 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1151
1152
1153
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
1168struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1169{
1170 struct cifsFileInfo *open_file = NULL;
1171
1172 read_lock(&GlobalSMBSeslock);
1173
1174
1175
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
1183
1184 cifsFileInfo_get(open_file);
1185 read_unlock(&GlobalSMBSeslock);
1186 return open_file;
1187 }
1188
1189
1190 } else
1191 break;
1192 }
1193 read_unlock(&GlobalSMBSeslock);
1194 return NULL;
1195}
1196#endif
1197
1198struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1199{
1200 struct cifsFileInfo *open_file;
1201 bool any_available = false;
1202 int rc;
1203
1204
1205
1206
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);
1215refind_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
1228 read_unlock(&GlobalSMBSeslock);
1229 return open_file;
1230 }
1231
1232 read_unlock(&GlobalSMBSeslock);
1233
1234 rc = cifs_reopen_file(open_file->pfile, false);
1235 if (!rc) {
1236 if (!open_file->closePend)
1237 return open_file;
1238 else {
1239
1240 read_lock(&GlobalSMBSeslock);
1241 cifsFileInfo_put(open_file);
1242 goto refind_writable;
1243 }
1244 }
1245
1246
1247
1248
1249
1250
1251
1252
1253 cFYI(1, ("wp failed on reopen file"));
1254 read_lock(&GlobalSMBSeslock);
1255
1256
1257 cifsFileInfo_put(open_file);
1258
1259 if (open_file->closePend)
1260 goto refind_writable;
1261
1262
1263
1264
1265
1266
1267
1268 }
1269 }
1270
1271 if (!any_available) {
1272 any_available = true;
1273 goto refind_writable;
1274 }
1275 read_unlock(&GlobalSMBSeslock);
1276 return NULL;
1277}
1278
1279static 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
1308 if (offset > mapping->host->i_size) {
1309 kunmap(page);
1310 return 0;
1311 }
1312
1313
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
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
1337static 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
1366
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
1384
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;
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 }
1405retry:
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
1422
1423
1424
1425
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
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
1461
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
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
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
1496
1497
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
1517
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
1530
1531
1532
1533
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
1546 index = pvec.pages[0]->index + 1;
1547
1548 pagevec_release(&pvec);
1549 }
1550 if (!scanned && !done) {
1551
1552
1553
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
1567static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1568{
1569 int rc = -EFAULT;
1570 int xid;
1571
1572 xid = GetXid();
1573
1574 page_cache_get(page);
1575 if (!PageUptodate(page))
1576 cFYI(1, ("ppw - page not up to date"));
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588 set_page_writeback(page);
1589 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1590 SetPageUptodate(page);
1591 unlock_page(page);
1592 end_page_writeback(page);
1593 page_cache_release(page);
1594 FreeXid(xid);
1595 return rc;
1596}
1597
1598static 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
1622
1623
1624
1625
1626 page_data = kmap(page);
1627 rc = cifs_write(file, page_data + offset, copied, &pos);
1628
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
1651int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1652{
1653 int xid;
1654 int rc = 0;
1655 struct cifsTconInfo *tcon;
1656 struct cifsFileInfo *smbfile =
1657 (struct cifsFileInfo *)file->private_data;
1658 struct inode *inode = file->f_path.dentry->d_inode;
1659
1660 xid = GetXid();
1661
1662 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
1663 dentry->d_name.name, datasync));
1664
1665 rc = filemap_write_and_wait(inode->i_mapping);
1666 if (rc == 0) {
1667 rc = CIFS_I(inode)->write_behind_rc;
1668 CIFS_I(inode)->write_behind_rc = 0;
1669 tcon = CIFS_SB(inode->i_sb)->tcon;
1670 if (!rc && tcon && smbfile &&
1671 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1672 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1673 }
1674
1675 FreeXid(xid);
1676 return rc;
1677}
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711int cifs_flush(struct file *file, fl_owner_t id)
1712{
1713 struct inode *inode = file->f_path.dentry->d_inode;
1714 int rc = 0;
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725 rc = filemap_fdatawrite(inode->i_mapping);
1726
1727 if (!rc) {
1728 rc = CIFS_I(inode)->write_behind_rc;
1729 CIFS_I(inode)->write_behind_rc = 0;
1730 }
1731
1732 cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
1733
1734 return rc;
1735}
1736
1737ssize_t cifs_user_read(struct file *file, char __user *read_data,
1738 size_t read_size, loff_t *poffset)
1739{
1740 int rc = -EACCES;
1741 unsigned int bytes_read = 0;
1742 unsigned int total_read = 0;
1743 unsigned int current_read_size;
1744 struct cifs_sb_info *cifs_sb;
1745 struct cifsTconInfo *pTcon;
1746 int xid;
1747 struct cifsFileInfo *open_file;
1748 char *smb_read_data;
1749 char __user *current_offset;
1750 struct smb_com_read_rsp *pSMBr;
1751
1752 xid = GetXid();
1753 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1754 pTcon = cifs_sb->tcon;
1755
1756 if (file->private_data == NULL) {
1757 rc = -EBADF;
1758 FreeXid(xid);
1759 return rc;
1760 }
1761 open_file = (struct cifsFileInfo *)file->private_data;
1762
1763 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1764 cFYI(1, ("attempting read on write only file instance"));
1765
1766 for (total_read = 0, current_offset = read_data;
1767 read_size > total_read;
1768 total_read += bytes_read, current_offset += bytes_read) {
1769 current_read_size = min_t(const int, read_size - total_read,
1770 cifs_sb->rsize);
1771 rc = -EAGAIN;
1772 smb_read_data = NULL;
1773 while (rc == -EAGAIN) {
1774 int buf_type = CIFS_NO_BUFFER;
1775 if ((open_file->invalidHandle) &&
1776 (!open_file->closePend)) {
1777 rc = cifs_reopen_file(file, true);
1778 if (rc != 0)
1779 break;
1780 }
1781 rc = CIFSSMBRead(xid, pTcon,
1782 open_file->netfid,
1783 current_read_size, *poffset,
1784 &bytes_read, &smb_read_data,
1785 &buf_type);
1786 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1787 if (smb_read_data) {
1788 if (copy_to_user(current_offset,
1789 smb_read_data +
1790 4 +
1791 le16_to_cpu(pSMBr->DataOffset),
1792 bytes_read))
1793 rc = -EFAULT;
1794
1795 if (buf_type == CIFS_SMALL_BUFFER)
1796 cifs_small_buf_release(smb_read_data);
1797 else if (buf_type == CIFS_LARGE_BUFFER)
1798 cifs_buf_release(smb_read_data);
1799 smb_read_data = NULL;
1800 }
1801 }
1802 if (rc || (bytes_read == 0)) {
1803 if (total_read) {
1804 break;
1805 } else {
1806 FreeXid(xid);
1807 return rc;
1808 }
1809 } else {
1810 cifs_stats_bytes_read(pTcon, bytes_read);
1811 *poffset += bytes_read;
1812 }
1813 }
1814 FreeXid(xid);
1815 return total_read;
1816}
1817
1818
1819static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1820 loff_t *poffset)
1821{
1822 int rc = -EACCES;
1823 unsigned int bytes_read = 0;
1824 unsigned int total_read;
1825 unsigned int current_read_size;
1826 struct cifs_sb_info *cifs_sb;
1827 struct cifsTconInfo *pTcon;
1828 int xid;
1829 char *current_offset;
1830 struct cifsFileInfo *open_file;
1831 int buf_type = CIFS_NO_BUFFER;
1832
1833 xid = GetXid();
1834 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1835 pTcon = cifs_sb->tcon;
1836
1837 if (file->private_data == NULL) {
1838 rc = -EBADF;
1839 FreeXid(xid);
1840 return rc;
1841 }
1842 open_file = (struct cifsFileInfo *)file->private_data;
1843
1844 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1845 cFYI(1, ("attempting read on write only file instance"));
1846
1847 for (total_read = 0, current_offset = read_data;
1848 read_size > total_read;
1849 total_read += bytes_read, current_offset += bytes_read) {
1850 current_read_size = min_t(const int, read_size - total_read,
1851 cifs_sb->rsize);
1852
1853
1854 if ((pTcon->ses) &&
1855 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1856 current_read_size = min_t(const int, current_read_size,
1857 pTcon->ses->server->maxBuf - 128);
1858 }
1859 rc = -EAGAIN;
1860 while (rc == -EAGAIN) {
1861 if ((open_file->invalidHandle) &&
1862 (!open_file->closePend)) {
1863 rc = cifs_reopen_file(file, true);
1864 if (rc != 0)
1865 break;
1866 }
1867 rc = CIFSSMBRead(xid, pTcon,
1868 open_file->netfid,
1869 current_read_size, *poffset,
1870 &bytes_read, ¤t_offset,
1871 &buf_type);
1872 }
1873 if (rc || (bytes_read == 0)) {
1874 if (total_read) {
1875 break;
1876 } else {
1877 FreeXid(xid);
1878 return rc;
1879 }
1880 } else {
1881 cifs_stats_bytes_read(pTcon, total_read);
1882 *poffset += bytes_read;
1883 }
1884 }
1885 FreeXid(xid);
1886 return total_read;
1887}
1888
1889int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1890{
1891 struct dentry *dentry = file->f_path.dentry;
1892 int rc, xid;
1893
1894 xid = GetXid();
1895 rc = cifs_revalidate(dentry);
1896 if (rc) {
1897 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1898 FreeXid(xid);
1899 return rc;
1900 }
1901 rc = generic_file_mmap(file, vma);
1902 FreeXid(xid);
1903 return rc;
1904}
1905
1906
1907static void cifs_copy_cache_pages(struct address_space *mapping,
1908 struct list_head *pages, int bytes_read, char *data,
1909 struct pagevec *plru_pvec)
1910{
1911 struct page *page;
1912 char *target;
1913
1914 while (bytes_read > 0) {
1915 if (list_empty(pages))
1916 break;
1917
1918 page = list_entry(pages->prev, struct page, lru);
1919 list_del(&page->lru);
1920
1921 if (add_to_page_cache(page, mapping, page->index,
1922 GFP_KERNEL)) {
1923 page_cache_release(page);
1924 cFYI(1, ("Add page cache failed"));
1925 data += PAGE_CACHE_SIZE;
1926 bytes_read -= PAGE_CACHE_SIZE;
1927 continue;
1928 }
1929
1930 target = kmap_atomic(page, KM_USER0);
1931
1932 if (PAGE_CACHE_SIZE > bytes_read) {
1933 memcpy(target, data, bytes_read);
1934
1935 memset(target + bytes_read, 0,
1936 PAGE_CACHE_SIZE - bytes_read);
1937 bytes_read = 0;
1938 } else {
1939 memcpy(target, data, PAGE_CACHE_SIZE);
1940 bytes_read -= PAGE_CACHE_SIZE;
1941 }
1942 kunmap_atomic(target, KM_USER0);
1943
1944 flush_dcache_page(page);
1945 SetPageUptodate(page);
1946 unlock_page(page);
1947 if (!pagevec_add(plru_pvec, page))
1948 __pagevec_lru_add_file(plru_pvec);
1949 data += PAGE_CACHE_SIZE;
1950 }
1951 return;
1952}
1953
1954static int cifs_readpages(struct file *file, struct address_space *mapping,
1955 struct list_head *page_list, unsigned num_pages)
1956{
1957 int rc = -EACCES;
1958 int xid;
1959 loff_t offset;
1960 struct page *page;
1961 struct cifs_sb_info *cifs_sb;
1962 struct cifsTconInfo *pTcon;
1963 unsigned int bytes_read = 0;
1964 unsigned int read_size, i;
1965 char *smb_read_data = NULL;
1966 struct smb_com_read_rsp *pSMBr;
1967 struct pagevec lru_pvec;
1968 struct cifsFileInfo *open_file;
1969 int buf_type = CIFS_NO_BUFFER;
1970
1971 xid = GetXid();
1972 if (file->private_data == NULL) {
1973 rc = -EBADF;
1974 FreeXid(xid);
1975 return rc;
1976 }
1977 open_file = (struct cifsFileInfo *)file->private_data;
1978 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1979 pTcon = cifs_sb->tcon;
1980
1981 pagevec_init(&lru_pvec, 0);
1982 cFYI(DBG2, ("rpages: num pages %d", num_pages));
1983 for (i = 0; i < num_pages; ) {
1984 unsigned contig_pages;
1985 struct page *tmp_page;
1986 unsigned long expected_index;
1987
1988 if (list_empty(page_list))
1989 break;
1990
1991 page = list_entry(page_list->prev, struct page, lru);
1992 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1993
1994
1995 contig_pages = 0;
1996 expected_index =
1997 list_entry(page_list->prev, struct page, lru)->index;
1998 list_for_each_entry_reverse(tmp_page, page_list, lru) {
1999 if (tmp_page->index == expected_index) {
2000 contig_pages++;
2001 expected_index++;
2002 } else
2003 break;
2004 }
2005 if (contig_pages + i > num_pages)
2006 contig_pages = num_pages - i;
2007
2008
2009
2010
2011 read_size = contig_pages * PAGE_CACHE_SIZE;
2012
2013 read_size = min_t(const unsigned int, read_size,
2014 cifs_sb->rsize & PAGE_CACHE_MASK);
2015 cFYI(DBG2, ("rpages: read size 0x%x contiguous pages %d",
2016 read_size, contig_pages));
2017 rc = -EAGAIN;
2018 while (rc == -EAGAIN) {
2019 if ((open_file->invalidHandle) &&
2020 (!open_file->closePend)) {
2021 rc = cifs_reopen_file(file, true);
2022 if (rc != 0)
2023 break;
2024 }
2025
2026 rc = CIFSSMBRead(xid, pTcon,
2027 open_file->netfid,
2028 read_size, offset,
2029 &bytes_read, &smb_read_data,
2030 &buf_type);
2031
2032 if (rc == -EAGAIN) {
2033 if (smb_read_data) {
2034 if (buf_type == CIFS_SMALL_BUFFER)
2035 cifs_small_buf_release(smb_read_data);
2036 else if (buf_type == CIFS_LARGE_BUFFER)
2037 cifs_buf_release(smb_read_data);
2038 smb_read_data = NULL;
2039 }
2040 }
2041 }
2042 if ((rc < 0) || (smb_read_data == NULL)) {
2043 cFYI(1, ("Read error in readpages: %d", rc));
2044 break;
2045 } else if (bytes_read > 0) {
2046 task_io_account_read(bytes_read);
2047 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2048 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2049 smb_read_data + 4 +
2050 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
2051
2052 i += bytes_read >> PAGE_CACHE_SHIFT;
2053 cifs_stats_bytes_read(pTcon, bytes_read);
2054 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2055 i++;
2056
2057
2058
2059
2060
2061
2062
2063
2064 }
2065 } else {
2066 cFYI(1, ("No bytes read (%d) at offset %lld . "
2067 "Cleaning remaining pages from readahead list",
2068 bytes_read, offset));
2069
2070
2071 break;
2072 }
2073 if (smb_read_data) {
2074 if (buf_type == CIFS_SMALL_BUFFER)
2075 cifs_small_buf_release(smb_read_data);
2076 else if (buf_type == CIFS_LARGE_BUFFER)
2077 cifs_buf_release(smb_read_data);
2078 smb_read_data = NULL;
2079 }
2080 bytes_read = 0;
2081 }
2082
2083 pagevec_lru_add_file(&lru_pvec);
2084
2085
2086 if (smb_read_data) {
2087 if (buf_type == CIFS_SMALL_BUFFER)
2088 cifs_small_buf_release(smb_read_data);
2089 else if (buf_type == CIFS_LARGE_BUFFER)
2090 cifs_buf_release(smb_read_data);
2091 smb_read_data = NULL;
2092 }
2093
2094 FreeXid(xid);
2095 return rc;
2096}
2097
2098static int cifs_readpage_worker(struct file *file, struct page *page,
2099 loff_t *poffset)
2100{
2101 char *read_data;
2102 int rc;
2103
2104 page_cache_get(page);
2105 read_data = kmap(page);
2106
2107
2108 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2109
2110 if (rc < 0)
2111 goto io_error;
2112 else
2113 cFYI(1, ("Bytes read %d", rc));
2114
2115 file->f_path.dentry->d_inode->i_atime =
2116 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2117
2118 if (PAGE_CACHE_SIZE > rc)
2119 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2120
2121 flush_dcache_page(page);
2122 SetPageUptodate(page);
2123 rc = 0;
2124
2125io_error:
2126 kunmap(page);
2127 page_cache_release(page);
2128 return rc;
2129}
2130
2131static int cifs_readpage(struct file *file, struct page *page)
2132{
2133 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2134 int rc = -EACCES;
2135 int xid;
2136
2137 xid = GetXid();
2138
2139 if (file->private_data == NULL) {
2140 rc = -EBADF;
2141 FreeXid(xid);
2142 return rc;
2143 }
2144
2145 cFYI(1, ("readpage %p at offset %d 0x%x\n",
2146 page, (int)offset, (int)offset));
2147
2148 rc = cifs_readpage_worker(file, page, &offset);
2149
2150 unlock_page(page);
2151
2152 FreeXid(xid);
2153 return rc;
2154}
2155
2156static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2157{
2158 struct cifsFileInfo *open_file;
2159
2160 read_lock(&GlobalSMBSeslock);
2161 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2162 if (open_file->closePend)
2163 continue;
2164 if (open_file->pfile &&
2165 ((open_file->pfile->f_flags & O_RDWR) ||
2166 (open_file->pfile->f_flags & O_WRONLY))) {
2167 read_unlock(&GlobalSMBSeslock);
2168 return 1;
2169 }
2170 }
2171 read_unlock(&GlobalSMBSeslock);
2172 return 0;
2173}
2174
2175
2176
2177
2178
2179
2180
2181bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2182{
2183 if (!cifsInode)
2184 return true;
2185
2186 if (is_inode_writable(cifsInode)) {
2187
2188 struct cifs_sb_info *cifs_sb;
2189
2190 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2191 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2192
2193
2194 return true;
2195 }
2196
2197 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2198 return true;
2199
2200 return false;
2201 } else
2202 return true;
2203}
2204
2205static int cifs_write_begin(struct file *file, struct address_space *mapping,
2206 loff_t pos, unsigned len, unsigned flags,
2207 struct page **pagep, void **fsdata)
2208{
2209 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2210 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2211 loff_t page_start = pos & PAGE_MASK;
2212 loff_t i_size;
2213 struct page *page;
2214 int rc = 0;
2215
2216 cFYI(1, ("write_begin from %lld len %d", (long long)pos, len));
2217
2218 page = grab_cache_page_write_begin(mapping, index, flags);
2219 if (!page) {
2220 rc = -ENOMEM;
2221 goto out;
2222 }
2223
2224 if (PageUptodate(page))
2225 goto out;
2226
2227
2228
2229
2230
2231
2232 if (len == PAGE_CACHE_SIZE)
2233 goto out;
2234
2235
2236
2237
2238
2239
2240
2241 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2242 i_size = i_size_read(mapping->host);
2243 if (page_start >= i_size ||
2244 (offset == 0 && (pos + len) >= i_size)) {
2245 zero_user_segments(page, 0, offset,
2246 offset + len,
2247 PAGE_CACHE_SIZE);
2248
2249
2250
2251
2252
2253
2254 SetPageChecked(page);
2255 goto out;
2256 }
2257 }
2258
2259 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2260
2261
2262
2263
2264
2265 cifs_readpage_worker(file, page, &page_start);
2266 } else {
2267
2268
2269
2270
2271 }
2272out:
2273 *pagep = page;
2274 return rc;
2275}
2276
2277static void
2278cifs_oplock_break(struct slow_work *work)
2279{
2280 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2281 oplock_break);
2282 struct inode *inode = cfile->pInode;
2283 struct cifsInodeInfo *cinode = CIFS_I(inode);
2284 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->mnt->mnt_sb);
2285 int rc, waitrc = 0;
2286
2287 if (inode && S_ISREG(inode->i_mode)) {
2288#ifdef CONFIG_CIFS_EXPERIMENTAL
2289 if (cinode->clientCanCacheAll == 0)
2290 break_lease(inode, FMODE_READ);
2291 else if (cinode->clientCanCacheRead == 0)
2292 break_lease(inode, FMODE_WRITE);
2293#endif
2294 rc = filemap_fdatawrite(inode->i_mapping);
2295 if (cinode->clientCanCacheRead == 0) {
2296 waitrc = filemap_fdatawait(inode->i_mapping);
2297 invalidate_remote_inode(inode);
2298 }
2299 if (!rc)
2300 rc = waitrc;
2301 if (rc)
2302 cinode->write_behind_rc = rc;
2303 cFYI(1, ("Oplock flush inode %p rc %d", inode, rc));
2304 }
2305
2306
2307
2308
2309
2310
2311
2312 if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2313 rc = CIFSSMBLock(0, cifs_sb->tcon, cfile->netfid, 0, 0, 0, 0,
2314 LOCKING_ANDX_OPLOCK_RELEASE, false);
2315 cFYI(1, ("Oplock release rc = %d", rc));
2316 }
2317}
2318
2319static int
2320cifs_oplock_break_get(struct slow_work *work)
2321{
2322 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2323 oplock_break);
2324 mntget(cfile->mnt);
2325 cifsFileInfo_get(cfile);
2326 return 0;
2327}
2328
2329static void
2330cifs_oplock_break_put(struct slow_work *work)
2331{
2332 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2333 oplock_break);
2334 mntput(cfile->mnt);
2335 cifsFileInfo_put(cfile);
2336}
2337
2338const struct slow_work_ops cifs_oplock_break_ops = {
2339 .get_ref = cifs_oplock_break_get,
2340 .put_ref = cifs_oplock_break_put,
2341 .execute = cifs_oplock_break,
2342};
2343
2344const struct address_space_operations cifs_addr_ops = {
2345 .readpage = cifs_readpage,
2346 .readpages = cifs_readpages,
2347 .writepage = cifs_writepage,
2348 .writepages = cifs_writepages,
2349 .write_begin = cifs_write_begin,
2350 .write_end = cifs_write_end,
2351 .set_page_dirty = __set_page_dirty_nobuffers,
2352
2353
2354};
2355
2356
2357
2358
2359
2360
2361const struct address_space_operations cifs_addr_ops_smallbuf = {
2362 .readpage = cifs_readpage,
2363 .writepage = cifs_writepage,
2364 .writepages = cifs_writepages,
2365 .write_begin = cifs_write_begin,
2366 .write_end = cifs_write_end,
2367 .set_page_dirty = __set_page_dirty_nobuffers,
2368
2369
2370};
2371