]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/cifs/file.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
CIFS: Reduce CONFIG_CIFS_STATS ifdefs
[mirror_ubuntu-artful-kernel.git] / fs / cifs / file.c
1 /*
2 * fs/cifs/file.c
3 *
4 * vfs operations that deal with files
5 *
6 * Copyright (C) International Business Machines Corp., 2002,2003
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 *
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23 #include <linux/fs.h>
24 #include <linux/stat.h>
25 #include <linux/fcntl.h>
26 #include <linux/pagemap.h>
27 #include <linux/pagevec.h>
28 #include <linux/smp_lock.h>
29 #include <asm/div64.h>
30 #include "cifsfs.h"
31 #include "cifspdu.h"
32 #include "cifsglob.h"
33 #include "cifsproto.h"
34 #include "cifs_unicode.h"
35 #include "cifs_debug.h"
36 #include "cifs_fs_sb.h"
37
38 static inline struct cifsFileInfo *cifs_init_private(
39 struct cifsFileInfo *private_data, struct inode *inode,
40 struct file *file, __u16 netfid)
41 {
42 memset(private_data, 0, sizeof(struct cifsFileInfo));
43 private_data->netfid = netfid;
44 private_data->pid = current->tgid;
45 init_MUTEX(&private_data->fh_sem);
46 private_data->pfile = file; /* needed for writepage */
47 private_data->pInode = inode;
48 private_data->invalidHandle = FALSE;
49 private_data->closePend = FALSE;
50
51 return private_data;
52 }
53
54 static inline int cifs_convert_flags(unsigned int flags)
55 {
56 if ((flags & O_ACCMODE) == O_RDONLY)
57 return GENERIC_READ;
58 else if ((flags & O_ACCMODE) == O_WRONLY)
59 return GENERIC_WRITE;
60 else if ((flags & O_ACCMODE) == O_RDWR) {
61 /* GENERIC_ALL is too much permission to request
62 can cause unnecessary access denied on create */
63 /* return GENERIC_ALL; */
64 return (GENERIC_READ | GENERIC_WRITE);
65 }
66
67 return 0x20197;
68 }
69
70 static inline int cifs_get_disposition(unsigned int flags)
71 {
72 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
73 return FILE_CREATE;
74 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
75 return FILE_OVERWRITE_IF;
76 else if ((flags & O_CREAT) == O_CREAT)
77 return FILE_OPEN_IF;
78 else
79 return FILE_OPEN;
80 }
81
82 /* all arguments to this function must be checked for validity in caller */
83 static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
84 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
85 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
86 char *full_path, int xid)
87 {
88 struct timespec temp;
89 int rc;
90
91 /* want handles we can use to read with first
92 in the list so we do not have to walk the
93 list to search for one in prepare_write */
94 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
95 list_add_tail(&pCifsFile->flist,
96 &pCifsInode->openFileList);
97 } else {
98 list_add(&pCifsFile->flist,
99 &pCifsInode->openFileList);
100 }
101 write_unlock(&GlobalSMBSeslock);
102 write_unlock(&file->f_owner.lock);
103 if (pCifsInode->clientCanCacheRead) {
104 /* we have the inode open somewhere else
105 no need to discard cache data */
106 goto client_can_cache;
107 }
108
109 /* BB need same check in cifs_create too? */
110 /* if not oplocked, invalidate inode pages if mtime or file
111 size changed */
112 temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
113 if (timespec_equal(&file->f_dentry->d_inode->i_mtime, &temp) &&
114 (file->f_dentry->d_inode->i_size ==
115 (loff_t)le64_to_cpu(buf->EndOfFile))) {
116 cFYI(1, ("inode unchanged on server"));
117 } else {
118 if (file->f_dentry->d_inode->i_mapping) {
119 /* BB no need to lock inode until after invalidate
120 since namei code should already have it locked? */
121 filemap_fdatawrite(file->f_dentry->d_inode->i_mapping);
122 filemap_fdatawait(file->f_dentry->d_inode->i_mapping);
123 }
124 cFYI(1, ("invalidating remote inode since open detected it "
125 "changed"));
126 invalidate_remote_inode(file->f_dentry->d_inode);
127 }
128
129 client_can_cache:
130 if (pTcon->ses->capabilities & CAP_UNIX)
131 rc = cifs_get_inode_info_unix(&file->f_dentry->d_inode,
132 full_path, inode->i_sb, xid);
133 else
134 rc = cifs_get_inode_info(&file->f_dentry->d_inode,
135 full_path, buf, inode->i_sb, xid);
136
137 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
138 pCifsInode->clientCanCacheAll = TRUE;
139 pCifsInode->clientCanCacheRead = TRUE;
140 cFYI(1, ("Exclusive Oplock granted on inode %p",
141 file->f_dentry->d_inode));
142 } else if ((*oplock & 0xF) == OPLOCK_READ)
143 pCifsInode->clientCanCacheRead = TRUE;
144
145 return rc;
146 }
147
148 int cifs_open(struct inode *inode, struct file *file)
149 {
150 int rc = -EACCES;
151 int xid, oplock;
152 struct cifs_sb_info *cifs_sb;
153 struct cifsTconInfo *pTcon;
154 struct cifsFileInfo *pCifsFile;
155 struct cifsInodeInfo *pCifsInode;
156 struct list_head *tmp;
157 char *full_path = NULL;
158 int desiredAccess;
159 int disposition;
160 __u16 netfid;
161 FILE_ALL_INFO *buf = NULL;
162
163 xid = GetXid();
164
165 cifs_sb = CIFS_SB(inode->i_sb);
166 pTcon = cifs_sb->tcon;
167
168 if (file->f_flags & O_CREAT) {
169 /* search inode for this file and fill in file->private_data */
170 pCifsInode = CIFS_I(file->f_dentry->d_inode);
171 read_lock(&GlobalSMBSeslock);
172 list_for_each(tmp, &pCifsInode->openFileList) {
173 pCifsFile = list_entry(tmp, struct cifsFileInfo,
174 flist);
175 if ((pCifsFile->pfile == NULL) &&
176 (pCifsFile->pid == current->tgid)) {
177 /* mode set in cifs_create */
178
179 /* needed for writepage */
180 pCifsFile->pfile = file;
181
182 file->private_data = pCifsFile;
183 break;
184 }
185 }
186 read_unlock(&GlobalSMBSeslock);
187 if (file->private_data != NULL) {
188 rc = 0;
189 FreeXid(xid);
190 return rc;
191 } else {
192 if (file->f_flags & O_EXCL)
193 cERROR(1, ("could not find file instance for "
194 "new file %p ", file));
195 }
196 }
197
198 down(&inode->i_sb->s_vfs_rename_sem);
199 full_path = build_path_from_dentry(file->f_dentry, cifs_sb);
200 up(&inode->i_sb->s_vfs_rename_sem);
201 if (full_path == NULL) {
202 FreeXid(xid);
203 return -ENOMEM;
204 }
205
206 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
207 inode, file->f_flags, full_path));
208 desiredAccess = cifs_convert_flags(file->f_flags);
209
210 /*********************************************************************
211 * open flag mapping table:
212 *
213 * POSIX Flag CIFS Disposition
214 * ---------- ----------------
215 * O_CREAT FILE_OPEN_IF
216 * O_CREAT | O_EXCL FILE_CREATE
217 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
218 * O_TRUNC FILE_OVERWRITE
219 * none of the above FILE_OPEN
220 *
221 * Note that there is not a direct match between disposition
222 * FILE_SUPERSEDE (ie create whether or not file exists although
223 * O_CREAT | O_TRUNC is similar but truncates the existing
224 * file rather than creating a new file as FILE_SUPERSEDE does
225 * (which uses the attributes / metadata passed in on open call)
226 *?
227 *? O_SYNC is a reasonable match to CIFS writethrough flag
228 *? and the read write flags match reasonably. O_LARGEFILE
229 *? is irrelevant because largefile support is always used
230 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
231 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
232 *********************************************************************/
233
234 disposition = cifs_get_disposition(file->f_flags);
235
236 if (oplockEnabled)
237 oplock = REQ_OPLOCK;
238 else
239 oplock = FALSE;
240
241 /* BB pass O_SYNC flag through on file attributes .. BB */
242
243 /* Also refresh inode by passing in file_info buf returned by SMBOpen
244 and calling get_inode_info with returned buf (at least helps
245 non-Unix server case) */
246
247 /* BB we can not do this if this is the second open of a file
248 and the first handle has writebehind data, we might be
249 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
250 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
251 if (!buf) {
252 rc = -ENOMEM;
253 goto out;
254 }
255 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
256 CREATE_NOT_DIR, &netfid, &oplock, buf,
257 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
258 & CIFS_MOUNT_MAP_SPECIAL_CHR);
259 if (rc) {
260 cFYI(1, ("cifs_open returned 0x%x ", rc));
261 goto out;
262 }
263 file->private_data =
264 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
265 if (file->private_data == NULL) {
266 rc = -ENOMEM;
267 goto out;
268 }
269 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
270 write_lock(&file->f_owner.lock);
271 write_lock(&GlobalSMBSeslock);
272 list_add(&pCifsFile->tlist, &pTcon->openFileList);
273
274 pCifsInode = CIFS_I(file->f_dentry->d_inode);
275 if (pCifsInode) {
276 rc = cifs_open_inode_helper(inode, file, pCifsInode,
277 pCifsFile, pTcon,
278 &oplock, buf, full_path, xid);
279 } else {
280 write_unlock(&GlobalSMBSeslock);
281 write_unlock(&file->f_owner.lock);
282 }
283
284 if (oplock & CIFS_CREATE_ACTION) {
285 /* time to set mode which we can not set earlier due to
286 problems creating new read-only files */
287 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
288 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
289 inode->i_mode,
290 (__u64)-1, (__u64)-1, 0 /* dev */,
291 cifs_sb->local_nls,
292 cifs_sb->mnt_cifs_flags &
293 CIFS_MOUNT_MAP_SPECIAL_CHR);
294 } else {
295 /* BB implement via Windows security descriptors eg
296 CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
297 -1, -1, local_nls);
298 in the meantime could set r/o dos attribute when
299 perms are eg: mode & 0222 == 0 */
300 }
301 }
302
303 out:
304 kfree(buf);
305 kfree(full_path);
306 FreeXid(xid);
307 return rc;
308 }
309
310 /* Try to reaquire byte range locks that were released when session */
311 /* to server was lost */
312 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
313 {
314 int rc = 0;
315
316 /* BB list all locks open on this file and relock */
317
318 return rc;
319 }
320
321 static int cifs_reopen_file(struct inode *inode, struct file *file,
322 int can_flush)
323 {
324 int rc = -EACCES;
325 int xid, oplock;
326 struct cifs_sb_info *cifs_sb;
327 struct cifsTconInfo *pTcon;
328 struct cifsFileInfo *pCifsFile;
329 struct cifsInodeInfo *pCifsInode;
330 char *full_path = NULL;
331 int desiredAccess;
332 int disposition = FILE_OPEN;
333 __u16 netfid;
334
335 if (inode == NULL)
336 return -EBADF;
337 if (file->private_data) {
338 pCifsFile = (struct cifsFileInfo *)file->private_data;
339 } else
340 return -EBADF;
341
342 xid = GetXid();
343 down(&pCifsFile->fh_sem);
344 if (pCifsFile->invalidHandle == FALSE) {
345 up(&pCifsFile->fh_sem);
346 FreeXid(xid);
347 return 0;
348 }
349
350 if (file->f_dentry == NULL) {
351 up(&pCifsFile->fh_sem);
352 cFYI(1, ("failed file reopen, no valid name if dentry freed"));
353 FreeXid(xid);
354 return -EBADF;
355 }
356 cifs_sb = CIFS_SB(inode->i_sb);
357 pTcon = cifs_sb->tcon;
358 /* can not grab rename sem here because various ops, including
359 those that already have the rename sem can end up causing writepage
360 to get called and if the server was down that means we end up here,
361 and we can never tell if the caller already has the rename_sem */
362 full_path = build_path_from_dentry(file->f_dentry, cifs_sb);
363 if (full_path == NULL) {
364 up(&pCifsFile->fh_sem);
365 FreeXid(xid);
366 return -ENOMEM;
367 }
368
369 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
370 inode, file->f_flags,full_path));
371 desiredAccess = cifs_convert_flags(file->f_flags);
372
373 if (oplockEnabled)
374 oplock = REQ_OPLOCK;
375 else
376 oplock = FALSE;
377
378 /* Can not refresh inode by passing in file_info buf to be returned
379 by SMBOpen and then calling get_inode_info with returned buf
380 since file might have write behind data that needs to be flushed
381 and server version of file size can be stale. If we knew for sure
382 that inode was not dirty locally we could do this */
383
384 /* buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
385 if (buf == 0) {
386 up(&pCifsFile->fh_sem);
387 kfree(full_path);
388 FreeXid(xid);
389 return -ENOMEM;
390 } */
391 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
392 CREATE_NOT_DIR, &netfid, &oplock, NULL,
393 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
394 CIFS_MOUNT_MAP_SPECIAL_CHR);
395 if (rc) {
396 up(&pCifsFile->fh_sem);
397 cFYI(1, ("cifs_open returned 0x%x ", rc));
398 cFYI(1, ("oplock: %d ", oplock));
399 } else {
400 pCifsFile->netfid = netfid;
401 pCifsFile->invalidHandle = FALSE;
402 up(&pCifsFile->fh_sem);
403 pCifsInode = CIFS_I(inode);
404 if (pCifsInode) {
405 if (can_flush) {
406 filemap_fdatawrite(inode->i_mapping);
407 filemap_fdatawait(inode->i_mapping);
408 /* temporarily disable caching while we
409 go to server to get inode info */
410 pCifsInode->clientCanCacheAll = FALSE;
411 pCifsInode->clientCanCacheRead = FALSE;
412 if (pTcon->ses->capabilities & CAP_UNIX)
413 rc = cifs_get_inode_info_unix(&inode,
414 full_path, inode->i_sb, xid);
415 else
416 rc = cifs_get_inode_info(&inode,
417 full_path, NULL, inode->i_sb,
418 xid);
419 } /* else we are writing out data to server already
420 and could deadlock if we tried to flush data, and
421 since we do not know if we have data that would
422 invalidate the current end of file on the server
423 we can not go to the server to get the new inod
424 info */
425 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
426 pCifsInode->clientCanCacheAll = TRUE;
427 pCifsInode->clientCanCacheRead = TRUE;
428 cFYI(1, ("Exclusive Oplock granted on inode %p",
429 file->f_dentry->d_inode));
430 } else if ((oplock & 0xF) == OPLOCK_READ) {
431 pCifsInode->clientCanCacheRead = TRUE;
432 pCifsInode->clientCanCacheAll = FALSE;
433 } else {
434 pCifsInode->clientCanCacheRead = FALSE;
435 pCifsInode->clientCanCacheAll = FALSE;
436 }
437 cifs_relock_file(pCifsFile);
438 }
439 }
440
441 kfree(full_path);
442 FreeXid(xid);
443 return rc;
444 }
445
446 int cifs_close(struct inode *inode, struct file *file)
447 {
448 int rc = 0;
449 int xid;
450 struct cifs_sb_info *cifs_sb;
451 struct cifsTconInfo *pTcon;
452 struct cifsFileInfo *pSMBFile =
453 (struct cifsFileInfo *)file->private_data;
454
455 xid = GetXid();
456
457 cifs_sb = CIFS_SB(inode->i_sb);
458 pTcon = cifs_sb->tcon;
459 if (pSMBFile) {
460 pSMBFile->closePend = TRUE;
461 write_lock(&file->f_owner.lock);
462 if (pTcon) {
463 /* no sense reconnecting to close a file that is
464 already closed */
465 if (pTcon->tidStatus != CifsNeedReconnect) {
466 write_unlock(&file->f_owner.lock);
467 rc = CIFSSMBClose(xid, pTcon,
468 pSMBFile->netfid);
469 write_lock(&file->f_owner.lock);
470 }
471 }
472 write_lock(&GlobalSMBSeslock);
473 list_del(&pSMBFile->flist);
474 list_del(&pSMBFile->tlist);
475 write_unlock(&GlobalSMBSeslock);
476 write_unlock(&file->f_owner.lock);
477 kfree(pSMBFile->search_resume_name);
478 kfree(file->private_data);
479 file->private_data = NULL;
480 } else
481 rc = -EBADF;
482
483 if (list_empty(&(CIFS_I(inode)->openFileList))) {
484 cFYI(1, ("closing last open instance for inode %p", inode));
485 /* if the file is not open we do not know if we can cache info
486 on this inode, much less write behind and read ahead */
487 CIFS_I(inode)->clientCanCacheRead = FALSE;
488 CIFS_I(inode)->clientCanCacheAll = FALSE;
489 }
490 if ((rc ==0) && CIFS_I(inode)->write_behind_rc)
491 rc = CIFS_I(inode)->write_behind_rc;
492 FreeXid(xid);
493 return rc;
494 }
495
496 int cifs_closedir(struct inode *inode, struct file *file)
497 {
498 int rc = 0;
499 int xid;
500 struct cifsFileInfo *pCFileStruct =
501 (struct cifsFileInfo *)file->private_data;
502 char *ptmp;
503
504 cFYI(1, ("Closedir inode = 0x%p with ", inode));
505
506 xid = GetXid();
507
508 if (pCFileStruct) {
509 struct cifsTconInfo *pTcon;
510 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_dentry->d_sb);
511
512 pTcon = cifs_sb->tcon;
513
514 cFYI(1, ("Freeing private data in close dir"));
515 if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
516 (pCFileStruct->invalidHandle == FALSE)) {
517 pCFileStruct->invalidHandle = TRUE;
518 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
519 cFYI(1, ("Closing uncompleted readdir with rc %d",
520 rc));
521 /* not much we can do if it fails anyway, ignore rc */
522 rc = 0;
523 }
524 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
525 if (ptmp) {
526 /* BB removeme BB */ cFYI(1, ("freeing smb buf in srch struct in closedir"));
527 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
528 cifs_buf_release(ptmp);
529 }
530 ptmp = pCFileStruct->search_resume_name;
531 if (ptmp) {
532 /* BB removeme BB */ cFYI(1, ("freeing resume name in closedir"));
533 pCFileStruct->search_resume_name = NULL;
534 kfree(ptmp);
535 }
536 kfree(file->private_data);
537 file->private_data = NULL;
538 }
539 /* BB can we lock the filestruct while this is going on? */
540 FreeXid(xid);
541 return rc;
542 }
543
544 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
545 {
546 int rc, xid;
547 __u32 lockType = LOCKING_ANDX_LARGE_FILES;
548 __u32 numLock = 0;
549 __u32 numUnlock = 0;
550 __u64 length;
551 int wait_flag = FALSE;
552 struct cifs_sb_info *cifs_sb;
553 struct cifsTconInfo *pTcon;
554
555 length = 1 + pfLock->fl_end - pfLock->fl_start;
556 rc = -EACCES;
557 xid = GetXid();
558
559 cFYI(1, ("Lock parm: 0x%x flockflags: "
560 "0x%x flocktype: 0x%x start: %lld end: %lld",
561 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
562 pfLock->fl_end));
563
564 if (pfLock->fl_flags & FL_POSIX)
565 cFYI(1, ("Posix "));
566 if (pfLock->fl_flags & FL_FLOCK)
567 cFYI(1, ("Flock "));
568 if (pfLock->fl_flags & FL_SLEEP) {
569 cFYI(1, ("Blocking lock "));
570 wait_flag = TRUE;
571 }
572 if (pfLock->fl_flags & FL_ACCESS)
573 cFYI(1, ("Process suspended by mandatory locking - "
574 "not implemented yet "));
575 if (pfLock->fl_flags & FL_LEASE)
576 cFYI(1, ("Lease on file - not implemented yet"));
577 if (pfLock->fl_flags &
578 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
579 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
580
581 if (pfLock->fl_type == F_WRLCK) {
582 cFYI(1, ("F_WRLCK "));
583 numLock = 1;
584 } else if (pfLock->fl_type == F_UNLCK) {
585 cFYI(1, ("F_UNLCK "));
586 numUnlock = 1;
587 } else if (pfLock->fl_type == F_RDLCK) {
588 cFYI(1, ("F_RDLCK "));
589 lockType |= LOCKING_ANDX_SHARED_LOCK;
590 numLock = 1;
591 } else if (pfLock->fl_type == F_EXLCK) {
592 cFYI(1, ("F_EXLCK "));
593 numLock = 1;
594 } else if (pfLock->fl_type == F_SHLCK) {
595 cFYI(1, ("F_SHLCK "));
596 lockType |= LOCKING_ANDX_SHARED_LOCK;
597 numLock = 1;
598 } else
599 cFYI(1, ("Unknown type of lock "));
600
601 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
602 pTcon = cifs_sb->tcon;
603
604 if (file->private_data == NULL) {
605 FreeXid(xid);
606 return -EBADF;
607 }
608
609 if (IS_GETLK(cmd)) {
610 rc = CIFSSMBLock(xid, pTcon,
611 ((struct cifsFileInfo *)file->
612 private_data)->netfid,
613 length,
614 pfLock->fl_start, 0, 1, lockType,
615 0 /* wait flag */ );
616 if (rc == 0) {
617 rc = CIFSSMBLock(xid, pTcon,
618 ((struct cifsFileInfo *) file->
619 private_data)->netfid,
620 length,
621 pfLock->fl_start, 1 /* numUnlock */ ,
622 0 /* numLock */ , lockType,
623 0 /* wait flag */ );
624 pfLock->fl_type = F_UNLCK;
625 if (rc != 0)
626 cERROR(1, ("Error unlocking previously locked "
627 "range %d during test of lock ",
628 rc));
629 rc = 0;
630
631 } else {
632 /* if rc == ERR_SHARING_VIOLATION ? */
633 rc = 0; /* do not change lock type to unlock
634 since range in use */
635 }
636
637 FreeXid(xid);
638 return rc;
639 }
640
641 rc = CIFSSMBLock(xid, pTcon,
642 ((struct cifsFileInfo *) file->private_data)->
643 netfid, length,
644 pfLock->fl_start, numUnlock, numLock, lockType,
645 wait_flag);
646 if (rc == 0 && (pfLock->fl_flags & FL_POSIX))
647 posix_lock_file_wait(file, pfLock);
648 FreeXid(xid);
649 return rc;
650 }
651
652 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
653 size_t write_size, loff_t *poffset)
654 {
655 int rc = 0;
656 unsigned int bytes_written = 0;
657 unsigned int total_written;
658 struct cifs_sb_info *cifs_sb;
659 struct cifsTconInfo *pTcon;
660 int xid, long_op;
661 struct cifsFileInfo *open_file;
662
663 if (file->f_dentry == NULL)
664 return -EBADF;
665
666 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
667 if (cifs_sb == NULL)
668 return -EBADF;
669
670 pTcon = cifs_sb->tcon;
671
672 /* cFYI(1,
673 (" write %d bytes to offset %lld of %s", write_size,
674 *poffset, file->f_dentry->d_name.name)); */
675
676 if (file->private_data == NULL)
677 return -EBADF;
678 else
679 open_file = (struct cifsFileInfo *) file->private_data;
680
681 xid = GetXid();
682 if (file->f_dentry->d_inode == NULL) {
683 FreeXid(xid);
684 return -EBADF;
685 }
686
687 if (*poffset > file->f_dentry->d_inode->i_size)
688 long_op = 2; /* writes past end of file can take a long time */
689 else
690 long_op = 1;
691
692 for (total_written = 0; write_size > total_written;
693 total_written += bytes_written) {
694 rc = -EAGAIN;
695 while (rc == -EAGAIN) {
696 if (file->private_data == NULL) {
697 /* file has been closed on us */
698 FreeXid(xid);
699 /* if we have gotten here we have written some data
700 and blocked, and the file has been freed on us while
701 we blocked so return what we managed to write */
702 return total_written;
703 }
704 if (open_file->closePend) {
705 FreeXid(xid);
706 if (total_written)
707 return total_written;
708 else
709 return -EBADF;
710 }
711 if (open_file->invalidHandle) {
712 if ((file->f_dentry == NULL) ||
713 (file->f_dentry->d_inode == NULL)) {
714 FreeXid(xid);
715 return total_written;
716 }
717 /* we could deadlock if we called
718 filemap_fdatawait from here so tell
719 reopen_file not to flush data to server
720 now */
721 rc = cifs_reopen_file(file->f_dentry->d_inode,
722 file, FALSE);
723 if (rc != 0)
724 break;
725 }
726
727 rc = CIFSSMBWrite(xid, pTcon,
728 open_file->netfid,
729 min_t(const int, cifs_sb->wsize,
730 write_size - total_written),
731 *poffset, &bytes_written,
732 NULL, write_data + total_written, long_op);
733 }
734 if (rc || (bytes_written == 0)) {
735 if (total_written)
736 break;
737 else {
738 FreeXid(xid);
739 return rc;
740 }
741 } else
742 *poffset += bytes_written;
743 long_op = FALSE; /* subsequent writes fast -
744 15 seconds is plenty */
745 }
746
747 cifs_stats_bytes_written(pTcon, total_written);
748
749 /* since the write may have blocked check these pointers again */
750 if (file->f_dentry) {
751 if (file->f_dentry->d_inode) {
752 struct inode *inode = file->f_dentry->d_inode;
753 inode->i_ctime = inode->i_mtime =
754 current_fs_time(inode->i_sb);
755 if (total_written > 0) {
756 if (*poffset > file->f_dentry->d_inode->i_size)
757 i_size_write(file->f_dentry->d_inode,
758 *poffset);
759 }
760 mark_inode_dirty_sync(file->f_dentry->d_inode);
761 }
762 }
763 FreeXid(xid);
764 return total_written;
765 }
766
767 static ssize_t cifs_write(struct file *file, const char *write_data,
768 size_t write_size, loff_t *poffset)
769 {
770 int rc = 0;
771 unsigned int bytes_written = 0;
772 unsigned int total_written;
773 struct cifs_sb_info *cifs_sb;
774 struct cifsTconInfo *pTcon;
775 int xid, long_op;
776 struct cifsFileInfo *open_file;
777
778 if (file->f_dentry == NULL)
779 return -EBADF;
780
781 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
782 if (cifs_sb == NULL)
783 return -EBADF;
784
785 pTcon = cifs_sb->tcon;
786
787 cFYI(1,(" write %d bytes to offset %lld of %s", write_size,
788 *poffset, file->f_dentry->d_name.name)); /* BB removeme BB */
789
790 if (file->private_data == NULL)
791 return -EBADF;
792 else
793 open_file = (struct cifsFileInfo *)file->private_data;
794
795 xid = GetXid();
796 if (file->f_dentry->d_inode == NULL) {
797 FreeXid(xid);
798 return -EBADF;
799 }
800
801 if (*poffset > file->f_dentry->d_inode->i_size)
802 long_op = 2; /* writes past end of file can take a long time */
803 else
804 long_op = 1;
805
806 for (total_written = 0; write_size > total_written;
807 total_written += bytes_written) {
808 rc = -EAGAIN;
809 while (rc == -EAGAIN) {
810 if (file->private_data == NULL) {
811 /* file has been closed on us */
812 FreeXid(xid);
813 /* if we have gotten here we have written some data
814 and blocked, and the file has been freed on us
815 while we blocked so return what we managed to
816 write */
817 return total_written;
818 }
819 if (open_file->closePend) {
820 FreeXid(xid);
821 if (total_written)
822 return total_written;
823 else
824 return -EBADF;
825 }
826 if (open_file->invalidHandle) {
827 if ((file->f_dentry == NULL) ||
828 (file->f_dentry->d_inode == NULL)) {
829 FreeXid(xid);
830 return total_written;
831 }
832 /* we could deadlock if we called
833 filemap_fdatawait from here so tell
834 reopen_file not to flush data to
835 server now */
836 rc = cifs_reopen_file(file->f_dentry->d_inode,
837 file, FALSE);
838 if (rc != 0)
839 break;
840 }
841 #ifdef CONFIG_CIFS_EXPERIMENTAL
842 /* BB FIXME We can not sign across two buffers yet */
843 if((experimEnabled) && ((pTcon->ses->server->secMode &
844 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) == 0)) {
845 rc = CIFSSMBWrite2(xid, pTcon,
846 open_file->netfid,
847 min_t(const int, cifs_sb->wsize,
848 write_size - total_written),
849 *poffset, &bytes_written,
850 write_data + total_written,
851 long_op);
852 } else
853 /* BB FIXME fixup indentation of line below */
854 #endif
855 rc = CIFSSMBWrite(xid, pTcon,
856 open_file->netfid,
857 min_t(const int, cifs_sb->wsize,
858 write_size - total_written),
859 *poffset, &bytes_written,
860 write_data + total_written, NULL, long_op);
861 }
862 if (rc || (bytes_written == 0)) {
863 if (total_written)
864 break;
865 else {
866 FreeXid(xid);
867 return rc;
868 }
869 } else
870 *poffset += bytes_written;
871 long_op = FALSE; /* subsequent writes fast -
872 15 seconds is plenty */
873 }
874
875 cifs_stats_bytes_written(pTcon, total_written);
876
877 /* since the write may have blocked check these pointers again */
878 if (file->f_dentry) {
879 if (file->f_dentry->d_inode) {
880 file->f_dentry->d_inode->i_ctime =
881 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
882 if (total_written > 0) {
883 if (*poffset > file->f_dentry->d_inode->i_size)
884 i_size_write(file->f_dentry->d_inode,
885 *poffset);
886 }
887 mark_inode_dirty_sync(file->f_dentry->d_inode);
888 }
889 }
890 FreeXid(xid);
891 return total_written;
892 }
893
894 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
895 {
896 struct address_space *mapping = page->mapping;
897 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
898 char *write_data;
899 int rc = -EFAULT;
900 int bytes_written = 0;
901 struct cifs_sb_info *cifs_sb;
902 struct cifsTconInfo *pTcon;
903 struct inode *inode;
904 struct cifsInodeInfo *cifsInode;
905 struct cifsFileInfo *open_file = NULL;
906 struct list_head *tmp;
907 struct list_head *tmp1;
908
909 if (!mapping || !mapping->host)
910 return -EFAULT;
911
912 inode = page->mapping->host;
913 cifs_sb = CIFS_SB(inode->i_sb);
914 pTcon = cifs_sb->tcon;
915
916 offset += (loff_t)from;
917 write_data = kmap(page);
918 write_data += from;
919
920 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
921 kunmap(page);
922 return -EIO;
923 }
924
925 /* racing with truncate? */
926 if (offset > mapping->host->i_size) {
927 kunmap(page);
928 return 0; /* don't care */
929 }
930
931 /* check to make sure that we are not extending the file */
932 if (mapping->host->i_size - offset < (loff_t)to)
933 to = (unsigned)(mapping->host->i_size - offset);
934
935 cifsInode = CIFS_I(mapping->host);
936 read_lock(&GlobalSMBSeslock);
937 /* BB we should start at the end */
938 list_for_each_safe(tmp, tmp1, &cifsInode->openFileList) {
939 open_file = list_entry(tmp, struct cifsFileInfo, flist);
940 if (open_file->closePend)
941 continue;
942 /* We check if file is open for writing first */
943 if ((open_file->pfile) &&
944 ((open_file->pfile->f_flags & O_RDWR) ||
945 (open_file->pfile->f_flags & O_WRONLY))) {
946 read_unlock(&GlobalSMBSeslock);
947 bytes_written = cifs_write(open_file->pfile,
948 write_data, to-from,
949 &offset);
950 read_lock(&GlobalSMBSeslock);
951 /* Does mm or vfs already set times? */
952 inode->i_atime =
953 inode->i_mtime = current_fs_time(inode->i_sb);
954 if ((bytes_written > 0) && (offset)) {
955 rc = 0;
956 } else if (bytes_written < 0) {
957 if (rc == -EBADF) {
958 /* have seen a case in which kernel seemed to
959 have closed/freed a file even with writes
960 active so we might as well see if there are
961 other file structs to try for the same
962 inode before giving up */
963 continue;
964 } else
965 rc = bytes_written;
966 }
967 break; /* now that we found a valid file handle and
968 tried to write to it we are done, no sense
969 continuing to loop looking for another */
970 }
971 if (tmp->next == NULL) {
972 cFYI(1, ("File instance %p removed", tmp));
973 break;
974 }
975 }
976 read_unlock(&GlobalSMBSeslock);
977 if (open_file == NULL) {
978 cFYI(1, ("No writeable filehandles for inode"));
979 rc = -EIO;
980 }
981
982 kunmap(page);
983 return rc;
984 }
985
986 #if 0
987 static int cifs_writepages(struct address_space *mapping,
988 struct writeback_control *wbc)
989 {
990 int rc = -EFAULT;
991 int xid;
992
993 xid = GetXid();
994
995 /* Find contiguous pages then iterate through repeating
996 call 16K write then Setpageuptodate or if LARGE_WRITE_X
997 support then send larger writes via kevec so as to eliminate
998 a memcpy */
999 FreeXid(xid);
1000 return rc;
1001 }
1002 #endif
1003
1004 static int cifs_writepage(struct page* page, struct writeback_control *wbc)
1005 {
1006 int rc = -EFAULT;
1007 int xid;
1008
1009 xid = GetXid();
1010 /* BB add check for wbc flags */
1011 page_cache_get(page);
1012 if (!PageUptodate(page)) {
1013 cFYI(1, ("ppw - page not up to date"));
1014 }
1015
1016 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1017 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1018 unlock_page(page);
1019 page_cache_release(page);
1020 FreeXid(xid);
1021 return rc;
1022 }
1023
1024 static int cifs_commit_write(struct file *file, struct page *page,
1025 unsigned offset, unsigned to)
1026 {
1027 int xid;
1028 int rc = 0;
1029 struct inode *inode = page->mapping->host;
1030 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1031 char *page_data;
1032
1033 xid = GetXid();
1034 cFYI(1, ("commit write for page %p up to position %lld for %d",
1035 page, position, to));
1036 if (position > inode->i_size) {
1037 i_size_write(inode, position);
1038 /* if (file->private_data == NULL) {
1039 rc = -EBADF;
1040 } else {
1041 open_file = (struct cifsFileInfo *)file->private_data;
1042 cifs_sb = CIFS_SB(inode->i_sb);
1043 rc = -EAGAIN;
1044 while (rc == -EAGAIN) {
1045 if ((open_file->invalidHandle) &&
1046 (!open_file->closePend)) {
1047 rc = cifs_reopen_file(
1048 file->f_dentry->d_inode, file);
1049 if (rc != 0)
1050 break;
1051 }
1052 if (!open_file->closePend) {
1053 rc = CIFSSMBSetFileSize(xid,
1054 cifs_sb->tcon, position,
1055 open_file->netfid,
1056 open_file->pid, FALSE);
1057 } else {
1058 rc = -EBADF;
1059 break;
1060 }
1061 }
1062 cFYI(1, (" SetEOF (commit write) rc = %d", rc));
1063 } */
1064 }
1065 if (!PageUptodate(page)) {
1066 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1067 /* can not rely on (or let) writepage write this data */
1068 if (to < offset) {
1069 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1070 offset, to));
1071 FreeXid(xid);
1072 return rc;
1073 }
1074 /* this is probably better than directly calling
1075 partialpage_write since in this function the file handle is
1076 known which we might as well leverage */
1077 /* BB check if anything else missing out of ppw
1078 such as updating last write time */
1079 page_data = kmap(page);
1080 rc = cifs_write(file, page_data + offset, to-offset,
1081 &position);
1082 if (rc > 0)
1083 rc = 0;
1084 /* else if (rc < 0) should we set writebehind rc? */
1085 kunmap(page);
1086 } else {
1087 set_page_dirty(page);
1088 }
1089
1090 FreeXid(xid);
1091 return rc;
1092 }
1093
1094 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1095 {
1096 int xid;
1097 int rc = 0;
1098 struct inode *inode = file->f_dentry->d_inode;
1099
1100 xid = GetXid();
1101
1102 cFYI(1, ("Sync file - name: %s datasync: 0x%x ",
1103 dentry->d_name.name, datasync));
1104
1105 rc = filemap_fdatawrite(inode->i_mapping);
1106 if (rc == 0)
1107 CIFS_I(inode)->write_behind_rc = 0;
1108 FreeXid(xid);
1109 return rc;
1110 }
1111
1112 /* static int cifs_sync_page(struct page *page)
1113 {
1114 struct address_space *mapping;
1115 struct inode *inode;
1116 unsigned long index = page->index;
1117 unsigned int rpages = 0;
1118 int rc = 0;
1119
1120 cFYI(1, ("sync page %p",page));
1121 mapping = page->mapping;
1122 if (!mapping)
1123 return 0;
1124 inode = mapping->host;
1125 if (!inode)
1126 return 0; */
1127
1128 /* fill in rpages then
1129 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1130
1131 /* cFYI(1, ("rpages is %d for sync page of Index %ld ", rpages, index));
1132
1133 if (rc < 0)
1134 return rc;
1135 return 0;
1136 } */
1137
1138 /*
1139 * As file closes, flush all cached write data for this inode checking
1140 * for write behind errors.
1141 */
1142 int cifs_flush(struct file *file)
1143 {
1144 struct inode * inode = file->f_dentry->d_inode;
1145 int rc = 0;
1146
1147 /* Rather than do the steps manually:
1148 lock the inode for writing
1149 loop through pages looking for write behind data (dirty pages)
1150 coalesce into contiguous 16K (or smaller) chunks to write to server
1151 send to server (prefer in parallel)
1152 deal with writebehind errors
1153 unlock inode for writing
1154 filemapfdatawrite appears easier for the time being */
1155
1156 rc = filemap_fdatawrite(inode->i_mapping);
1157 if (!rc) /* reset wb rc if we were able to write out dirty pages */
1158 CIFS_I(inode)->write_behind_rc = 0;
1159
1160 cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
1161
1162 return rc;
1163 }
1164
1165 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1166 size_t read_size, loff_t *poffset)
1167 {
1168 int rc = -EACCES;
1169 unsigned int bytes_read = 0;
1170 unsigned int total_read = 0;
1171 unsigned int current_read_size;
1172 struct cifs_sb_info *cifs_sb;
1173 struct cifsTconInfo *pTcon;
1174 int xid;
1175 struct cifsFileInfo *open_file;
1176 char *smb_read_data;
1177 char __user *current_offset;
1178 struct smb_com_read_rsp *pSMBr;
1179
1180 xid = GetXid();
1181 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1182 pTcon = cifs_sb->tcon;
1183
1184 if (file->private_data == NULL) {
1185 FreeXid(xid);
1186 return -EBADF;
1187 }
1188 open_file = (struct cifsFileInfo *)file->private_data;
1189
1190 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1191 cFYI(1, ("attempting read on write only file instance"));
1192 }
1193 for (total_read = 0, current_offset = read_data;
1194 read_size > total_read;
1195 total_read += bytes_read, current_offset += bytes_read) {
1196 current_read_size = min_t(const int, read_size - total_read,
1197 cifs_sb->rsize);
1198 rc = -EAGAIN;
1199 smb_read_data = NULL;
1200 while (rc == -EAGAIN) {
1201 if ((open_file->invalidHandle) &&
1202 (!open_file->closePend)) {
1203 rc = cifs_reopen_file(file->f_dentry->d_inode,
1204 file, TRUE);
1205 if (rc != 0)
1206 break;
1207 }
1208
1209 rc = CIFSSMBRead(xid, pTcon,
1210 open_file->netfid,
1211 current_read_size, *poffset,
1212 &bytes_read, &smb_read_data);
1213
1214 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1215 if (copy_to_user(current_offset,
1216 smb_read_data + 4 /* RFC1001 hdr */
1217 + le16_to_cpu(pSMBr->DataOffset),
1218 bytes_read)) {
1219 rc = -EFAULT;
1220 FreeXid(xid);
1221 return rc;
1222 }
1223 if (smb_read_data) {
1224 cifs_buf_release(smb_read_data);
1225 smb_read_data = NULL;
1226 }
1227 }
1228 if (rc || (bytes_read == 0)) {
1229 if (total_read) {
1230 break;
1231 } else {
1232 FreeXid(xid);
1233 return rc;
1234 }
1235 } else {
1236 cifs_stats_bytes_read(pTcon, bytes_read);
1237 *poffset += bytes_read;
1238 }
1239 }
1240 FreeXid(xid);
1241 return total_read;
1242 }
1243
1244
1245 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1246 loff_t *poffset)
1247 {
1248 int rc = -EACCES;
1249 unsigned int bytes_read = 0;
1250 unsigned int total_read;
1251 unsigned int current_read_size;
1252 struct cifs_sb_info *cifs_sb;
1253 struct cifsTconInfo *pTcon;
1254 int xid;
1255 char *current_offset;
1256 struct cifsFileInfo *open_file;
1257
1258 xid = GetXid();
1259 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1260 pTcon = cifs_sb->tcon;
1261
1262 if (file->private_data == NULL) {
1263 FreeXid(xid);
1264 return -EBADF;
1265 }
1266 open_file = (struct cifsFileInfo *)file->private_data;
1267
1268 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1269 cFYI(1, ("attempting read on write only file instance"));
1270
1271 for (total_read = 0, current_offset = read_data;
1272 read_size > total_read;
1273 total_read += bytes_read, current_offset += bytes_read) {
1274 current_read_size = min_t(const int, read_size - total_read,
1275 cifs_sb->rsize);
1276 rc = -EAGAIN;
1277 while (rc == -EAGAIN) {
1278 if ((open_file->invalidHandle) &&
1279 (!open_file->closePend)) {
1280 rc = cifs_reopen_file(file->f_dentry->d_inode,
1281 file, TRUE);
1282 if (rc != 0)
1283 break;
1284 }
1285
1286 rc = CIFSSMBRead(xid, pTcon,
1287 open_file->netfid,
1288 current_read_size, *poffset,
1289 &bytes_read, &current_offset);
1290 }
1291 if (rc || (bytes_read == 0)) {
1292 if (total_read) {
1293 break;
1294 } else {
1295 FreeXid(xid);
1296 return rc;
1297 }
1298 } else {
1299 cifs_stats_bytes_read(pTcon, total_read);
1300 *poffset += bytes_read;
1301 }
1302 }
1303 FreeXid(xid);
1304 return total_read;
1305 }
1306
1307 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1308 {
1309 struct dentry *dentry = file->f_dentry;
1310 int rc, xid;
1311
1312 xid = GetXid();
1313 rc = cifs_revalidate(dentry);
1314 if (rc) {
1315 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1316 FreeXid(xid);
1317 return rc;
1318 }
1319 rc = generic_file_mmap(file, vma);
1320 FreeXid(xid);
1321 return rc;
1322 }
1323
1324
1325 static void cifs_copy_cache_pages(struct address_space *mapping,
1326 struct list_head *pages, int bytes_read, char *data,
1327 struct pagevec *plru_pvec)
1328 {
1329 struct page *page;
1330 char *target;
1331
1332 while (bytes_read > 0) {
1333 if (list_empty(pages))
1334 break;
1335
1336 page = list_entry(pages->prev, struct page, lru);
1337 list_del(&page->lru);
1338
1339 if (add_to_page_cache(page, mapping, page->index,
1340 GFP_KERNEL)) {
1341 page_cache_release(page);
1342 cFYI(1, ("Add page cache failed"));
1343 data += PAGE_CACHE_SIZE;
1344 bytes_read -= PAGE_CACHE_SIZE;
1345 continue;
1346 }
1347
1348 target = kmap_atomic(page,KM_USER0);
1349
1350 if (PAGE_CACHE_SIZE > bytes_read) {
1351 memcpy(target, data, bytes_read);
1352 /* zero the tail end of this partial page */
1353 memset(target + bytes_read, 0,
1354 PAGE_CACHE_SIZE - bytes_read);
1355 bytes_read = 0;
1356 } else {
1357 memcpy(target, data, PAGE_CACHE_SIZE);
1358 bytes_read -= PAGE_CACHE_SIZE;
1359 }
1360 kunmap_atomic(target, KM_USER0);
1361
1362 flush_dcache_page(page);
1363 SetPageUptodate(page);
1364 unlock_page(page);
1365 if (!pagevec_add(plru_pvec, page))
1366 __pagevec_lru_add(plru_pvec);
1367 data += PAGE_CACHE_SIZE;
1368 }
1369 return;
1370 }
1371
1372 static int cifs_readpages(struct file *file, struct address_space *mapping,
1373 struct list_head *page_list, unsigned num_pages)
1374 {
1375 int rc = -EACCES;
1376 int xid;
1377 loff_t offset;
1378 struct page *page;
1379 struct cifs_sb_info *cifs_sb;
1380 struct cifsTconInfo *pTcon;
1381 int bytes_read = 0;
1382 unsigned int read_size,i;
1383 char *smb_read_data = NULL;
1384 struct smb_com_read_rsp *pSMBr;
1385 struct pagevec lru_pvec;
1386 struct cifsFileInfo *open_file;
1387
1388 xid = GetXid();
1389 if (file->private_data == NULL) {
1390 FreeXid(xid);
1391 return -EBADF;
1392 }
1393 open_file = (struct cifsFileInfo *)file->private_data;
1394 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1395 pTcon = cifs_sb->tcon;
1396
1397 pagevec_init(&lru_pvec, 0);
1398
1399 for (i = 0; i < num_pages; ) {
1400 unsigned contig_pages;
1401 struct page *tmp_page;
1402 unsigned long expected_index;
1403
1404 if (list_empty(page_list))
1405 break;
1406
1407 page = list_entry(page_list->prev, struct page, lru);
1408 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1409
1410 /* count adjacent pages that we will read into */
1411 contig_pages = 0;
1412 expected_index =
1413 list_entry(page_list->prev, struct page, lru)->index;
1414 list_for_each_entry_reverse(tmp_page,page_list,lru) {
1415 if (tmp_page->index == expected_index) {
1416 contig_pages++;
1417 expected_index++;
1418 } else
1419 break;
1420 }
1421 if (contig_pages + i > num_pages)
1422 contig_pages = num_pages - i;
1423
1424 /* for reads over a certain size could initiate async
1425 read ahead */
1426
1427 read_size = contig_pages * PAGE_CACHE_SIZE;
1428 /* Read size needs to be in multiples of one page */
1429 read_size = min_t(const unsigned int, read_size,
1430 cifs_sb->rsize & PAGE_CACHE_MASK);
1431
1432 rc = -EAGAIN;
1433 while (rc == -EAGAIN) {
1434 if ((open_file->invalidHandle) &&
1435 (!open_file->closePend)) {
1436 rc = cifs_reopen_file(file->f_dentry->d_inode,
1437 file, TRUE);
1438 if (rc != 0)
1439 break;
1440 }
1441
1442 rc = CIFSSMBRead(xid, pTcon,
1443 open_file->netfid,
1444 read_size, offset,
1445 &bytes_read, &smb_read_data);
1446 /* BB need to check return code here */
1447 if (rc== -EAGAIN) {
1448 if (smb_read_data) {
1449 cifs_buf_release(smb_read_data);
1450 smb_read_data = NULL;
1451 }
1452 }
1453 }
1454 if ((rc < 0) || (smb_read_data == NULL)) {
1455 cFYI(1, ("Read error in readpages: %d", rc));
1456 /* clean up remaing pages off list */
1457 while (!list_empty(page_list) && (i < num_pages)) {
1458 page = list_entry(page_list->prev, struct page,
1459 lru);
1460 list_del(&page->lru);
1461 page_cache_release(page);
1462 }
1463 break;
1464 } else if (bytes_read > 0) {
1465 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1466 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1467 smb_read_data + 4 /* RFC1001 hdr */ +
1468 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1469
1470 i += bytes_read >> PAGE_CACHE_SHIFT;
1471 cifs_stats_bytes_read(pTcon, bytes_read);
1472 if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1473 i++; /* account for partial page */
1474
1475 /* server copy of file can have smaller size
1476 than client */
1477 /* BB do we need to verify this common case ?
1478 this case is ok - if we are at server EOF
1479 we will hit it on next read */
1480
1481 /* while (!list_empty(page_list) && (i < num_pages)) {
1482 page = list_entry(page_list->prev,
1483 struct page, list);
1484 list_del(&page->list);
1485 page_cache_release(page);
1486 }
1487 break; */
1488 }
1489 } else {
1490 cFYI(1, ("No bytes read (%d) at offset %lld . "
1491 "Cleaning remaining pages from readahead list",
1492 bytes_read, offset));
1493 /* BB turn off caching and do new lookup on
1494 file size at server? */
1495 while (!list_empty(page_list) && (i < num_pages)) {
1496 page = list_entry(page_list->prev, struct page,
1497 lru);
1498 list_del(&page->lru);
1499
1500 /* BB removeme - replace with zero of page? */
1501 page_cache_release(page);
1502 }
1503 break;
1504 }
1505 if (smb_read_data) {
1506 cifs_buf_release(smb_read_data);
1507 smb_read_data = NULL;
1508 }
1509 bytes_read = 0;
1510 }
1511
1512 pagevec_lru_add(&lru_pvec);
1513
1514 /* need to free smb_read_data buf before exit */
1515 if (smb_read_data) {
1516 cifs_buf_release(smb_read_data);
1517 smb_read_data = NULL;
1518 }
1519
1520 FreeXid(xid);
1521 return rc;
1522 }
1523
1524 static int cifs_readpage_worker(struct file *file, struct page *page,
1525 loff_t *poffset)
1526 {
1527 char *read_data;
1528 int rc;
1529
1530 page_cache_get(page);
1531 read_data = kmap(page);
1532 /* for reads over a certain size could initiate async read ahead */
1533
1534 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1535
1536 if (rc < 0)
1537 goto io_error;
1538 else
1539 cFYI(1, ("Bytes read %d ",rc));
1540
1541 file->f_dentry->d_inode->i_atime =
1542 current_fs_time(file->f_dentry->d_inode->i_sb);
1543
1544 if (PAGE_CACHE_SIZE > rc)
1545 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1546
1547 flush_dcache_page(page);
1548 SetPageUptodate(page);
1549 rc = 0;
1550
1551 io_error:
1552 kunmap(page);
1553 page_cache_release(page);
1554 return rc;
1555 }
1556
1557 static int cifs_readpage(struct file *file, struct page *page)
1558 {
1559 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1560 int rc = -EACCES;
1561 int xid;
1562
1563 xid = GetXid();
1564
1565 if (file->private_data == NULL) {
1566 FreeXid(xid);
1567 return -EBADF;
1568 }
1569
1570 cFYI(1, ("readpage %p at offset %d 0x%x\n",
1571 page, (int)offset, (int)offset));
1572
1573 rc = cifs_readpage_worker(file, page, &offset);
1574
1575 unlock_page(page);
1576
1577 FreeXid(xid);
1578 return rc;
1579 }
1580
1581 /* We do not want to update the file size from server for inodes
1582 open for write - to avoid races with writepage extending
1583 the file - in the future we could consider allowing
1584 refreshing the inode only on increases in the file size
1585 but this is tricky to do without racing with writebehind
1586 page caching in the current Linux kernel design */
1587 int is_size_safe_to_change(struct cifsInodeInfo *cifsInode)
1588 {
1589 struct list_head *tmp;
1590 struct list_head *tmp1;
1591 struct cifsFileInfo *open_file = NULL;
1592 int rc = TRUE;
1593
1594 if (cifsInode == NULL)
1595 return rc;
1596
1597 read_lock(&GlobalSMBSeslock);
1598 list_for_each_safe(tmp, tmp1, &cifsInode->openFileList) {
1599 open_file = list_entry(tmp, struct cifsFileInfo, flist);
1600 if (open_file == NULL)
1601 break;
1602 if (open_file->closePend)
1603 continue;
1604 /* We check if file is open for writing,
1605 BB we could supplement this with a check to see if file size
1606 changes have been flushed to server - ie inode metadata dirty */
1607 if ((open_file->pfile) &&
1608 ((open_file->pfile->f_flags & O_RDWR) ||
1609 (open_file->pfile->f_flags & O_WRONLY))) {
1610 rc = FALSE;
1611 break;
1612 }
1613 if (tmp->next == NULL) {
1614 cFYI(1, ("File instance %p removed", tmp));
1615 break;
1616 }
1617 }
1618 read_unlock(&GlobalSMBSeslock);
1619 return rc;
1620 }
1621
1622
1623 static int cifs_prepare_write(struct file *file, struct page *page,
1624 unsigned from, unsigned to)
1625 {
1626 int rc = 0;
1627 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1628 cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
1629 if (!PageUptodate(page)) {
1630 /* if (to - from != PAGE_CACHE_SIZE) {
1631 void *kaddr = kmap_atomic(page, KM_USER0);
1632 memset(kaddr, 0, from);
1633 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
1634 flush_dcache_page(page);
1635 kunmap_atomic(kaddr, KM_USER0);
1636 } */
1637 /* If we are writing a full page it will be up to date,
1638 no need to read from the server */
1639 if ((to == PAGE_CACHE_SIZE) && (from == 0))
1640 SetPageUptodate(page);
1641
1642 /* might as well read a page, it is fast enough */
1643 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
1644 rc = cifs_readpage_worker(file, page, &offset);
1645 } else {
1646 /* should we try using another file handle if there is one -
1647 how would we lock it to prevent close of that handle
1648 racing with this read?
1649 In any case this will be written out by commit_write */
1650 }
1651 }
1652
1653 /* BB should we pass any errors back?
1654 e.g. if we do not have read access to the file */
1655 return 0;
1656 }
1657
1658 struct address_space_operations cifs_addr_ops = {
1659 .readpage = cifs_readpage,
1660 .readpages = cifs_readpages,
1661 .writepage = cifs_writepage,
1662 .prepare_write = cifs_prepare_write,
1663 .commit_write = cifs_commit_write,
1664 .set_page_dirty = __set_page_dirty_nobuffers,
1665 /* .sync_page = cifs_sync_page, */
1666 /* .direct_IO = */
1667 };
Ubuntu Artful kernel mirror