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