?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
aufs: possible bugfix, allow the nested aufsd between several aufs mounts
[zen-stable.git] / fs / cifs / file.c
blob5e64748a29173d75ad976c0375f7152d5ae0171d
1 /*
2 * fs/cifs/file.c
3 *
4 * vfs operations that deal with files
5 *
6 * Copyright (C) International Business Machines Corp., 2002,2010
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 * Jeremy Allison (jra@samba.org)
9 *
10 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 */
24 #include <linux/fs.h>
25 #include <linux/backing-dev.h>
26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
28 #include <linux/pagemap.h>
29 #include <linux/pagevec.h>
30 #include <linux/writeback.h>
31 #include <linux/task_io_accounting_ops.h>
32 #include <linux/delay.h>
33 #include <linux/mount.h>
34 #include <linux/slab.h>
35 #include <linux/swap.h>
36 #include <asm/div64.h>
37 #include "cifsfs.h"
38 #include "cifspdu.h"
39 #include "cifsglob.h"
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
44 #include "fscache.h"
45
46 static inline int cifs_convert_flags(unsigned int flags)
47 {
48 if ((flags & O_ACCMODE) == O_RDONLY)
49 return GENERIC_READ;
50 else if ((flags & O_ACCMODE) == O_WRONLY)
51 return GENERIC_WRITE;
52 else if ((flags & O_ACCMODE) == O_RDWR) {
53 /* GENERIC_ALL is too much permission to request
54 can cause unnecessary access denied on create */
55 /* return GENERIC_ALL; */
56 return (GENERIC_READ | GENERIC_WRITE);
57 }
58
59 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
60 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
61 FILE_READ_DATA);
62 }
63
64 static u32 cifs_posix_convert_flags(unsigned int flags)
65 {
66 u32 posix_flags = 0;
67
68 if ((flags & O_ACCMODE) == O_RDONLY)
69 posix_flags = SMB_O_RDONLY;
70 else if ((flags & O_ACCMODE) == O_WRONLY)
71 posix_flags = SMB_O_WRONLY;
72 else if ((flags & O_ACCMODE) == O_RDWR)
73 posix_flags = SMB_O_RDWR;
74
75 if (flags & O_CREAT)
76 posix_flags |= SMB_O_CREAT;
77 if (flags & O_EXCL)
78 posix_flags |= SMB_O_EXCL;
79 if (flags & O_TRUNC)
80 posix_flags |= SMB_O_TRUNC;
81 /* be safe and imply O_SYNC for O_DSYNC */
82 if (flags & O_DSYNC)
83 posix_flags |= SMB_O_SYNC;
84 if (flags & O_DIRECTORY)
85 posix_flags |= SMB_O_DIRECTORY;
86 if (flags & O_NOFOLLOW)
87 posix_flags |= SMB_O_NOFOLLOW;
88 if (flags & O_DIRECT)
89 posix_flags |= SMB_O_DIRECT;
90
91 return posix_flags;
92 }
93
94 static inline int cifs_get_disposition(unsigned int flags)
95 {
96 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
97 return FILE_CREATE;
98 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
99 return FILE_OVERWRITE_IF;
100 else if ((flags & O_CREAT) == O_CREAT)
101 return FILE_OPEN_IF;
102 else if ((flags & O_TRUNC) == O_TRUNC)
103 return FILE_OVERWRITE;
104 else
105 return FILE_OPEN;
106 }
107
108 int cifs_posix_open(char *full_path, struct inode **pinode,
109 struct super_block *sb, int mode, unsigned int f_flags,
110 __u32 *poplock, __u16 *pnetfid, int xid)
111 {
112 int rc;
113 FILE_UNIX_BASIC_INFO *presp_data;
114 __u32 posix_flags = 0;
115 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
116 struct cifs_fattr fattr;
117 struct tcon_link *tlink;
118 struct cifs_tcon *tcon;
119
120 cFYI(1, "posix open %s", full_path);
121
122 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
123 if (presp_data == NULL)
124 return -ENOMEM;
125
126 tlink = cifs_sb_tlink(cifs_sb);
127 if (IS_ERR(tlink)) {
128 rc = PTR_ERR(tlink);
129 goto posix_open_ret;
130 }
131
132 tcon = tlink_tcon(tlink);
133 mode &= ~current_umask();
134
135 posix_flags = cifs_posix_convert_flags(f_flags);
136 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
137 poplock, full_path, cifs_sb->local_nls,
138 cifs_sb->mnt_cifs_flags &
139 CIFS_MOUNT_MAP_SPECIAL_CHR);
140 cifs_put_tlink(tlink);
141
142 if (rc)
143 goto posix_open_ret;
144
145 if (presp_data->Type == cpu_to_le32(-1))
146 goto posix_open_ret; /* open ok, caller does qpathinfo */
147
148 if (!pinode)
149 goto posix_open_ret; /* caller does not need info */
150
151 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
152
153 /* get new inode and set it up */
154 if (*pinode == NULL) {
155 cifs_fill_uniqueid(sb, &fattr);
156 *pinode = cifs_iget(sb, &fattr);
157 if (!*pinode) {
158 rc = -ENOMEM;
159 goto posix_open_ret;
160 }
161 } else {
162 cifs_fattr_to_inode(*pinode, &fattr);
163 }
164
165 posix_open_ret:
166 kfree(presp_data);
167 return rc;
168 }
169
170 static int
171 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
172 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *poplock,
173 __u16 *pnetfid, int xid)
174 {
175 int rc;
176 int desiredAccess;
177 int disposition;
178 int create_options = CREATE_NOT_DIR;
179 FILE_ALL_INFO *buf;
180
181 desiredAccess = cifs_convert_flags(f_flags);
182
183 /*********************************************************************
184 * open flag mapping table:
185 *
186 * POSIX Flag CIFS Disposition
187 * ---------- ----------------
188 * O_CREAT FILE_OPEN_IF
189 * O_CREAT | O_EXCL FILE_CREATE
190 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
191 * O_TRUNC FILE_OVERWRITE
192 * none of the above FILE_OPEN
193 *
194 * Note that there is not a direct match between disposition
195 * FILE_SUPERSEDE (ie create whether or not file exists although
196 * O_CREAT | O_TRUNC is similar but truncates the existing
197 * file rather than creating a new file as FILE_SUPERSEDE does
198 * (which uses the attributes / metadata passed in on open call)
199 *?
200 *? O_SYNC is a reasonable match to CIFS writethrough flag
201 *? and the read write flags match reasonably. O_LARGEFILE
202 *? is irrelevant because largefile support is always used
203 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
204 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
205 *********************************************************************/
206
207 disposition = cifs_get_disposition(f_flags);
208
209 /* BB pass O_SYNC flag through on file attributes .. BB */
210
211 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
212 if (!buf)
213 return -ENOMEM;
214
215 if (backup_cred(cifs_sb))
216 create_options |= CREATE_OPEN_BACKUP_INTENT;
217
218 if (tcon->ses->capabilities & CAP_NT_SMBS)
219 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
220 desiredAccess, create_options, pnetfid, poplock, buf,
221 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
222 & CIFS_MOUNT_MAP_SPECIAL_CHR);
223 else
224 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
225 desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
226 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
227 & CIFS_MOUNT_MAP_SPECIAL_CHR);
228
229 if (rc)
230 goto out;
231
232 if (tcon->unix_ext)
233 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
234 xid);
235 else
236 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
237 xid, pnetfid);
238
239 out:
240 kfree(buf);
241 return rc;
242 }
243
244 struct cifsFileInfo *
245 cifs_new_fileinfo(__u16 fileHandle, struct file *file,
246 struct tcon_link *tlink, __u32 oplock)
247 {
248 struct dentry *dentry = file->f_path.dentry;
249 struct inode *inode = dentry->d_inode;
250 struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
251 struct cifsFileInfo *pCifsFile;
252
253 pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
254 if (pCifsFile == NULL)
255 return pCifsFile;
256
257 pCifsFile->count = 1;
258 pCifsFile->netfid = fileHandle;
259 pCifsFile->pid = current->tgid;
260 pCifsFile->uid = current_fsuid();
261 pCifsFile->dentry = dget(dentry);
262 pCifsFile->f_flags = file->f_flags;
263 pCifsFile->invalidHandle = false;
264 pCifsFile->tlink = cifs_get_tlink(tlink);
265 mutex_init(&pCifsFile->fh_mutex);
266 INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
267
268 spin_lock(&cifs_file_list_lock);
269 list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
270 /* if readable file instance put first in list*/
271 if (file->f_mode & FMODE_READ)
272 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
273 else
274 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
275 spin_unlock(&cifs_file_list_lock);
276
277 cifs_set_oplock_level(pCifsInode, oplock);
278 pCifsInode->can_cache_brlcks = pCifsInode->clientCanCacheAll;
279
280 file->private_data = pCifsFile;
281 return pCifsFile;
282 }
283
284 static void cifs_del_lock_waiters(struct cifsLockInfo *lock);
285
286 /*
287 * Release a reference on the file private data. This may involve closing
288 * the filehandle out on the server. Must be called without holding
289 * cifs_file_list_lock.
290 */
291 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
292 {
293 struct inode *inode = cifs_file->dentry->d_inode;
294 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
295 struct cifsInodeInfo *cifsi = CIFS_I(inode);
296 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
297 struct cifsLockInfo *li, *tmp;
298
299 spin_lock(&cifs_file_list_lock);
300 if (--cifs_file->count > 0) {
301 spin_unlock(&cifs_file_list_lock);
302 return;
303 }
304
305 /* remove it from the lists */
306 list_del(&cifs_file->flist);
307 list_del(&cifs_file->tlist);
308
309 if (list_empty(&cifsi->openFileList)) {
310 cFYI(1, "closing last open instance for inode %p",
311 cifs_file->dentry->d_inode);
312
313 /* in strict cache mode we need invalidate mapping on the last
314 close because it may cause a error when we open this file
315 again and get at least level II oplock */
316 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
317 CIFS_I(inode)->invalid_mapping = true;
318
319 cifs_set_oplock_level(cifsi, 0);
320 }
321 spin_unlock(&cifs_file_list_lock);
322
323 cancel_work_sync(&cifs_file->oplock_break);
324
325 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
326 int xid, rc;
327
328 xid = GetXid();
329 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
330 FreeXid(xid);
331 }
332
333 /* Delete any outstanding lock records. We'll lose them when the file
334 * is closed anyway.
335 */
336 mutex_lock(&cifsi->lock_mutex);
337 list_for_each_entry_safe(li, tmp, &cifsi->llist, llist) {
338 if (li->netfid != cifs_file->netfid)
339 continue;
340 list_del(&li->llist);
341 cifs_del_lock_waiters(li);
342 kfree(li);
343 }
344 mutex_unlock(&cifsi->lock_mutex);
345
346 cifs_put_tlink(cifs_file->tlink);
347 dput(cifs_file->dentry);
348 kfree(cifs_file);
349 }
350
351 int cifs_open(struct inode *inode, struct file *file)
352 {
353 int rc = -EACCES;
354 int xid;
355 __u32 oplock;
356 struct cifs_sb_info *cifs_sb;
357 struct cifs_tcon *tcon;
358 struct tcon_link *tlink;
359 struct cifsFileInfo *pCifsFile = NULL;
360 char *full_path = NULL;
361 bool posix_open_ok = false;
362 __u16 netfid;
363
364 xid = GetXid();
365
366 cifs_sb = CIFS_SB(inode->i_sb);
367 tlink = cifs_sb_tlink(cifs_sb);
368 if (IS_ERR(tlink)) {
369 FreeXid(xid);
370 return PTR_ERR(tlink);
371 }
372 tcon = tlink_tcon(tlink);
373
374 full_path = build_path_from_dentry(file->f_path.dentry);
375 if (full_path == NULL) {
376 rc = -ENOMEM;
377 goto out;
378 }
379
380 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
381 inode, file->f_flags, full_path);
382
383 if (enable_oplocks)
384 oplock = REQ_OPLOCK;
385 else
386 oplock = 0;
387
388 if (!tcon->broken_posix_open && tcon->unix_ext &&
389 (tcon->ses->capabilities & CAP_UNIX) &&
390 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
391 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
392 /* can not refresh inode info since size could be stale */
393 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
394 cifs_sb->mnt_file_mode /* ignored */,
395 file->f_flags, &oplock, &netfid, xid);
396 if (rc == 0) {
397 cFYI(1, "posix open succeeded");
398 posix_open_ok = true;
399 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
400 if (tcon->ses->serverNOS)
401 cERROR(1, "server %s of type %s returned"
402 " unexpected error on SMB posix open"
403 ", disabling posix open support."
404 " Check if server update available.",
405 tcon->ses->serverName,
406 tcon->ses->serverNOS);
407 tcon->broken_posix_open = true;
408 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
409 (rc != -EOPNOTSUPP)) /* path not found or net err */
410 goto out;
411 /* else fallthrough to retry open the old way on network i/o
412 or DFS errors */
413 }
414
415 if (!posix_open_ok) {
416 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
417 file->f_flags, &oplock, &netfid, xid);
418 if (rc)
419 goto out;
420 }
421
422 pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
423 if (pCifsFile == NULL) {
424 CIFSSMBClose(xid, tcon, netfid);
425 rc = -ENOMEM;
426 goto out;
427 }
428
429 cifs_fscache_set_inode_cookie(inode, file);
430
431 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
432 /* time to set mode which we can not set earlier due to
433 problems creating new read-only files */
434 struct cifs_unix_set_info_args args = {
435 .mode = inode->i_mode,
436 .uid = NO_CHANGE_64,
437 .gid = NO_CHANGE_64,
438 .ctime = NO_CHANGE_64,
439 .atime = NO_CHANGE_64,
440 .mtime = NO_CHANGE_64,
441 .device = 0,
442 };
443 CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
444 pCifsFile->pid);
445 }
446
447 out:
448 kfree(full_path);
449 FreeXid(xid);
450 cifs_put_tlink(tlink);
451 return rc;
452 }
453
454 /* Try to reacquire byte range locks that were released when session */
455 /* to server was lost */
456 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
457 {
458 int rc = 0;
459
460 /* BB list all locks open on this file and relock */
461
462 return rc;
463 }
464
465 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
466 {
467 int rc = -EACCES;
468 int xid;
469 __u32 oplock;
470 struct cifs_sb_info *cifs_sb;
471 struct cifs_tcon *tcon;
472 struct cifsInodeInfo *pCifsInode;
473 struct inode *inode;
474 char *full_path = NULL;
475 int desiredAccess;
476 int disposition = FILE_OPEN;
477 int create_options = CREATE_NOT_DIR;
478 __u16 netfid;
479
480 xid = GetXid();
481 mutex_lock(&pCifsFile->fh_mutex);
482 if (!pCifsFile->invalidHandle) {
483 mutex_unlock(&pCifsFile->fh_mutex);
484 rc = 0;
485 FreeXid(xid);
486 return rc;
487 }
488
489 inode = pCifsFile->dentry->d_inode;
490 cifs_sb = CIFS_SB(inode->i_sb);
491 tcon = tlink_tcon(pCifsFile->tlink);
492
493 /* can not grab rename sem here because various ops, including
494 those that already have the rename sem can end up causing writepage
495 to get called and if the server was down that means we end up here,
496 and we can never tell if the caller already has the rename_sem */
497 full_path = build_path_from_dentry(pCifsFile->dentry);
498 if (full_path == NULL) {
499 rc = -ENOMEM;
500 mutex_unlock(&pCifsFile->fh_mutex);
501 FreeXid(xid);
502 return rc;
503 }
504
505 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
506 inode, pCifsFile->f_flags, full_path);
507
508 if (enable_oplocks)
509 oplock = REQ_OPLOCK;
510 else
511 oplock = 0;
512
513 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
514 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
515 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
516
517 /*
518 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
519 * original open. Must mask them off for a reopen.
520 */
521 unsigned int oflags = pCifsFile->f_flags &
522 ~(O_CREAT | O_EXCL | O_TRUNC);
523
524 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
525 cifs_sb->mnt_file_mode /* ignored */,
526 oflags, &oplock, &netfid, xid);
527 if (rc == 0) {
528 cFYI(1, "posix reopen succeeded");
529 goto reopen_success;
530 }
531 /* fallthrough to retry open the old way on errors, especially
532 in the reconnect path it is important to retry hard */
533 }
534
535 desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
536
537 if (backup_cred(cifs_sb))
538 create_options |= CREATE_OPEN_BACKUP_INTENT;
539
540 /* Can not refresh inode by passing in file_info buf to be returned
541 by SMBOpen and then calling get_inode_info with returned buf
542 since file might have write behind data that needs to be flushed
543 and server version of file size can be stale. If we knew for sure
544 that inode was not dirty locally we could do this */
545
546 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
547 create_options, &netfid, &oplock, NULL,
548 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
549 CIFS_MOUNT_MAP_SPECIAL_CHR);
550 if (rc) {
551 mutex_unlock(&pCifsFile->fh_mutex);
552 cFYI(1, "cifs_open returned 0x%x", rc);
553 cFYI(1, "oplock: %d", oplock);
554 goto reopen_error_exit;
555 }
556
557 reopen_success:
558 pCifsFile->netfid = netfid;
559 pCifsFile->invalidHandle = false;
560 mutex_unlock(&pCifsFile->fh_mutex);
561 pCifsInode = CIFS_I(inode);
562
563 if (can_flush) {
564 rc = filemap_write_and_wait(inode->i_mapping);
565 mapping_set_error(inode->i_mapping, rc);
566
567 if (tcon->unix_ext)
568 rc = cifs_get_inode_info_unix(&inode,
569 full_path, inode->i_sb, xid);
570 else
571 rc = cifs_get_inode_info(&inode,
572 full_path, NULL, inode->i_sb,
573 xid, NULL);
574 } /* else we are writing out data to server already
575 and could deadlock if we tried to flush data, and
576 since we do not know if we have data that would
577 invalidate the current end of file on the server
578 we can not go to the server to get the new inod
579 info */
580
581 cifs_set_oplock_level(pCifsInode, oplock);
582
583 cifs_relock_file(pCifsFile);
584
585 reopen_error_exit:
586 kfree(full_path);
587 FreeXid(xid);
588 return rc;
589 }
590
591 int cifs_close(struct inode *inode, struct file *file)
592 {
593 if (file->private_data != NULL) {
594 cifsFileInfo_put(file->private_data);
595 file->private_data = NULL;
596 }
597
598 /* return code from the ->release op is always ignored */
599 return 0;
600 }
601
602 int cifs_closedir(struct inode *inode, struct file *file)
603 {
604 int rc = 0;
605 int xid;
606 struct cifsFileInfo *pCFileStruct = file->private_data;
607 char *ptmp;
608
609 cFYI(1, "Closedir inode = 0x%p", inode);
610
611 xid = GetXid();
612
613 if (pCFileStruct) {
614 struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
615
616 cFYI(1, "Freeing private data in close dir");
617 spin_lock(&cifs_file_list_lock);
618 if (!pCFileStruct->srch_inf.endOfSearch &&
619 !pCFileStruct->invalidHandle) {
620 pCFileStruct->invalidHandle = true;
621 spin_unlock(&cifs_file_list_lock);
622 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
623 cFYI(1, "Closing uncompleted readdir with rc %d",
624 rc);
625 /* not much we can do if it fails anyway, ignore rc */
626 rc = 0;
627 } else
628 spin_unlock(&cifs_file_list_lock);
629 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
630 if (ptmp) {
631 cFYI(1, "closedir free smb buf in srch struct");
632 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
633 if (pCFileStruct->srch_inf.smallBuf)
634 cifs_small_buf_release(ptmp);
635 else
636 cifs_buf_release(ptmp);
637 }
638 cifs_put_tlink(pCFileStruct->tlink);
639 kfree(file->private_data);
640 file->private_data = NULL;
641 }
642 /* BB can we lock the filestruct while this is going on? */
643 FreeXid(xid);
644 return rc;
645 }
646
647 static struct cifsLockInfo *
648 cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 netfid)
649 {
650 struct cifsLockInfo *lock =
651 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
652 if (!lock)
653 return lock;
654 lock->offset = offset;
655 lock->length = length;
656 lock->type = type;
657 lock->netfid = netfid;
658 lock->pid = current->tgid;
659 INIT_LIST_HEAD(&lock->blist);
660 init_waitqueue_head(&lock->block_q);
661 return lock;
662 }
663
664 static void
665 cifs_del_lock_waiters(struct cifsLockInfo *lock)
666 {
667 struct cifsLockInfo *li, *tmp;
668 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
669 list_del_init(&li->blist);
670 wake_up(&li->block_q);
671 }
672 }
673
674 static bool
675 __cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset,
676 __u64 length, __u8 type, __u16 netfid,
677 struct cifsLockInfo **conf_lock)
678 {
679 struct cifsLockInfo *li, *tmp;
680
681 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
682 if (offset + length <= li->offset ||
683 offset >= li->offset + li->length)
684 continue;
685 else if ((type & LOCKING_ANDX_SHARED_LOCK) &&
686 ((netfid == li->netfid && current->tgid == li->pid) ||
687 type == li->type))
688 continue;
689 else {
690 *conf_lock = li;
691 return true;
692 }
693 }
694 return false;
695 }
696
697 static bool
698 cifs_find_lock_conflict(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
699 struct cifsLockInfo **conf_lock)
700 {
701 return __cifs_find_lock_conflict(cinode, lock->offset, lock->length,
702 lock->type, lock->netfid, conf_lock);
703 }
704
705 /*
706 * Check if there is another lock that prevents us to set the lock (mandatory
707 * style). If such a lock exists, update the flock structure with its
708 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
709 * or leave it the same if we can't. Returns 0 if we don't need to request to
710 * the server or 1 otherwise.
711 */
712 static int
713 cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
714 __u8 type, __u16 netfid, struct file_lock *flock)
715 {
716 int rc = 0;
717 struct cifsLockInfo *conf_lock;
718 bool exist;
719
720 mutex_lock(&cinode->lock_mutex);
721
722 exist = __cifs_find_lock_conflict(cinode, offset, length, type, netfid,
723 &conf_lock);
724 if (exist) {
725 flock->fl_start = conf_lock->offset;
726 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
727 flock->fl_pid = conf_lock->pid;
728 if (conf_lock->type & LOCKING_ANDX_SHARED_LOCK)
729 flock->fl_type = F_RDLCK;
730 else
731 flock->fl_type = F_WRLCK;
732 } else if (!cinode->can_cache_brlcks)
733 rc = 1;
734 else
735 flock->fl_type = F_UNLCK;
736
737 mutex_unlock(&cinode->lock_mutex);
738 return rc;
739 }
740
741 static void
742 cifs_lock_add(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock)
743 {
744 mutex_lock(&cinode->lock_mutex);
745 list_add_tail(&lock->llist, &cinode->llist);
746 mutex_unlock(&cinode->lock_mutex);
747 }
748
749 /*
750 * Set the byte-range lock (mandatory style). Returns:
751 * 1) 0, if we set the lock and don't need to request to the server;
752 * 2) 1, if no locks prevent us but we need to request to the server;
753 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
754 */
755 static int
756 cifs_lock_add_if(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
757 bool wait)
758 {
759 struct cifsLockInfo *conf_lock;
760 bool exist;
761 int rc = 0;
762
763 try_again:
764 exist = false;
765 mutex_lock(&cinode->lock_mutex);
766
767 exist = cifs_find_lock_conflict(cinode, lock, &conf_lock);
768 if (!exist && cinode->can_cache_brlcks) {
769 list_add_tail(&lock->llist, &cinode->llist);
770 mutex_unlock(&cinode->lock_mutex);
771 return rc;
772 }
773
774 if (!exist)
775 rc = 1;
776 else if (!wait)
777 rc = -EACCES;
778 else {
779 list_add_tail(&lock->blist, &conf_lock->blist);
780 mutex_unlock(&cinode->lock_mutex);
781 rc = wait_event_interruptible(lock->block_q,
782 (lock->blist.prev == &lock->blist) &&
783 (lock->blist.next == &lock->blist));
784 if (!rc)
785 goto try_again;
786 mutex_lock(&cinode->lock_mutex);
787 list_del_init(&lock->blist);
788 }
789
790 mutex_unlock(&cinode->lock_mutex);
791 return rc;
792 }
793
794 /*
795 * Check if there is another lock that prevents us to set the lock (posix
796 * style). If such a lock exists, update the flock structure with its
797 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
798 * or leave it the same if we can't. Returns 0 if we don't need to request to
799 * the server or 1 otherwise.
800 */
801 static int
802 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
803 {
804 int rc = 0;
805 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
806 unsigned char saved_type = flock->fl_type;
807
808 if ((flock->fl_flags & FL_POSIX) == 0)
809 return 1;
810
811 mutex_lock(&cinode->lock_mutex);
812 posix_test_lock(file, flock);
813
814 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
815 flock->fl_type = saved_type;
816 rc = 1;
817 }
818
819 mutex_unlock(&cinode->lock_mutex);
820 return rc;
821 }
822
823 /*
824 * Set the byte-range lock (posix style). Returns:
825 * 1) 0, if we set the lock and don't need to request to the server;
826 * 2) 1, if we need to request to the server;
827 * 3) <0, if the error occurs while setting the lock.
828 */
829 static int
830 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
831 {
832 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
833 int rc = 1;
834
835 if ((flock->fl_flags & FL_POSIX) == 0)
836 return rc;
837
838 mutex_lock(&cinode->lock_mutex);
839 if (!cinode->can_cache_brlcks) {
840 mutex_unlock(&cinode->lock_mutex);
841 return rc;
842 }
843 rc = posix_lock_file_wait(file, flock);
844 mutex_unlock(&cinode->lock_mutex);
845 return rc;
846 }
847
848 static int
849 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
850 {
851 int xid, rc = 0, stored_rc;
852 struct cifsLockInfo *li, *tmp;
853 struct cifs_tcon *tcon;
854 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
855 unsigned int num, max_num;
856 LOCKING_ANDX_RANGE *buf, *cur;
857 int types[] = {LOCKING_ANDX_LARGE_FILES,
858 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
859 int i;
860
861 xid = GetXid();
862 tcon = tlink_tcon(cfile->tlink);
863
864 mutex_lock(&cinode->lock_mutex);
865 if (!cinode->can_cache_brlcks) {
866 mutex_unlock(&cinode->lock_mutex);
867 FreeXid(xid);
868 return rc;
869 }
870
871 max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
872 sizeof(LOCKING_ANDX_RANGE);
873 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
874 if (!buf) {
875 mutex_unlock(&cinode->lock_mutex);
876 FreeXid(xid);
877 return rc;
878 }
879
880 for (i = 0; i < 2; i++) {
881 cur = buf;
882 num = 0;
883 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
884 if (li->type != types[i])
885 continue;
886 cur->Pid = cpu_to_le16(li->pid);
887 cur->LengthLow = cpu_to_le32((u32)li->length);
888 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
889 cur->OffsetLow = cpu_to_le32((u32)li->offset);
890 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
891 if (++num == max_num) {
892 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
893 li->type, 0, num, buf);
894 if (stored_rc)
895 rc = stored_rc;
896 cur = buf;
897 num = 0;
898 } else
899 cur++;
900 }
901
902 if (num) {
903 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
904 types[i], 0, num, buf);
905 if (stored_rc)
906 rc = stored_rc;
907 }
908 }
909
910 cinode->can_cache_brlcks = false;
911 mutex_unlock(&cinode->lock_mutex);
912
913 kfree(buf);
914 FreeXid(xid);
915 return rc;
916 }
917
918 /* copied from fs/locks.c with a name change */
919 #define cifs_for_each_lock(inode, lockp) \
920 for (lockp = &inode->i_flock; *lockp != NULL; \
921 lockp = &(*lockp)->fl_next)
922
923 struct lock_to_push {
924 struct list_head llist;
925 __u64 offset;
926 __u64 length;
927 __u32 pid;
928 __u16 netfid;
929 __u8 type;
930 };
931
932 static int
933 cifs_push_posix_locks(struct cifsFileInfo *cfile)
934 {
935 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
936 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
937 struct file_lock *flock, **before;
938 unsigned int count = 0, i = 0;
939 int rc = 0, xid, type;
940 struct list_head locks_to_send, *el;
941 struct lock_to_push *lck, *tmp;
942 __u64 length;
943
944 xid = GetXid();
945
946 mutex_lock(&cinode->lock_mutex);
947 if (!cinode->can_cache_brlcks) {
948 mutex_unlock(&cinode->lock_mutex);
949 FreeXid(xid);
950 return rc;
951 }
952
953 lock_flocks();
954 cifs_for_each_lock(cfile->dentry->d_inode, before) {
955 if ((*before)->fl_flags & FL_POSIX)
956 count++;
957 }
958 unlock_flocks();
959
960 INIT_LIST_HEAD(&locks_to_send);
961
962 /*
963 * Allocating count locks is enough because no locks can be added to
964 * the list while we are holding cinode->lock_mutex that protects
965 * locking operations of this inode.
966 */
967 for (; i < count; i++) {
968 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
969 if (!lck) {
970 rc = -ENOMEM;
971 goto err_out;
972 }
973 list_add_tail(&lck->llist, &locks_to_send);
974 }
975
976 i = 0;
977 el = locks_to_send.next;
978 lock_flocks();
979 cifs_for_each_lock(cfile->dentry->d_inode, before) {
980 if (el == &locks_to_send) {
981 /* something is really wrong */
982 cERROR(1, "Can't push all brlocks!");
983 break;
984 }
985 flock = *before;
986 if ((flock->fl_flags & FL_POSIX) == 0)
987 continue;
988 length = 1 + flock->fl_end - flock->fl_start;
989 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
990 type = CIFS_RDLCK;
991 else
992 type = CIFS_WRLCK;
993 lck = list_entry(el, struct lock_to_push, llist);
994 lck->pid = flock->fl_pid;
995 lck->netfid = cfile->netfid;
996 lck->length = length;
997 lck->type = type;
998 lck->offset = flock->fl_start;
999 i++;
1000 el = el->next;
1001 }
1002 unlock_flocks();
1003
1004 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1005 struct file_lock tmp_lock;
1006 int stored_rc;
1007
1008 tmp_lock.fl_start = lck->offset;
1009 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1010 0, lck->length, &tmp_lock,
1011 lck->type, 0);
1012 if (stored_rc)
1013 rc = stored_rc;
1014 list_del(&lck->llist);
1015 kfree(lck);
1016 }
1017
1018 out:
1019 cinode->can_cache_brlcks = false;
1020 mutex_unlock(&cinode->lock_mutex);
1021
1022 FreeXid(xid);
1023 return rc;
1024 err_out:
1025 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1026 list_del(&lck->llist);
1027 kfree(lck);
1028 }
1029 goto out;
1030 }
1031
1032 static int
1033 cifs_push_locks(struct cifsFileInfo *cfile)
1034 {
1035 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1036 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1037
1038 if ((tcon->ses->capabilities & CAP_UNIX) &&
1039 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1040 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1041 return cifs_push_posix_locks(cfile);
1042
1043 return cifs_push_mandatory_locks(cfile);
1044 }
1045
1046 static void
1047 cifs_read_flock(struct file_lock *flock, __u8 *type, int *lock, int *unlock,
1048 bool *wait_flag)
1049 {
1050 if (flock->fl_flags & FL_POSIX)
1051 cFYI(1, "Posix");
1052 if (flock->fl_flags & FL_FLOCK)
1053 cFYI(1, "Flock");
1054 if (flock->fl_flags & FL_SLEEP) {
1055 cFYI(1, "Blocking lock");
1056 *wait_flag = true;
1057 }
1058 if (flock->fl_flags & FL_ACCESS)
1059 cFYI(1, "Process suspended by mandatory locking - "
1060 "not implemented yet");
1061 if (flock->fl_flags & FL_LEASE)
1062 cFYI(1, "Lease on file - not implemented yet");
1063 if (flock->fl_flags &
1064 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
1065 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1066
1067 *type = LOCKING_ANDX_LARGE_FILES;
1068 if (flock->fl_type == F_WRLCK) {
1069 cFYI(1, "F_WRLCK ");
1070 *lock = 1;
1071 } else if (flock->fl_type == F_UNLCK) {
1072 cFYI(1, "F_UNLCK");
1073 *unlock = 1;
1074 /* Check if unlock includes more than one lock range */
1075 } else if (flock->fl_type == F_RDLCK) {
1076 cFYI(1, "F_RDLCK");
1077 *type |= LOCKING_ANDX_SHARED_LOCK;
1078 *lock = 1;
1079 } else if (flock->fl_type == F_EXLCK) {
1080 cFYI(1, "F_EXLCK");
1081 *lock = 1;
1082 } else if (flock->fl_type == F_SHLCK) {
1083 cFYI(1, "F_SHLCK");
1084 *type |= LOCKING_ANDX_SHARED_LOCK;
1085 *lock = 1;
1086 } else
1087 cFYI(1, "Unknown type of lock");
1088 }
1089
1090 static int
1091 cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
1092 bool wait_flag, bool posix_lck, int xid)
1093 {
1094 int rc = 0;
1095 __u64 length = 1 + flock->fl_end - flock->fl_start;
1096 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1097 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1098 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1099 __u16 netfid = cfile->netfid;
1100
1101 if (posix_lck) {
1102 int posix_lock_type;
1103
1104 rc = cifs_posix_lock_test(file, flock);
1105 if (!rc)
1106 return rc;
1107
1108 if (type & LOCKING_ANDX_SHARED_LOCK)
1109 posix_lock_type = CIFS_RDLCK;
1110 else
1111 posix_lock_type = CIFS_WRLCK;
1112 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1113 1 /* get */, length, flock,
1114 posix_lock_type, wait_flag);
1115 return rc;
1116 }
1117
1118 rc = cifs_lock_test(cinode, flock->fl_start, length, type, netfid,
1119 flock);
1120 if (!rc)
1121 return rc;
1122
1123 /* BB we could chain these into one lock request BB */
1124 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1125 flock->fl_start, 0, 1, type, 0, 0);
1126 if (rc == 0) {
1127 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1128 length, flock->fl_start, 1, 0,
1129 type, 0, 0);
1130 flock->fl_type = F_UNLCK;
1131 if (rc != 0)
1132 cERROR(1, "Error unlocking previously locked "
1133 "range %d during test of lock", rc);
1134 return 0;
1135 }
1136
1137 if (type & LOCKING_ANDX_SHARED_LOCK) {
1138 flock->fl_type = F_WRLCK;
1139 return 0;
1140 }
1141
1142 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1143 flock->fl_start, 0, 1,
1144 type | LOCKING_ANDX_SHARED_LOCK, 0, 0);
1145 if (rc == 0) {
1146 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1147 length, flock->fl_start, 1, 0,
1148 type | LOCKING_ANDX_SHARED_LOCK,
1149 0, 0);
1150 flock->fl_type = F_RDLCK;
1151 if (rc != 0)
1152 cERROR(1, "Error unlocking previously locked "
1153 "range %d during test of lock", rc);
1154 } else
1155 flock->fl_type = F_WRLCK;
1156
1157 return 0;
1158 }
1159
1160 static void
1161 cifs_move_llist(struct list_head *source, struct list_head *dest)
1162 {
1163 struct list_head *li, *tmp;
1164 list_for_each_safe(li, tmp, source)
1165 list_move(li, dest);
1166 }
1167
1168 static void
1169 cifs_free_llist(struct list_head *llist)
1170 {
1171 struct cifsLockInfo *li, *tmp;
1172 list_for_each_entry_safe(li, tmp, llist, llist) {
1173 cifs_del_lock_waiters(li);
1174 list_del(&li->llist);
1175 kfree(li);
1176 }
1177 }
1178
1179 static int
1180 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1181 {
1182 int rc = 0, stored_rc;
1183 int types[] = {LOCKING_ANDX_LARGE_FILES,
1184 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1185 unsigned int i;
1186 unsigned int max_num, num;
1187 LOCKING_ANDX_RANGE *buf, *cur;
1188 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1189 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1190 struct cifsLockInfo *li, *tmp;
1191 __u64 length = 1 + flock->fl_end - flock->fl_start;
1192 struct list_head tmp_llist;
1193
1194 INIT_LIST_HEAD(&tmp_llist);
1195
1196 max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1197 sizeof(LOCKING_ANDX_RANGE);
1198 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1199 if (!buf)
1200 return -ENOMEM;
1201
1202 mutex_lock(&cinode->lock_mutex);
1203 for (i = 0; i < 2; i++) {
1204 cur = buf;
1205 num = 0;
1206 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
1207 if (flock->fl_start > li->offset ||
1208 (flock->fl_start + length) <
1209 (li->offset + li->length))
1210 continue;
1211 if (current->tgid != li->pid)
1212 continue;
1213 if (cfile->netfid != li->netfid)
1214 continue;
1215 if (types[i] != li->type)
1216 continue;
1217 if (!cinode->can_cache_brlcks) {
1218 cur->Pid = cpu_to_le16(li->pid);
1219 cur->LengthLow = cpu_to_le32((u32)li->length);
1220 cur->LengthHigh =
1221 cpu_to_le32((u32)(li->length>>32));
1222 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1223 cur->OffsetHigh =
1224 cpu_to_le32((u32)(li->offset>>32));
1225 /*
1226 * We need to save a lock here to let us add
1227 * it again to the inode list if the unlock
1228 * range request fails on the server.
1229 */
1230 list_move(&li->llist, &tmp_llist);
1231 if (++num == max_num) {
1232 stored_rc = cifs_lockv(xid, tcon,
1233 cfile->netfid,
1234 li->type, num,
1235 0, buf);
1236 if (stored_rc) {
1237 /*
1238 * We failed on the unlock range
1239 * request - add all locks from
1240 * the tmp list to the head of
1241 * the inode list.
1242 */
1243 cifs_move_llist(&tmp_llist,
1244 &cinode->llist);
1245 rc = stored_rc;
1246 } else
1247 /*
1248 * The unlock range request
1249 * succeed - free the tmp list.
1250 */
1251 cifs_free_llist(&tmp_llist);
1252 cur = buf;
1253 num = 0;
1254 } else
1255 cur++;
1256 } else {
1257 /*
1258 * We can cache brlock requests - simply remove
1259 * a lock from the inode list.
1260 */
1261 list_del(&li->llist);
1262 cifs_del_lock_waiters(li);
1263 kfree(li);
1264 }
1265 }
1266 if (num) {
1267 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1268 types[i], num, 0, buf);
1269 if (stored_rc) {
1270 cifs_move_llist(&tmp_llist, &cinode->llist);
1271 rc = stored_rc;
1272 } else
1273 cifs_free_llist(&tmp_llist);
1274 }
1275 }
1276
1277 mutex_unlock(&cinode->lock_mutex);
1278 kfree(buf);
1279 return rc;
1280 }
1281
1282 static int
1283 cifs_setlk(struct file *file, struct file_lock *flock, __u8 type,
1284 bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1285 {
1286 int rc = 0;
1287 __u64 length = 1 + flock->fl_end - flock->fl_start;
1288 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1289 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1290 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
1291 __u16 netfid = cfile->netfid;
1292
1293 if (posix_lck) {
1294 int posix_lock_type;
1295
1296 rc = cifs_posix_lock_set(file, flock);
1297 if (!rc || rc < 0)
1298 return rc;
1299
1300 if (type & LOCKING_ANDX_SHARED_LOCK)
1301 posix_lock_type = CIFS_RDLCK;
1302 else
1303 posix_lock_type = CIFS_WRLCK;
1304
1305 if (unlock == 1)
1306 posix_lock_type = CIFS_UNLCK;
1307
1308 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1309 0 /* set */, length, flock,
1310 posix_lock_type, wait_flag);
1311 goto out;
1312 }
1313
1314 if (lock) {
1315 struct cifsLockInfo *lock;
1316
1317 lock = cifs_lock_init(flock->fl_start, length, type, netfid);
1318 if (!lock)
1319 return -ENOMEM;
1320
1321 rc = cifs_lock_add_if(cinode, lock, wait_flag);
1322 if (rc < 0)
1323 kfree(lock);
1324 if (rc <= 0)
1325 goto out;
1326
1327 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1328 flock->fl_start, 0, 1, type, wait_flag, 0);
1329 if (rc) {
1330 kfree(lock);
1331 goto out;
1332 }
1333
1334 cifs_lock_add(cinode, lock);
1335 } else if (unlock)
1336 rc = cifs_unlock_range(cfile, flock, xid);
1337
1338 out:
1339 if (flock->fl_flags & FL_POSIX)
1340 posix_lock_file_wait(file, flock);
1341 return rc;
1342 }
1343
1344 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1345 {
1346 int rc, xid;
1347 int lock = 0, unlock = 0;
1348 bool wait_flag = false;
1349 bool posix_lck = false;
1350 struct cifs_sb_info *cifs_sb;
1351 struct cifs_tcon *tcon;
1352 struct cifsInodeInfo *cinode;
1353 struct cifsFileInfo *cfile;
1354 __u16 netfid;
1355 __u8 type;
1356
1357 rc = -EACCES;
1358 xid = GetXid();
1359
1360 cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1361 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1362 flock->fl_start, flock->fl_end);
1363
1364 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag);
1365
1366 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1367 cfile = (struct cifsFileInfo *)file->private_data;
1368 tcon = tlink_tcon(cfile->tlink);
1369 netfid = cfile->netfid;
1370 cinode = CIFS_I(file->f_path.dentry->d_inode);
1371
1372 if ((tcon->ses->capabilities & CAP_UNIX) &&
1373 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1374 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1375 posix_lck = true;
1376 /*
1377 * BB add code here to normalize offset and length to account for
1378 * negative length which we can not accept over the wire.
1379 */
1380 if (IS_GETLK(cmd)) {
1381 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1382 FreeXid(xid);
1383 return rc;
1384 }
1385
1386 if (!lock && !unlock) {
1387 /*
1388 * if no lock or unlock then nothing to do since we do not
1389 * know what it is
1390 */
1391 FreeXid(xid);
1392 return -EOPNOTSUPP;
1393 }
1394
1395 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1396 xid);
1397 FreeXid(xid);
1398 return rc;
1399 }
1400
1401 /* update the file size (if needed) after a write */
1402 void
1403 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1404 unsigned int bytes_written)
1405 {
1406 loff_t end_of_write = offset + bytes_written;
1407
1408 if (end_of_write > cifsi->server_eof)
1409 cifsi->server_eof = end_of_write;
1410 }
1411
1412 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
1413 const char *write_data, size_t write_size,
1414 loff_t *poffset)
1415 {
1416 int rc = 0;
1417 unsigned int bytes_written = 0;
1418 unsigned int total_written;
1419 struct cifs_sb_info *cifs_sb;
1420 struct cifs_tcon *pTcon;
1421 int xid;
1422 struct dentry *dentry = open_file->dentry;
1423 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1424 struct cifs_io_parms io_parms;
1425
1426 cifs_sb = CIFS_SB(dentry->d_sb);
1427
1428 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1429 *poffset, dentry->d_name.name);
1430
1431 pTcon = tlink_tcon(open_file->tlink);
1432
1433 xid = GetXid();
1434
1435 for (total_written = 0; write_size > total_written;
1436 total_written += bytes_written) {
1437 rc = -EAGAIN;
1438 while (rc == -EAGAIN) {
1439 struct kvec iov[2];
1440 unsigned int len;
1441
1442 if (open_file->invalidHandle) {
1443 /* we could deadlock if we called
1444 filemap_fdatawait from here so tell
1445 reopen_file not to flush data to
1446 server now */
1447 rc = cifs_reopen_file(open_file, false);
1448 if (rc != 0)
1449 break;
1450 }
1451
1452 len = min((size_t)cifs_sb->wsize,
1453 write_size - total_written);
1454 /* iov[0] is reserved for smb header */
1455 iov[1].iov_base = (char *)write_data + total_written;
1456 iov[1].iov_len = len;
1457 io_parms.netfid = open_file->netfid;
1458 io_parms.pid = pid;
1459 io_parms.tcon = pTcon;
1460 io_parms.offset = *poffset;
1461 io_parms.length = len;
1462 rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1463 1, 0);
1464 }
1465 if (rc || (bytes_written == 0)) {
1466 if (total_written)
1467 break;
1468 else {
1469 FreeXid(xid);
1470 return rc;
1471 }
1472 } else {
1473 cifs_update_eof(cifsi, *poffset, bytes_written);
1474 *poffset += bytes_written;
1475 }
1476 }
1477
1478 cifs_stats_bytes_written(pTcon, total_written);
1479
1480 if (total_written > 0) {
1481 spin_lock(&dentry->d_inode->i_lock);
1482 if (*poffset > dentry->d_inode->i_size)
1483 i_size_write(dentry->d_inode, *poffset);
1484 spin_unlock(&dentry->d_inode->i_lock);
1485 }
1486 mark_inode_dirty_sync(dentry->d_inode);
1487 FreeXid(xid);
1488 return total_written;
1489 }
1490
1491 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1492 bool fsuid_only)
1493 {
1494 struct cifsFileInfo *open_file = NULL;
1495 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1496
1497 /* only filter by fsuid on multiuser mounts */
1498 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1499 fsuid_only = false;
1500
1501 spin_lock(&cifs_file_list_lock);
1502 /* we could simply get the first_list_entry since write-only entries
1503 are always at the end of the list but since the first entry might
1504 have a close pending, we go through the whole list */
1505 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1506 if (fsuid_only && open_file->uid != current_fsuid())
1507 continue;
1508 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1509 if (!open_file->invalidHandle) {
1510 /* found a good file */
1511 /* lock it so it will not be closed on us */
1512 cifsFileInfo_get(open_file);
1513 spin_unlock(&cifs_file_list_lock);
1514 return open_file;
1515 } /* else might as well continue, and look for
1516 another, or simply have the caller reopen it
1517 again rather than trying to fix this handle */
1518 } else /* write only file */
1519 break; /* write only files are last so must be done */
1520 }
1521 spin_unlock(&cifs_file_list_lock);
1522 return NULL;
1523 }
1524
1525 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1526 bool fsuid_only)
1527 {
1528 struct cifsFileInfo *open_file;
1529 struct cifs_sb_info *cifs_sb;
1530 bool any_available = false;
1531 int rc;
1532
1533 /* Having a null inode here (because mapping->host was set to zero by
1534 the VFS or MM) should not happen but we had reports of on oops (due to
1535 it being zero) during stress testcases so we need to check for it */
1536
1537 if (cifs_inode == NULL) {
1538 cERROR(1, "Null inode passed to cifs_writeable_file");
1539 dump_stack();
1540 return NULL;
1541 }
1542
1543 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1544
1545 /* only filter by fsuid on multiuser mounts */
1546 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1547 fsuid_only = false;
1548
1549 spin_lock(&cifs_file_list_lock);
1550 refind_writable:
1551 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1552 if (!any_available && open_file->pid != current->tgid)
1553 continue;
1554 if (fsuid_only && open_file->uid != current_fsuid())
1555 continue;
1556 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1557 cifsFileInfo_get(open_file);
1558
1559 if (!open_file->invalidHandle) {
1560 /* found a good writable file */
1561 spin_unlock(&cifs_file_list_lock);
1562 return open_file;
1563 }
1564
1565 spin_unlock(&cifs_file_list_lock);
1566
1567 /* Had to unlock since following call can block */
1568 rc = cifs_reopen_file(open_file, false);
1569 if (!rc)
1570 return open_file;
1571
1572 /* if it fails, try another handle if possible */
1573 cFYI(1, "wp failed on reopen file");
1574 cifsFileInfo_put(open_file);
1575
1576 spin_lock(&cifs_file_list_lock);
1577
1578 /* else we simply continue to the next entry. Thus
1579 we do not loop on reopen errors. If we
1580 can not reopen the file, for example if we
1581 reconnected to a server with another client
1582 racing to delete or lock the file we would not
1583 make progress if we restarted before the beginning
1584 of the loop here. */
1585 }
1586 }
1587 /* couldn't find useable FH with same pid, try any available */
1588 if (!any_available) {
1589 any_available = true;
1590 goto refind_writable;
1591 }
1592 spin_unlock(&cifs_file_list_lock);
1593 return NULL;
1594 }
1595
1596 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1597 {
1598 struct address_space *mapping = page->mapping;
1599 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1600 char *write_data;
1601 int rc = -EFAULT;
1602 int bytes_written = 0;
1603 struct inode *inode;
1604 struct cifsFileInfo *open_file;
1605
1606 if (!mapping || !mapping->host)
1607 return -EFAULT;
1608
1609 inode = page->mapping->host;
1610
1611 offset += (loff_t)from;
1612 write_data = kmap(page);
1613 write_data += from;
1614
1615 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1616 kunmap(page);
1617 return -EIO;
1618 }
1619
1620 /* racing with truncate? */
1621 if (offset > mapping->host->i_size) {
1622 kunmap(page);
1623 return 0; /* don't care */
1624 }
1625
1626 /* check to make sure that we are not extending the file */
1627 if (mapping->host->i_size - offset < (loff_t)to)
1628 to = (unsigned)(mapping->host->i_size - offset);
1629
1630 open_file = find_writable_file(CIFS_I(mapping->host), false);
1631 if (open_file) {
1632 bytes_written = cifs_write(open_file, open_file->pid,
1633 write_data, to - from, &offset);
1634 cifsFileInfo_put(open_file);
1635 /* Does mm or vfs already set times? */
1636 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1637 if ((bytes_written > 0) && (offset))
1638 rc = 0;
1639 else if (bytes_written < 0)
1640 rc = bytes_written;
1641 } else {
1642 cFYI(1, "No writeable filehandles for inode");
1643 rc = -EIO;
1644 }
1645
1646 kunmap(page);
1647 return rc;
1648 }
1649
1650 static int cifs_writepages(struct address_space *mapping,
1651 struct writeback_control *wbc)
1652 {
1653 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1654 bool done = false, scanned = false, range_whole = false;
1655 pgoff_t end, index;
1656 struct cifs_writedata *wdata;
1657 struct page *page;
1658 int rc = 0;
1659
1660 /*
1661 * If wsize is smaller than the page cache size, default to writing
1662 * one page at a time via cifs_writepage
1663 */
1664 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1665 return generic_writepages(mapping, wbc);
1666
1667 if (wbc->range_cyclic) {
1668 index = mapping->writeback_index; /* Start from prev offset */
1669 end = -1;
1670 } else {
1671 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1672 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1673 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1674 range_whole = true;
1675 scanned = true;
1676 }
1677 retry:
1678 while (!done && index <= end) {
1679 unsigned int i, nr_pages, found_pages;
1680 pgoff_t next = 0, tofind;
1681 struct page **pages;
1682
1683 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1684 end - index) + 1;
1685
1686 wdata = cifs_writedata_alloc((unsigned int)tofind);
1687 if (!wdata) {
1688 rc = -ENOMEM;
1689 break;
1690 }
1691
1692 /*
1693 * find_get_pages_tag seems to return a max of 256 on each
1694 * iteration, so we must call it several times in order to
1695 * fill the array or the wsize is effectively limited to
1696 * 256 * PAGE_CACHE_SIZE.
1697 */
1698 found_pages = 0;
1699 pages = wdata->pages;
1700 do {
1701 nr_pages = find_get_pages_tag(mapping, &index,
1702 PAGECACHE_TAG_DIRTY,
1703 tofind, pages);
1704 found_pages += nr_pages;
1705 tofind -= nr_pages;
1706 pages += nr_pages;
1707 } while (nr_pages && tofind && index <= end);
1708
1709 if (found_pages == 0) {
1710 kref_put(&wdata->refcount, cifs_writedata_release);
1711 break;
1712 }
1713
1714 nr_pages = 0;
1715 for (i = 0; i < found_pages; i++) {
1716 page = wdata->pages[i];
1717 /*
1718 * At this point we hold neither mapping->tree_lock nor
1719 * lock on the page itself: the page may be truncated or
1720 * invalidated (changing page->mapping to NULL), or even
1721 * swizzled back from swapper_space to tmpfs file
1722 * mapping
1723 */
1724
1725 if (nr_pages == 0)
1726 lock_page(page);
1727 else if (!trylock_page(page))
1728 break;
1729
1730 if (unlikely(page->mapping != mapping)) {
1731 unlock_page(page);
1732 break;
1733 }
1734
1735 if (!wbc->range_cyclic && page->index > end) {
1736 done = true;
1737 unlock_page(page);
1738 break;
1739 }
1740
1741 if (next && (page->index != next)) {
1742 /* Not next consecutive page */
1743 unlock_page(page);
1744 break;
1745 }
1746
1747 if (wbc->sync_mode != WB_SYNC_NONE)
1748 wait_on_page_writeback(page);
1749
1750 if (PageWriteback(page) ||
1751 !clear_page_dirty_for_io(page)) {
1752 unlock_page(page);
1753 break;
1754 }
1755
1756 /*
1757 * This actually clears the dirty bit in the radix tree.
1758 * See cifs_writepage() for more commentary.
1759 */
1760 set_page_writeback(page);
1761
1762 if (page_offset(page) >= mapping->host->i_size) {
1763 done = true;
1764 unlock_page(page);
1765 end_page_writeback(page);
1766 break;
1767 }
1768
1769 wdata->pages[i] = page;
1770 next = page->index + 1;
1771 ++nr_pages;
1772 }
1773
1774 /* reset index to refind any pages skipped */
1775 if (nr_pages == 0)
1776 index = wdata->pages[0]->index + 1;
1777
1778 /* put any pages we aren't going to use */
1779 for (i = nr_pages; i < found_pages; i++) {
1780 page_cache_release(wdata->pages[i]);
1781 wdata->pages[i] = NULL;
1782 }
1783
1784 /* nothing to write? */
1785 if (nr_pages == 0) {
1786 kref_put(&wdata->refcount, cifs_writedata_release);
1787 continue;
1788 }
1789
1790 wdata->sync_mode = wbc->sync_mode;
1791 wdata->nr_pages = nr_pages;
1792 wdata->offset = page_offset(wdata->pages[0]);
1793
1794 do {
1795 if (wdata->cfile != NULL)
1796 cifsFileInfo_put(wdata->cfile);
1797 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1798 false);
1799 if (!wdata->cfile) {
1800 cERROR(1, "No writable handles for inode");
1801 rc = -EBADF;
1802 break;
1803 }
1804 rc = cifs_async_writev(wdata);
1805 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1806
1807 for (i = 0; i < nr_pages; ++i)
1808 unlock_page(wdata->pages[i]);
1809
1810 /* send failure -- clean up the mess */
1811 if (rc != 0) {
1812 for (i = 0; i < nr_pages; ++i) {
1813 if (rc == -EAGAIN)
1814 redirty_page_for_writepage(wbc,
1815 wdata->pages[i]);
1816 else
1817 SetPageError(wdata->pages[i]);
1818 end_page_writeback(wdata->pages[i]);
1819 page_cache_release(wdata->pages[i]);
1820 }
1821 if (rc != -EAGAIN)
1822 mapping_set_error(mapping, rc);
1823 }
1824 kref_put(&wdata->refcount, cifs_writedata_release);
1825
1826 wbc->nr_to_write -= nr_pages;
1827 if (wbc->nr_to_write <= 0)
1828 done = true;
1829
1830 index = next;
1831 }
1832
1833 if (!scanned && !done) {
1834 /*
1835 * We hit the last page and there is more work to be done: wrap
1836 * back to the start of the file
1837 */
1838 scanned = true;
1839 index = 0;
1840 goto retry;
1841 }
1842
1843 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1844 mapping->writeback_index = index;
1845
1846 return rc;
1847 }
1848
1849 static int
1850 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1851 {
1852 int rc;
1853 int xid;
1854
1855 xid = GetXid();
1856 /* BB add check for wbc flags */
1857 page_cache_get(page);
1858 if (!PageUptodate(page))
1859 cFYI(1, "ppw - page not up to date");
1860
1861 /*
1862 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1863 *
1864 * A writepage() implementation always needs to do either this,
1865 * or re-dirty the page with "redirty_page_for_writepage()" in
1866 * the case of a failure.
1867 *
1868 * Just unlocking the page will cause the radix tree tag-bits
1869 * to fail to update with the state of the page correctly.
1870 */
1871 set_page_writeback(page);
1872 retry_write:
1873 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1874 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1875 goto retry_write;
1876 else if (rc == -EAGAIN)
1877 redirty_page_for_writepage(wbc, page);
1878 else if (rc != 0)
1879 SetPageError(page);
1880 else
1881 SetPageUptodate(page);
1882 end_page_writeback(page);
1883 page_cache_release(page);
1884 FreeXid(xid);
1885 return rc;
1886 }
1887
1888 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1889 {
1890 int rc = cifs_writepage_locked(page, wbc);
1891 unlock_page(page);
1892 return rc;
1893 }
1894
1895 static int cifs_write_end(struct file *file, struct address_space *mapping,
1896 loff_t pos, unsigned len, unsigned copied,
1897 struct page *page, void *fsdata)
1898 {
1899 int rc;
1900 struct inode *inode = mapping->host;
1901 struct cifsFileInfo *cfile = file->private_data;
1902 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1903 __u32 pid;
1904
1905 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1906 pid = cfile->pid;
1907 else
1908 pid = current->tgid;
1909
1910 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1911 page, pos, copied);
1912
1913 if (PageChecked(page)) {
1914 if (copied == len)
1915 SetPageUptodate(page);
1916 ClearPageChecked(page);
1917 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1918 SetPageUptodate(page);
1919
1920 if (!PageUptodate(page)) {
1921 char *page_data;
1922 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1923 int xid;
1924
1925 xid = GetXid();
1926 /* this is probably better than directly calling
1927 partialpage_write since in this function the file handle is
1928 known which we might as well leverage */
1929 /* BB check if anything else missing out of ppw
1930 such as updating last write time */
1931 page_data = kmap(page);
1932 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1933 /* if (rc < 0) should we set writebehind rc? */
1934 kunmap(page);
1935
1936 FreeXid(xid);
1937 } else {
1938 rc = copied;
1939 pos += copied;
1940 set_page_dirty(page);
1941 }
1942
1943 if (rc > 0) {
1944 spin_lock(&inode->i_lock);
1945 if (pos > inode->i_size)
1946 i_size_write(inode, pos);
1947 spin_unlock(&inode->i_lock);
1948 }
1949
1950 unlock_page(page);
1951 page_cache_release(page);
1952
1953 return rc;
1954 }
1955
1956 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1957 int datasync)
1958 {
1959 int xid;
1960 int rc = 0;
1961 struct cifs_tcon *tcon;
1962 struct cifsFileInfo *smbfile = file->private_data;
1963 struct inode *inode = file->f_path.dentry->d_inode;
1964 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1965
1966 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1967 if (rc)
1968 return rc;
1969 mutex_lock(&inode->i_mutex);
1970
1971 xid = GetXid();
1972
1973 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1974 file->f_path.dentry->d_name.name, datasync);
1975
1976 if (!CIFS_I(inode)->clientCanCacheRead) {
1977 rc = cifs_invalidate_mapping(inode);
1978 if (rc) {
1979 cFYI(1, "rc: %d during invalidate phase", rc);
1980 rc = 0; /* don't care about it in fsync */
1981 }
1982 }
1983
1984 tcon = tlink_tcon(smbfile->tlink);
1985 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1986 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1987
1988 FreeXid(xid);
1989 mutex_unlock(&inode->i_mutex);
1990 return rc;
1991 }
1992
1993 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1994 {
1995 int xid;
1996 int rc = 0;
1997 struct cifs_tcon *tcon;
1998 struct cifsFileInfo *smbfile = file->private_data;
1999 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2000 struct inode *inode = file->f_mapping->host;
2001
2002 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2003 if (rc)
2004 return rc;
2005 mutex_lock(&inode->i_mutex);
2006
2007 xid = GetXid();
2008
2009 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2010 file->f_path.dentry->d_name.name, datasync);
2011
2012 tcon = tlink_tcon(smbfile->tlink);
2013 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2014 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2015
2016 FreeXid(xid);
2017 mutex_unlock(&inode->i_mutex);
2018 return rc;
2019 }
2020
2021 /*
2022 * As file closes, flush all cached write data for this inode checking
2023 * for write behind errors.
2024 */
2025 int cifs_flush(struct file *file, fl_owner_t id)
2026 {
2027 struct inode *inode = file->f_path.dentry->d_inode;
2028 int rc = 0;
2029
2030 if (file->f_mode & FMODE_WRITE)
2031 rc = filemap_write_and_wait(inode->i_mapping);
2032
2033 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2034
2035 return rc;
2036 }
2037
2038 static int
2039 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2040 {
2041 int rc = 0;
2042 unsigned long i;
2043
2044 for (i = 0; i < num_pages; i++) {
2045 pages[i] = alloc_page(__GFP_HIGHMEM);
2046 if (!pages[i]) {
2047 /*
2048 * save number of pages we have already allocated and
2049 * return with ENOMEM error
2050 */
2051 num_pages = i;
2052 rc = -ENOMEM;
2053 goto error;
2054 }
2055 }
2056
2057 return rc;
2058
2059 error:
2060 for (i = 0; i < num_pages; i++)
2061 put_page(pages[i]);
2062 return rc;
2063 }
2064
2065 static inline
2066 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2067 {
2068 size_t num_pages;
2069 size_t clen;
2070
2071 clen = min_t(const size_t, len, wsize);
2072 num_pages = clen / PAGE_CACHE_SIZE;
2073 if (clen % PAGE_CACHE_SIZE)
2074 num_pages++;
2075
2076 if (cur_len)
2077 *cur_len = clen;
2078
2079 return num_pages;
2080 }
2081
2082 static ssize_t
2083 cifs_iovec_write(struct file *file, const struct iovec *iov,
2084 unsigned long nr_segs, loff_t *poffset)
2085 {
2086 unsigned int written;
2087 unsigned long num_pages, npages, i;
2088 size_t copied, len, cur_len;
2089 ssize_t total_written = 0;
2090 struct kvec *to_send;
2091 struct page **pages;
2092 struct iov_iter it;
2093 struct inode *inode;
2094 struct cifsFileInfo *open_file;
2095 struct cifs_tcon *pTcon;
2096 struct cifs_sb_info *cifs_sb;
2097 struct cifs_io_parms io_parms;
2098 int xid, rc;
2099 __u32 pid;
2100
2101 len = iov_length(iov, nr_segs);
2102 if (!len)
2103 return 0;
2104
2105 rc = generic_write_checks(file, poffset, &len, 0);
2106 if (rc)
2107 return rc;
2108
2109 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2110 num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2111
2112 pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2113 if (!pages)
2114 return -ENOMEM;
2115
2116 to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2117 if (!to_send) {
2118 kfree(pages);
2119 return -ENOMEM;
2120 }
2121
2122 rc = cifs_write_allocate_pages(pages, num_pages);
2123 if (rc) {
2124 kfree(pages);
2125 kfree(to_send);
2126 return rc;
2127 }
2128
2129 xid = GetXid();
2130 open_file = file->private_data;
2131
2132 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2133 pid = open_file->pid;
2134 else
2135 pid = current->tgid;
2136
2137 pTcon = tlink_tcon(open_file->tlink);
2138 inode = file->f_path.dentry->d_inode;
2139
2140 iov_iter_init(&it, iov, nr_segs, len, 0);
2141 npages = num_pages;
2142
2143 do {
2144 size_t save_len = cur_len;
2145 for (i = 0; i < npages; i++) {
2146 copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2147 copied = iov_iter_copy_from_user(pages[i], &it, 0,
2148 copied);
2149 cur_len -= copied;
2150 iov_iter_advance(&it, copied);
2151 to_send[i+1].iov_base = kmap(pages[i]);
2152 to_send[i+1].iov_len = copied;
2153 }
2154
2155 cur_len = save_len - cur_len;
2156
2157 do {
2158 if (open_file->invalidHandle) {
2159 rc = cifs_reopen_file(open_file, false);
2160 if (rc != 0)
2161 break;
2162 }
2163 io_parms.netfid = open_file->netfid;
2164 io_parms.pid = pid;
2165 io_parms.tcon = pTcon;
2166 io_parms.offset = *poffset;
2167 io_parms.length = cur_len;
2168 rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2169 npages, 0);
2170 } while (rc == -EAGAIN);
2171
2172 for (i = 0; i < npages; i++)
2173 kunmap(pages[i]);
2174
2175 if (written) {
2176 len -= written;
2177 total_written += written;
2178 cifs_update_eof(CIFS_I(inode), *poffset, written);
2179 *poffset += written;
2180 } else if (rc < 0) {
2181 if (!total_written)
2182 total_written = rc;
2183 break;
2184 }
2185
2186 /* get length and number of kvecs of the next write */
2187 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2188 } while (len > 0);
2189
2190 if (total_written > 0) {
2191 spin_lock(&inode->i_lock);
2192 if (*poffset > inode->i_size)
2193 i_size_write(inode, *poffset);
2194 spin_unlock(&inode->i_lock);
2195 }
2196
2197 cifs_stats_bytes_written(pTcon, total_written);
2198 mark_inode_dirty_sync(inode);
2199
2200 for (i = 0; i < num_pages; i++)
2201 put_page(pages[i]);
2202 kfree(to_send);
2203 kfree(pages);
2204 FreeXid(xid);
2205 return total_written;
2206 }
2207
2208 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2209 unsigned long nr_segs, loff_t pos)
2210 {
2211 ssize_t written;
2212 struct inode *inode;
2213
2214 inode = iocb->ki_filp->f_path.dentry->d_inode;
2215
2216 /*
2217 * BB - optimize the way when signing is disabled. We can drop this
2218 * extra memory-to-memory copying and use iovec buffers for constructing
2219 * write request.
2220 */
2221
2222 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2223 if (written > 0) {
2224 CIFS_I(inode)->invalid_mapping = true;
2225 iocb->ki_pos = pos;
2226 }
2227
2228 return written;
2229 }
2230
2231 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2232 unsigned long nr_segs, loff_t pos)
2233 {
2234 struct inode *inode;
2235
2236 inode = iocb->ki_filp->f_path.dentry->d_inode;
2237
2238 if (CIFS_I(inode)->clientCanCacheAll)
2239 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2240
2241 /*
2242 * In strict cache mode we need to write the data to the server exactly
2243 * from the pos to pos+len-1 rather than flush all affected pages
2244 * because it may cause a error with mandatory locks on these pages but
2245 * not on the region from pos to ppos+len-1.
2246 */
2247
2248 return cifs_user_writev(iocb, iov, nr_segs, pos);
2249 }
2250
2251 static ssize_t
2252 cifs_iovec_read(struct file *file, const struct iovec *iov,
2253 unsigned long nr_segs, loff_t *poffset)
2254 {
2255 int rc;
2256 int xid;
2257 ssize_t total_read;
2258 unsigned int bytes_read = 0;
2259 size_t len, cur_len;
2260 int iov_offset = 0;
2261 struct cifs_sb_info *cifs_sb;
2262 struct cifs_tcon *pTcon;
2263 struct cifsFileInfo *open_file;
2264 struct smb_com_read_rsp *pSMBr;
2265 struct cifs_io_parms io_parms;
2266 char *read_data;
2267 unsigned int rsize;
2268 __u32 pid;
2269
2270 if (!nr_segs)
2271 return 0;
2272
2273 len = iov_length(iov, nr_segs);
2274 if (!len)
2275 return 0;
2276
2277 xid = GetXid();
2278 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2279
2280 /* FIXME: set up handlers for larger reads and/or convert to async */
2281 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2282
2283 open_file = file->private_data;
2284 pTcon = tlink_tcon(open_file->tlink);
2285
2286 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2287 pid = open_file->pid;
2288 else
2289 pid = current->tgid;
2290
2291 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2292 cFYI(1, "attempting read on write only file instance");
2293
2294 for (total_read = 0; total_read < len; total_read += bytes_read) {
2295 cur_len = min_t(const size_t, len - total_read, rsize);
2296 rc = -EAGAIN;
2297 read_data = NULL;
2298
2299 while (rc == -EAGAIN) {
2300 int buf_type = CIFS_NO_BUFFER;
2301 if (open_file->invalidHandle) {
2302 rc = cifs_reopen_file(open_file, true);
2303 if (rc != 0)
2304 break;
2305 }
2306 io_parms.netfid = open_file->netfid;
2307 io_parms.pid = pid;
2308 io_parms.tcon = pTcon;
2309 io_parms.offset = *poffset;
2310 io_parms.length = cur_len;
2311 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2312 &read_data, &buf_type);
2313 pSMBr = (struct smb_com_read_rsp *)read_data;
2314 if (read_data) {
2315 char *data_offset = read_data + 4 +
2316 le16_to_cpu(pSMBr->DataOffset);
2317 if (memcpy_toiovecend(iov, data_offset,
2318 iov_offset, bytes_read))
2319 rc = -EFAULT;
2320 if (buf_type == CIFS_SMALL_BUFFER)
2321 cifs_small_buf_release(read_data);
2322 else if (buf_type == CIFS_LARGE_BUFFER)
2323 cifs_buf_release(read_data);
2324 read_data = NULL;
2325 iov_offset += bytes_read;
2326 }
2327 }
2328
2329 if (rc || (bytes_read == 0)) {
2330 if (total_read) {
2331 break;
2332 } else {
2333 FreeXid(xid);
2334 return rc;
2335 }
2336 } else {
2337 cifs_stats_bytes_read(pTcon, bytes_read);
2338 *poffset += bytes_read;
2339 }
2340 }
2341
2342 FreeXid(xid);
2343 return total_read;
2344 }
2345
2346 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2347 unsigned long nr_segs, loff_t pos)
2348 {
2349 ssize_t read;
2350
2351 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2352 if (read > 0)
2353 iocb->ki_pos = pos;
2354
2355 return read;
2356 }
2357
2358 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2359 unsigned long nr_segs, loff_t pos)
2360 {
2361 struct inode *inode;
2362
2363 inode = iocb->ki_filp->f_path.dentry->d_inode;
2364
2365 if (CIFS_I(inode)->clientCanCacheRead)
2366 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2367
2368 /*
2369 * In strict cache mode we need to read from the server all the time
2370 * if we don't have level II oplock because the server can delay mtime
2371 * change - so we can't make a decision about inode invalidating.
2372 * And we can also fail with pagereading if there are mandatory locks
2373 * on pages affected by this read but not on the region from pos to
2374 * pos+len-1.
2375 */
2376
2377 return cifs_user_readv(iocb, iov, nr_segs, pos);
2378 }
2379
2380 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2381 loff_t *poffset)
2382 {
2383 int rc = -EACCES;
2384 unsigned int bytes_read = 0;
2385 unsigned int total_read;
2386 unsigned int current_read_size;
2387 unsigned int rsize;
2388 struct cifs_sb_info *cifs_sb;
2389 struct cifs_tcon *pTcon;
2390 int xid;
2391 char *current_offset;
2392 struct cifsFileInfo *open_file;
2393 struct cifs_io_parms io_parms;
2394 int buf_type = CIFS_NO_BUFFER;
2395 __u32 pid;
2396
2397 xid = GetXid();
2398 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2399
2400 /* FIXME: set up handlers for larger reads and/or convert to async */
2401 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2402
2403 if (file->private_data == NULL) {
2404 rc = -EBADF;
2405 FreeXid(xid);
2406 return rc;
2407 }
2408 open_file = file->private_data;
2409 pTcon = tlink_tcon(open_file->tlink);
2410
2411 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2412 pid = open_file->pid;
2413 else
2414 pid = current->tgid;
2415
2416 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2417 cFYI(1, "attempting read on write only file instance");
2418
2419 for (total_read = 0, current_offset = read_data;
2420 read_size > total_read;
2421 total_read += bytes_read, current_offset += bytes_read) {
2422 current_read_size = min_t(uint, read_size - total_read, rsize);
2423
2424 /* For windows me and 9x we do not want to request more
2425 than it negotiated since it will refuse the read then */
2426 if ((pTcon->ses) &&
2427 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2428 current_read_size = min_t(uint, current_read_size,
2429 CIFSMaxBufSize);
2430 }
2431 rc = -EAGAIN;
2432 while (rc == -EAGAIN) {
2433 if (open_file->invalidHandle) {
2434 rc = cifs_reopen_file(open_file, true);
2435 if (rc != 0)
2436 break;
2437 }
2438 io_parms.netfid = open_file->netfid;
2439 io_parms.pid = pid;
2440 io_parms.tcon = pTcon;
2441 io_parms.offset = *poffset;
2442 io_parms.length = current_read_size;
2443 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2444 &current_offset, &buf_type);
2445 }
2446 if (rc || (bytes_read == 0)) {
2447 if (total_read) {
2448 break;
2449 } else {
2450 FreeXid(xid);
2451 return rc;
2452 }
2453 } else {
2454 cifs_stats_bytes_read(pTcon, total_read);
2455 *poffset += bytes_read;
2456 }
2457 }
2458 FreeXid(xid);
2459 return total_read;
2460 }
2461
2462 /*
2463 * If the page is mmap'ed into a process' page tables, then we need to make
2464 * sure that it doesn't change while being written back.
2465 */
2466 static int
2467 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2468 {
2469 struct page *page = vmf->page;
2470
2471 lock_page(page);
2472 return VM_FAULT_LOCKED;
2473 }
2474
2475 static struct vm_operations_struct cifs_file_vm_ops = {
2476 .fault = filemap_fault,
2477 .page_mkwrite = cifs_page_mkwrite,
2478 };
2479
2480 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2481 {
2482 int rc, xid;
2483 struct inode *inode = file->f_path.dentry->d_inode;
2484
2485 xid = GetXid();
2486
2487 if (!CIFS_I(inode)->clientCanCacheRead) {
2488 rc = cifs_invalidate_mapping(inode);
2489 if (rc)
2490 return rc;
2491 }
2492
2493 rc = generic_file_mmap(file, vma);
2494 if (rc == 0)
2495 vma->vm_ops = &cifs_file_vm_ops;
2496 FreeXid(xid);
2497 return rc;
2498 }
2499
2500 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2501 {
2502 int rc, xid;
2503
2504 xid = GetXid();
2505 rc = cifs_revalidate_file(file);
2506 if (rc) {
2507 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2508 FreeXid(xid);
2509 return rc;
2510 }
2511 rc = generic_file_mmap(file, vma);
2512 if (rc == 0)
2513 vma->vm_ops = &cifs_file_vm_ops;
2514 FreeXid(xid);
2515 return rc;
2516 }
2517
2518 static int cifs_readpages(struct file *file, struct address_space *mapping,
2519 struct list_head *page_list, unsigned num_pages)
2520 {
2521 int rc;
2522 struct list_head tmplist;
2523 struct cifsFileInfo *open_file = file->private_data;
2524 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2525 unsigned int rsize = cifs_sb->rsize;
2526 pid_t pid;
2527
2528 /*
2529 * Give up immediately if rsize is too small to read an entire page.
2530 * The VFS will fall back to readpage. We should never reach this
2531 * point however since we set ra_pages to 0 when the rsize is smaller
2532 * than a cache page.
2533 */
2534 if (unlikely(rsize < PAGE_CACHE_SIZE))
2535 return 0;
2536
2537 /*
2538 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2539 * immediately if the cookie is negative
2540 */
2541 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2542 &num_pages);
2543 if (rc == 0)
2544 return rc;
2545
2546 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2547 pid = open_file->pid;
2548 else
2549 pid = current->tgid;
2550
2551 rc = 0;
2552 INIT_LIST_HEAD(&tmplist);
2553
2554 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2555 mapping, num_pages);
2556
2557 /*
2558 * Start with the page at end of list and move it to private
2559 * list. Do the same with any following pages until we hit
2560 * the rsize limit, hit an index discontinuity, or run out of
2561 * pages. Issue the async read and then start the loop again
2562 * until the list is empty.
2563 *
2564 * Note that list order is important. The page_list is in
2565 * the order of declining indexes. When we put the pages in
2566 * the rdata->pages, then we want them in increasing order.
2567 */
2568 while (!list_empty(page_list)) {
2569 unsigned int bytes = PAGE_CACHE_SIZE;
2570 unsigned int expected_index;
2571 unsigned int nr_pages = 1;
2572 loff_t offset;
2573 struct page *page, *tpage;
2574 struct cifs_readdata *rdata;
2575
2576 page = list_entry(page_list->prev, struct page, lru);
2577
2578 /*
2579 * Lock the page and put it in the cache. Since no one else
2580 * should have access to this page, we're safe to simply set
2581 * PG_locked without checking it first.
2582 */
2583 __set_page_locked(page);
2584 rc = add_to_page_cache_locked(page, mapping,
2585 page->index, GFP_KERNEL);
2586
2587 /* give up if we can't stick it in the cache */
2588 if (rc) {
2589 __clear_page_locked(page);
2590 break;
2591 }
2592
2593 /* move first page to the tmplist */
2594 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2595 list_move_tail(&page->lru, &tmplist);
2596
2597 /* now try and add more pages onto the request */
2598 expected_index = page->index + 1;
2599 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2600 /* discontinuity ? */
2601 if (page->index != expected_index)
2602 break;
2603
2604 /* would this page push the read over the rsize? */
2605 if (bytes + PAGE_CACHE_SIZE > rsize)
2606 break;
2607
2608 __set_page_locked(page);
2609 if (add_to_page_cache_locked(page, mapping,
2610 page->index, GFP_KERNEL)) {
2611 __clear_page_locked(page);
2612 break;
2613 }
2614 list_move_tail(&page->lru, &tmplist);
2615 bytes += PAGE_CACHE_SIZE;
2616 expected_index++;
2617 nr_pages++;
2618 }
2619
2620 rdata = cifs_readdata_alloc(nr_pages);
2621 if (!rdata) {
2622 /* best to give up if we're out of mem */
2623 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2624 list_del(&page->lru);
2625 lru_cache_add_file(page);
2626 unlock_page(page);
2627 page_cache_release(page);
2628 }
2629 rc = -ENOMEM;
2630 break;
2631 }
2632
2633 spin_lock(&cifs_file_list_lock);
2634 cifsFileInfo_get(open_file);
2635 spin_unlock(&cifs_file_list_lock);
2636 rdata->cfile = open_file;
2637 rdata->mapping = mapping;
2638 rdata->offset = offset;
2639 rdata->bytes = bytes;
2640 rdata->pid = pid;
2641 list_splice_init(&tmplist, &rdata->pages);
2642
2643 do {
2644 if (open_file->invalidHandle) {
2645 rc = cifs_reopen_file(open_file, true);
2646 if (rc != 0)
2647 continue;
2648 }
2649 rc = cifs_async_readv(rdata);
2650 } while (rc == -EAGAIN);
2651
2652 if (rc != 0) {
2653 list_for_each_entry_safe(page, tpage, &rdata->pages,
2654 lru) {
2655 list_del(&page->lru);
2656 lru_cache_add_file(page);
2657 unlock_page(page);
2658 page_cache_release(page);
2659 }
2660 cifs_readdata_free(rdata);
2661 break;
2662 }
2663 }
2664
2665 return rc;
2666 }
2667
2668 static int cifs_readpage_worker(struct file *file, struct page *page,
2669 loff_t *poffset)
2670 {
2671 char *read_data;
2672 int rc;
2673
2674 /* Is the page cached? */
2675 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2676 if (rc == 0)
2677 goto read_complete;
2678
2679 page_cache_get(page);
2680 read_data = kmap(page);
2681 /* for reads over a certain size could initiate async read ahead */
2682
2683 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2684
2685 if (rc < 0)
2686 goto io_error;
2687 else
2688 cFYI(1, "Bytes read %d", rc);
2689
2690 file->f_path.dentry->d_inode->i_atime =
2691 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2692
2693 if (PAGE_CACHE_SIZE > rc)
2694 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2695
2696 flush_dcache_page(page);
2697 SetPageUptodate(page);
2698
2699 /* send this page to the cache */
2700 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2701
2702 rc = 0;
2703
2704 io_error:
2705 kunmap(page);
2706 page_cache_release(page);
2707
2708 read_complete:
2709 return rc;
2710 }
2711
2712 static int cifs_readpage(struct file *file, struct page *page)
2713 {
2714 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2715 int rc = -EACCES;
2716 int xid;
2717
2718 xid = GetXid();
2719
2720 if (file->private_data == NULL) {
2721 rc = -EBADF;
2722 FreeXid(xid);
2723 return rc;
2724 }
2725
2726 cFYI(1, "readpage %p at offset %d 0x%x\n",
2727 page, (int)offset, (int)offset);
2728
2729 rc = cifs_readpage_worker(file, page, &offset);
2730
2731 unlock_page(page);
2732
2733 FreeXid(xid);
2734 return rc;
2735 }
2736
2737 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2738 {
2739 struct cifsFileInfo *open_file;
2740
2741 spin_lock(&cifs_file_list_lock);
2742 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2743 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2744 spin_unlock(&cifs_file_list_lock);
2745 return 1;
2746 }
2747 }
2748 spin_unlock(&cifs_file_list_lock);
2749 return 0;
2750 }
2751
2752 /* We do not want to update the file size from server for inodes
2753 open for write - to avoid races with writepage extending
2754 the file - in the future we could consider allowing
2755 refreshing the inode only on increases in the file size
2756 but this is tricky to do without racing with writebehind
2757 page caching in the current Linux kernel design */
2758 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2759 {
2760 if (!cifsInode)
2761 return true;
2762
2763 if (is_inode_writable(cifsInode)) {
2764 /* This inode is open for write at least once */
2765 struct cifs_sb_info *cifs_sb;
2766
2767 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2768 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2769 /* since no page cache to corrupt on directio
2770 we can change size safely */
2771 return true;
2772 }
2773
2774 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2775 return true;
2776
2777 return false;
2778 } else
2779 return true;
2780 }
2781
2782 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2783 loff_t pos, unsigned len, unsigned flags,
2784 struct page **pagep, void **fsdata)
2785 {
2786 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2787 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2788 loff_t page_start = pos & PAGE_MASK;
2789 loff_t i_size;
2790 struct page *page;
2791 int rc = 0;
2792
2793 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2794
2795 page = grab_cache_page_write_begin(mapping, index, flags);
2796 if (!page) {
2797 rc = -ENOMEM;
2798 goto out;
2799 }
2800
2801 if (PageUptodate(page))
2802 goto out;
2803
2804 /*
2805 * If we write a full page it will be up to date, no need to read from
2806 * the server. If the write is short, we'll end up doing a sync write
2807 * instead.
2808 */
2809 if (len == PAGE_CACHE_SIZE)
2810 goto out;
2811
2812 /*
2813 * optimize away the read when we have an oplock, and we're not
2814 * expecting to use any of the data we'd be reading in. That
2815 * is, when the page lies beyond the EOF, or straddles the EOF
2816 * and the write will cover all of the existing data.
2817 */
2818 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2819 i_size = i_size_read(mapping->host);
2820 if (page_start >= i_size ||
2821 (offset == 0 && (pos + len) >= i_size)) {
2822 zero_user_segments(page, 0, offset,
2823 offset + len,
2824 PAGE_CACHE_SIZE);
2825 /*
2826 * PageChecked means that the parts of the page
2827 * to which we're not writing are considered up
2828 * to date. Once the data is copied to the
2829 * page, it can be set uptodate.
2830 */
2831 SetPageChecked(page);
2832 goto out;
2833 }
2834 }
2835
2836 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2837 /*
2838 * might as well read a page, it is fast enough. If we get
2839 * an error, we don't need to return it. cifs_write_end will
2840 * do a sync write instead since PG_uptodate isn't set.
2841 */
2842 cifs_readpage_worker(file, page, &page_start);
2843 } else {
2844 /* we could try using another file handle if there is one -
2845 but how would we lock it to prevent close of that handle
2846 racing with this read? In any case
2847 this will be written out by write_end so is fine */
2848 }
2849 out:
2850 *pagep = page;
2851 return rc;
2852 }
2853
2854 static int cifs_release_page(struct page *page, gfp_t gfp)
2855 {
2856 if (PagePrivate(page))
2857 return 0;
2858
2859 return cifs_fscache_release_page(page, gfp);
2860 }
2861
2862 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2863 {
2864 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2865
2866 if (offset == 0)
2867 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2868 }
2869
2870 static int cifs_launder_page(struct page *page)
2871 {
2872 int rc = 0;
2873 loff_t range_start = page_offset(page);
2874 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2875 struct writeback_control wbc = {
2876 .sync_mode = WB_SYNC_ALL,
2877 .nr_to_write = 0,
2878 .range_start = range_start,
2879 .range_end = range_end,
2880 };
2881
2882 cFYI(1, "Launder page: %p", page);
2883
2884 if (clear_page_dirty_for_io(page))
2885 rc = cifs_writepage_locked(page, &wbc);
2886
2887 cifs_fscache_invalidate_page(page, page->mapping->host);
2888 return rc;
2889 }
2890
2891 void cifs_oplock_break(struct work_struct *work)
2892 {
2893 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2894 oplock_break);
2895 struct inode *inode = cfile->dentry->d_inode;
2896 struct cifsInodeInfo *cinode = CIFS_I(inode);
2897 int rc = 0;
2898
2899 if (inode && S_ISREG(inode->i_mode)) {
2900 if (cinode->clientCanCacheRead)
2901 break_lease(inode, O_RDONLY);
2902 else
2903 break_lease(inode, O_WRONLY);
2904 rc = filemap_fdatawrite(inode->i_mapping);
2905 if (cinode->clientCanCacheRead == 0) {
2906 rc = filemap_fdatawait(inode->i_mapping);
2907 mapping_set_error(inode->i_mapping, rc);
2908 invalidate_remote_inode(inode);
2909 }
2910 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2911 }
2912
2913 rc = cifs_push_locks(cfile);
2914 if (rc)
2915 cERROR(1, "Push locks rc = %d", rc);
2916
2917 /*
2918 * releasing stale oplock after recent reconnect of smb session using
2919 * a now incorrect file handle is not a data integrity issue but do
2920 * not bother sending an oplock release if session to server still is
2921 * disconnected since oplock already released by the server
2922 */
2923 if (!cfile->oplock_break_cancelled) {
2924 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2925 current->tgid, 0, 0, 0, 0,
2926 LOCKING_ANDX_OPLOCK_RELEASE, false,
2927 cinode->clientCanCacheRead ? 1 : 0);
2928 cFYI(1, "Oplock release rc = %d", rc);
2929 }
2930 }
2931
2932 const struct address_space_operations cifs_addr_ops = {
2933 .readpage = cifs_readpage,
2934 .readpages = cifs_readpages,
2935 .writepage = cifs_writepage,
2936 .writepages = cifs_writepages,
2937 .write_begin = cifs_write_begin,
2938 .write_end = cifs_write_end,
2939 .set_page_dirty = __set_page_dirty_nobuffers,
2940 .releasepage = cifs_release_page,
2941 .invalidatepage = cifs_invalidate_page,
2942 .launder_page = cifs_launder_page,
2943 };
2944
2945 /*
2946 * cifs_readpages requires the server to support a buffer large enough to
2947 * contain the header plus one complete page of data. Otherwise, we need
2948 * to leave cifs_readpages out of the address space operations.
2949 */
2950 const struct address_space_operations cifs_addr_ops_smallbuf = {
2951 .readpage = cifs_readpage,
2952 .writepage = cifs_writepage,
2953 .writepages = cifs_writepages,
2954 .write_begin = cifs_write_begin,
2955 .write_end = cifs_write_end,
2956 .set_page_dirty = __set_page_dirty_nobuffers,
2957 .releasepage = cifs_release_page,
2958 .invalidatepage = cifs_invalidate_page,
2959 .launder_page = cifs_launder_page,
2960 };