]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - fs/cifs/file.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cifs: call cifs_update_eof with i_lock held
[mirror_ubuntu-bionic-kernel.git] / fs / cifs / file.c
1 /*
2 * fs/cifs/file.c
3 *
4 * vfs operations that deal with files
5 *
6 * Copyright (C) International Business Machines Corp., 2002,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 (tcon->ses->server->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 (tcon->ses->server->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 FL_POSIX locks can be
964 * added to the list while we are holding cinode->lock_mutex that
965 * protects 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 el = locks_to_send.next;
977 lock_flocks();
978 cifs_for_each_lock(cfile->dentry->d_inode, before) {
979 flock = *before;
980 if ((flock->fl_flags & FL_POSIX) == 0)
981 continue;
982 if (el == &locks_to_send) {
983 /*
984 * The list ended. We don't have enough allocated
985 * structures - something is really wrong.
986 */
987 cERROR(1, "Can't push all brlocks!");
988 break;
989 }
990 length = 1 + flock->fl_end - flock->fl_start;
991 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
992 type = CIFS_RDLCK;
993 else
994 type = CIFS_WRLCK;
995 lck = list_entry(el, struct lock_to_push, llist);
996 lck->pid = flock->fl_pid;
997 lck->netfid = cfile->netfid;
998 lck->length = length;
999 lck->type = type;
1000 lck->offset = flock->fl_start;
1001 el = el->next;
1002 }
1003 unlock_flocks();
1004
1005 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1006 struct file_lock tmp_lock;
1007 int stored_rc;
1008
1009 tmp_lock.fl_start = lck->offset;
1010 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1011 0, lck->length, &tmp_lock,
1012 lck->type, 0);
1013 if (stored_rc)
1014 rc = stored_rc;
1015 list_del(&lck->llist);
1016 kfree(lck);
1017 }
1018
1019 out:
1020 cinode->can_cache_brlcks = false;
1021 mutex_unlock(&cinode->lock_mutex);
1022
1023 FreeXid(xid);
1024 return rc;
1025 err_out:
1026 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1027 list_del(&lck->llist);
1028 kfree(lck);
1029 }
1030 goto out;
1031 }
1032
1033 static int
1034 cifs_push_locks(struct cifsFileInfo *cfile)
1035 {
1036 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1037 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1038
1039 if ((tcon->ses->capabilities & CAP_UNIX) &&
1040 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1041 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1042 return cifs_push_posix_locks(cfile);
1043
1044 return cifs_push_mandatory_locks(cfile);
1045 }
1046
1047 static void
1048 cifs_read_flock(struct file_lock *flock, __u8 *type, int *lock, int *unlock,
1049 bool *wait_flag)
1050 {
1051 if (flock->fl_flags & FL_POSIX)
1052 cFYI(1, "Posix");
1053 if (flock->fl_flags & FL_FLOCK)
1054 cFYI(1, "Flock");
1055 if (flock->fl_flags & FL_SLEEP) {
1056 cFYI(1, "Blocking lock");
1057 *wait_flag = true;
1058 }
1059 if (flock->fl_flags & FL_ACCESS)
1060 cFYI(1, "Process suspended by mandatory locking - "
1061 "not implemented yet");
1062 if (flock->fl_flags & FL_LEASE)
1063 cFYI(1, "Lease on file - not implemented yet");
1064 if (flock->fl_flags &
1065 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
1066 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1067
1068 *type = LOCKING_ANDX_LARGE_FILES;
1069 if (flock->fl_type == F_WRLCK) {
1070 cFYI(1, "F_WRLCK ");
1071 *lock = 1;
1072 } else if (flock->fl_type == F_UNLCK) {
1073 cFYI(1, "F_UNLCK");
1074 *unlock = 1;
1075 /* Check if unlock includes more than one lock range */
1076 } else if (flock->fl_type == F_RDLCK) {
1077 cFYI(1, "F_RDLCK");
1078 *type |= LOCKING_ANDX_SHARED_LOCK;
1079 *lock = 1;
1080 } else if (flock->fl_type == F_EXLCK) {
1081 cFYI(1, "F_EXLCK");
1082 *lock = 1;
1083 } else if (flock->fl_type == F_SHLCK) {
1084 cFYI(1, "F_SHLCK");
1085 *type |= LOCKING_ANDX_SHARED_LOCK;
1086 *lock = 1;
1087 } else
1088 cFYI(1, "Unknown type of lock");
1089 }
1090
1091 static int
1092 cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
1093 bool wait_flag, bool posix_lck, int xid)
1094 {
1095 int rc = 0;
1096 __u64 length = 1 + flock->fl_end - flock->fl_start;
1097 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1098 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1099 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1100 __u16 netfid = cfile->netfid;
1101
1102 if (posix_lck) {
1103 int posix_lock_type;
1104
1105 rc = cifs_posix_lock_test(file, flock);
1106 if (!rc)
1107 return rc;
1108
1109 if (type & LOCKING_ANDX_SHARED_LOCK)
1110 posix_lock_type = CIFS_RDLCK;
1111 else
1112 posix_lock_type = CIFS_WRLCK;
1113 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1114 1 /* get */, length, flock,
1115 posix_lock_type, wait_flag);
1116 return rc;
1117 }
1118
1119 rc = cifs_lock_test(cinode, flock->fl_start, length, type, netfid,
1120 flock);
1121 if (!rc)
1122 return rc;
1123
1124 /* BB we could chain these into one lock request BB */
1125 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1126 flock->fl_start, 0, 1, type, 0, 0);
1127 if (rc == 0) {
1128 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1129 length, flock->fl_start, 1, 0,
1130 type, 0, 0);
1131 flock->fl_type = F_UNLCK;
1132 if (rc != 0)
1133 cERROR(1, "Error unlocking previously locked "
1134 "range %d during test of lock", rc);
1135 return 0;
1136 }
1137
1138 if (type & LOCKING_ANDX_SHARED_LOCK) {
1139 flock->fl_type = F_WRLCK;
1140 return 0;
1141 }
1142
1143 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1144 flock->fl_start, 0, 1,
1145 type | LOCKING_ANDX_SHARED_LOCK, 0, 0);
1146 if (rc == 0) {
1147 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1148 length, flock->fl_start, 1, 0,
1149 type | LOCKING_ANDX_SHARED_LOCK,
1150 0, 0);
1151 flock->fl_type = F_RDLCK;
1152 if (rc != 0)
1153 cERROR(1, "Error unlocking previously locked "
1154 "range %d during test of lock", rc);
1155 } else
1156 flock->fl_type = F_WRLCK;
1157
1158 return 0;
1159 }
1160
1161 static void
1162 cifs_move_llist(struct list_head *source, struct list_head *dest)
1163 {
1164 struct list_head *li, *tmp;
1165 list_for_each_safe(li, tmp, source)
1166 list_move(li, dest);
1167 }
1168
1169 static void
1170 cifs_free_llist(struct list_head *llist)
1171 {
1172 struct cifsLockInfo *li, *tmp;
1173 list_for_each_entry_safe(li, tmp, llist, llist) {
1174 cifs_del_lock_waiters(li);
1175 list_del(&li->llist);
1176 kfree(li);
1177 }
1178 }
1179
1180 static int
1181 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1182 {
1183 int rc = 0, stored_rc;
1184 int types[] = {LOCKING_ANDX_LARGE_FILES,
1185 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1186 unsigned int i;
1187 unsigned int max_num, num;
1188 LOCKING_ANDX_RANGE *buf, *cur;
1189 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1190 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1191 struct cifsLockInfo *li, *tmp;
1192 __u64 length = 1 + flock->fl_end - flock->fl_start;
1193 struct list_head tmp_llist;
1194
1195 INIT_LIST_HEAD(&tmp_llist);
1196
1197 max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1198 sizeof(LOCKING_ANDX_RANGE);
1199 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1200 if (!buf)
1201 return -ENOMEM;
1202
1203 mutex_lock(&cinode->lock_mutex);
1204 for (i = 0; i < 2; i++) {
1205 cur = buf;
1206 num = 0;
1207 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
1208 if (flock->fl_start > li->offset ||
1209 (flock->fl_start + length) <
1210 (li->offset + li->length))
1211 continue;
1212 if (current->tgid != li->pid)
1213 continue;
1214 if (cfile->netfid != li->netfid)
1215 continue;
1216 if (types[i] != li->type)
1217 continue;
1218 if (!cinode->can_cache_brlcks) {
1219 cur->Pid = cpu_to_le16(li->pid);
1220 cur->LengthLow = cpu_to_le32((u32)li->length);
1221 cur->LengthHigh =
1222 cpu_to_le32((u32)(li->length>>32));
1223 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1224 cur->OffsetHigh =
1225 cpu_to_le32((u32)(li->offset>>32));
1226 /*
1227 * We need to save a lock here to let us add
1228 * it again to the inode list if the unlock
1229 * range request fails on the server.
1230 */
1231 list_move(&li->llist, &tmp_llist);
1232 if (++num == max_num) {
1233 stored_rc = cifs_lockv(xid, tcon,
1234 cfile->netfid,
1235 li->type, num,
1236 0, buf);
1237 if (stored_rc) {
1238 /*
1239 * We failed on the unlock range
1240 * request - add all locks from
1241 * the tmp list to the head of
1242 * the inode list.
1243 */
1244 cifs_move_llist(&tmp_llist,
1245 &cinode->llist);
1246 rc = stored_rc;
1247 } else
1248 /*
1249 * The unlock range request
1250 * succeed - free the tmp list.
1251 */
1252 cifs_free_llist(&tmp_llist);
1253 cur = buf;
1254 num = 0;
1255 } else
1256 cur++;
1257 } else {
1258 /*
1259 * We can cache brlock requests - simply remove
1260 * a lock from the inode list.
1261 */
1262 list_del(&li->llist);
1263 cifs_del_lock_waiters(li);
1264 kfree(li);
1265 }
1266 }
1267 if (num) {
1268 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1269 types[i], num, 0, buf);
1270 if (stored_rc) {
1271 cifs_move_llist(&tmp_llist, &cinode->llist);
1272 rc = stored_rc;
1273 } else
1274 cifs_free_llist(&tmp_llist);
1275 }
1276 }
1277
1278 mutex_unlock(&cinode->lock_mutex);
1279 kfree(buf);
1280 return rc;
1281 }
1282
1283 static int
1284 cifs_setlk(struct file *file, struct file_lock *flock, __u8 type,
1285 bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1286 {
1287 int rc = 0;
1288 __u64 length = 1 + flock->fl_end - flock->fl_start;
1289 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1290 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1291 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
1292 __u16 netfid = cfile->netfid;
1293
1294 if (posix_lck) {
1295 int posix_lock_type;
1296
1297 rc = cifs_posix_lock_set(file, flock);
1298 if (!rc || rc < 0)
1299 return rc;
1300
1301 if (type & LOCKING_ANDX_SHARED_LOCK)
1302 posix_lock_type = CIFS_RDLCK;
1303 else
1304 posix_lock_type = CIFS_WRLCK;
1305
1306 if (unlock == 1)
1307 posix_lock_type = CIFS_UNLCK;
1308
1309 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1310 0 /* set */, length, flock,
1311 posix_lock_type, wait_flag);
1312 goto out;
1313 }
1314
1315 if (lock) {
1316 struct cifsLockInfo *lock;
1317
1318 lock = cifs_lock_init(flock->fl_start, length, type, netfid);
1319 if (!lock)
1320 return -ENOMEM;
1321
1322 rc = cifs_lock_add_if(cinode, lock, wait_flag);
1323 if (rc < 0)
1324 kfree(lock);
1325 if (rc <= 0)
1326 goto out;
1327
1328 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1329 flock->fl_start, 0, 1, type, wait_flag, 0);
1330 if (rc) {
1331 kfree(lock);
1332 goto out;
1333 }
1334
1335 cifs_lock_add(cinode, lock);
1336 } else if (unlock)
1337 rc = cifs_unlock_range(cfile, flock, xid);
1338
1339 out:
1340 if (flock->fl_flags & FL_POSIX)
1341 posix_lock_file_wait(file, flock);
1342 return rc;
1343 }
1344
1345 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1346 {
1347 int rc, xid;
1348 int lock = 0, unlock = 0;
1349 bool wait_flag = false;
1350 bool posix_lck = false;
1351 struct cifs_sb_info *cifs_sb;
1352 struct cifs_tcon *tcon;
1353 struct cifsInodeInfo *cinode;
1354 struct cifsFileInfo *cfile;
1355 __u16 netfid;
1356 __u8 type;
1357
1358 rc = -EACCES;
1359 xid = GetXid();
1360
1361 cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1362 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1363 flock->fl_start, flock->fl_end);
1364
1365 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag);
1366
1367 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1368 cfile = (struct cifsFileInfo *)file->private_data;
1369 tcon = tlink_tcon(cfile->tlink);
1370 netfid = cfile->netfid;
1371 cinode = CIFS_I(file->f_path.dentry->d_inode);
1372
1373 if ((tcon->ses->capabilities & CAP_UNIX) &&
1374 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1375 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1376 posix_lck = true;
1377 /*
1378 * BB add code here to normalize offset and length to account for
1379 * negative length which we can not accept over the wire.
1380 */
1381 if (IS_GETLK(cmd)) {
1382 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1383 FreeXid(xid);
1384 return rc;
1385 }
1386
1387 if (!lock && !unlock) {
1388 /*
1389 * if no lock or unlock then nothing to do since we do not
1390 * know what it is
1391 */
1392 FreeXid(xid);
1393 return -EOPNOTSUPP;
1394 }
1395
1396 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1397 xid);
1398 FreeXid(xid);
1399 return rc;
1400 }
1401
1402 /*
1403 * update the file size (if needed) after a write. Should be called with
1404 * the inode->i_lock held
1405 */
1406 void
1407 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1408 unsigned int bytes_written)
1409 {
1410 loff_t end_of_write = offset + bytes_written;
1411
1412 if (end_of_write > cifsi->server_eof)
1413 cifsi->server_eof = end_of_write;
1414 }
1415
1416 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
1417 const char *write_data, size_t write_size,
1418 loff_t *poffset)
1419 {
1420 int rc = 0;
1421 unsigned int bytes_written = 0;
1422 unsigned int total_written;
1423 struct cifs_sb_info *cifs_sb;
1424 struct cifs_tcon *pTcon;
1425 int xid;
1426 struct dentry *dentry = open_file->dentry;
1427 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1428 struct cifs_io_parms io_parms;
1429
1430 cifs_sb = CIFS_SB(dentry->d_sb);
1431
1432 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1433 *poffset, dentry->d_name.name);
1434
1435 pTcon = tlink_tcon(open_file->tlink);
1436
1437 xid = GetXid();
1438
1439 for (total_written = 0; write_size > total_written;
1440 total_written += bytes_written) {
1441 rc = -EAGAIN;
1442 while (rc == -EAGAIN) {
1443 struct kvec iov[2];
1444 unsigned int len;
1445
1446 if (open_file->invalidHandle) {
1447 /* we could deadlock if we called
1448 filemap_fdatawait from here so tell
1449 reopen_file not to flush data to
1450 server now */
1451 rc = cifs_reopen_file(open_file, false);
1452 if (rc != 0)
1453 break;
1454 }
1455
1456 len = min((size_t)cifs_sb->wsize,
1457 write_size - total_written);
1458 /* iov[0] is reserved for smb header */
1459 iov[1].iov_base = (char *)write_data + total_written;
1460 iov[1].iov_len = len;
1461 io_parms.netfid = open_file->netfid;
1462 io_parms.pid = pid;
1463 io_parms.tcon = pTcon;
1464 io_parms.offset = *poffset;
1465 io_parms.length = len;
1466 rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1467 1, 0);
1468 }
1469 if (rc || (bytes_written == 0)) {
1470 if (total_written)
1471 break;
1472 else {
1473 FreeXid(xid);
1474 return rc;
1475 }
1476 } else {
1477 spin_lock(&dentry->d_inode->i_lock);
1478 cifs_update_eof(cifsi, *poffset, bytes_written);
1479 spin_unlock(&dentry->d_inode->i_lock);
1480 *poffset += bytes_written;
1481 }
1482 }
1483
1484 cifs_stats_bytes_written(pTcon, total_written);
1485
1486 if (total_written > 0) {
1487 spin_lock(&dentry->d_inode->i_lock);
1488 if (*poffset > dentry->d_inode->i_size)
1489 i_size_write(dentry->d_inode, *poffset);
1490 spin_unlock(&dentry->d_inode->i_lock);
1491 }
1492 mark_inode_dirty_sync(dentry->d_inode);
1493 FreeXid(xid);
1494 return total_written;
1495 }
1496
1497 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1498 bool fsuid_only)
1499 {
1500 struct cifsFileInfo *open_file = NULL;
1501 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1502
1503 /* only filter by fsuid on multiuser mounts */
1504 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1505 fsuid_only = false;
1506
1507 spin_lock(&cifs_file_list_lock);
1508 /* we could simply get the first_list_entry since write-only entries
1509 are always at the end of the list but since the first entry might
1510 have a close pending, we go through the whole list */
1511 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1512 if (fsuid_only && open_file->uid != current_fsuid())
1513 continue;
1514 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1515 if (!open_file->invalidHandle) {
1516 /* found a good file */
1517 /* lock it so it will not be closed on us */
1518 cifsFileInfo_get(open_file);
1519 spin_unlock(&cifs_file_list_lock);
1520 return open_file;
1521 } /* else might as well continue, and look for
1522 another, or simply have the caller reopen it
1523 again rather than trying to fix this handle */
1524 } else /* write only file */
1525 break; /* write only files are last so must be done */
1526 }
1527 spin_unlock(&cifs_file_list_lock);
1528 return NULL;
1529 }
1530
1531 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1532 bool fsuid_only)
1533 {
1534 struct cifsFileInfo *open_file;
1535 struct cifs_sb_info *cifs_sb;
1536 bool any_available = false;
1537 int rc;
1538
1539 /* Having a null inode here (because mapping->host was set to zero by
1540 the VFS or MM) should not happen but we had reports of on oops (due to
1541 it being zero) during stress testcases so we need to check for it */
1542
1543 if (cifs_inode == NULL) {
1544 cERROR(1, "Null inode passed to cifs_writeable_file");
1545 dump_stack();
1546 return NULL;
1547 }
1548
1549 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1550
1551 /* only filter by fsuid on multiuser mounts */
1552 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1553 fsuid_only = false;
1554
1555 spin_lock(&cifs_file_list_lock);
1556 refind_writable:
1557 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1558 if (!any_available && open_file->pid != current->tgid)
1559 continue;
1560 if (fsuid_only && open_file->uid != current_fsuid())
1561 continue;
1562 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1563 cifsFileInfo_get(open_file);
1564
1565 if (!open_file->invalidHandle) {
1566 /* found a good writable file */
1567 spin_unlock(&cifs_file_list_lock);
1568 return open_file;
1569 }
1570
1571 spin_unlock(&cifs_file_list_lock);
1572
1573 /* Had to unlock since following call can block */
1574 rc = cifs_reopen_file(open_file, false);
1575 if (!rc)
1576 return open_file;
1577
1578 /* if it fails, try another handle if possible */
1579 cFYI(1, "wp failed on reopen file");
1580 cifsFileInfo_put(open_file);
1581
1582 spin_lock(&cifs_file_list_lock);
1583
1584 /* else we simply continue to the next entry. Thus
1585 we do not loop on reopen errors. If we
1586 can not reopen the file, for example if we
1587 reconnected to a server with another client
1588 racing to delete or lock the file we would not
1589 make progress if we restarted before the beginning
1590 of the loop here. */
1591 }
1592 }
1593 /* couldn't find useable FH with same pid, try any available */
1594 if (!any_available) {
1595 any_available = true;
1596 goto refind_writable;
1597 }
1598 spin_unlock(&cifs_file_list_lock);
1599 return NULL;
1600 }
1601
1602 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1603 {
1604 struct address_space *mapping = page->mapping;
1605 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1606 char *write_data;
1607 int rc = -EFAULT;
1608 int bytes_written = 0;
1609 struct inode *inode;
1610 struct cifsFileInfo *open_file;
1611
1612 if (!mapping || !mapping->host)
1613 return -EFAULT;
1614
1615 inode = page->mapping->host;
1616
1617 offset += (loff_t)from;
1618 write_data = kmap(page);
1619 write_data += from;
1620
1621 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1622 kunmap(page);
1623 return -EIO;
1624 }
1625
1626 /* racing with truncate? */
1627 if (offset > mapping->host->i_size) {
1628 kunmap(page);
1629 return 0; /* don't care */
1630 }
1631
1632 /* check to make sure that we are not extending the file */
1633 if (mapping->host->i_size - offset < (loff_t)to)
1634 to = (unsigned)(mapping->host->i_size - offset);
1635
1636 open_file = find_writable_file(CIFS_I(mapping->host), false);
1637 if (open_file) {
1638 bytes_written = cifs_write(open_file, open_file->pid,
1639 write_data, to - from, &offset);
1640 cifsFileInfo_put(open_file);
1641 /* Does mm or vfs already set times? */
1642 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1643 if ((bytes_written > 0) && (offset))
1644 rc = 0;
1645 else if (bytes_written < 0)
1646 rc = bytes_written;
1647 } else {
1648 cFYI(1, "No writeable filehandles for inode");
1649 rc = -EIO;
1650 }
1651
1652 kunmap(page);
1653 return rc;
1654 }
1655
1656 /*
1657 * Marshal up the iov array, reserving the first one for the header. Also,
1658 * set wdata->bytes.
1659 */
1660 static void
1661 cifs_writepages_marshal_iov(struct kvec *iov, struct cifs_writedata *wdata)
1662 {
1663 int i;
1664 struct inode *inode = wdata->cfile->dentry->d_inode;
1665 loff_t size = i_size_read(inode);
1666
1667 /* marshal up the pages into iov array */
1668 wdata->bytes = 0;
1669 for (i = 0; i < wdata->nr_pages; i++) {
1670 iov[i + 1].iov_len = min(size - page_offset(wdata->pages[i]),
1671 (loff_t)PAGE_CACHE_SIZE);
1672 iov[i + 1].iov_base = kmap(wdata->pages[i]);
1673 wdata->bytes += iov[i + 1].iov_len;
1674 }
1675 }
1676
1677 static int cifs_writepages(struct address_space *mapping,
1678 struct writeback_control *wbc)
1679 {
1680 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1681 bool done = false, scanned = false, range_whole = false;
1682 pgoff_t end, index;
1683 struct cifs_writedata *wdata;
1684 struct page *page;
1685 int rc = 0;
1686
1687 /*
1688 * If wsize is smaller than the page cache size, default to writing
1689 * one page at a time via cifs_writepage
1690 */
1691 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1692 return generic_writepages(mapping, wbc);
1693
1694 if (wbc->range_cyclic) {
1695 index = mapping->writeback_index; /* Start from prev offset */
1696 end = -1;
1697 } else {
1698 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1699 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1700 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1701 range_whole = true;
1702 scanned = true;
1703 }
1704 retry:
1705 while (!done && index <= end) {
1706 unsigned int i, nr_pages, found_pages;
1707 pgoff_t next = 0, tofind;
1708 struct page **pages;
1709
1710 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1711 end - index) + 1;
1712
1713 wdata = cifs_writedata_alloc((unsigned int)tofind,
1714 cifs_writev_complete);
1715 if (!wdata) {
1716 rc = -ENOMEM;
1717 break;
1718 }
1719
1720 /*
1721 * find_get_pages_tag seems to return a max of 256 on each
1722 * iteration, so we must call it several times in order to
1723 * fill the array or the wsize is effectively limited to
1724 * 256 * PAGE_CACHE_SIZE.
1725 */
1726 found_pages = 0;
1727 pages = wdata->pages;
1728 do {
1729 nr_pages = find_get_pages_tag(mapping, &index,
1730 PAGECACHE_TAG_DIRTY,
1731 tofind, pages);
1732 found_pages += nr_pages;
1733 tofind -= nr_pages;
1734 pages += nr_pages;
1735 } while (nr_pages && tofind && index <= end);
1736
1737 if (found_pages == 0) {
1738 kref_put(&wdata->refcount, cifs_writedata_release);
1739 break;
1740 }
1741
1742 nr_pages = 0;
1743 for (i = 0; i < found_pages; i++) {
1744 page = wdata->pages[i];
1745 /*
1746 * At this point we hold neither mapping->tree_lock nor
1747 * lock on the page itself: the page may be truncated or
1748 * invalidated (changing page->mapping to NULL), or even
1749 * swizzled back from swapper_space to tmpfs file
1750 * mapping
1751 */
1752
1753 if (nr_pages == 0)
1754 lock_page(page);
1755 else if (!trylock_page(page))
1756 break;
1757
1758 if (unlikely(page->mapping != mapping)) {
1759 unlock_page(page);
1760 break;
1761 }
1762
1763 if (!wbc->range_cyclic && page->index > end) {
1764 done = true;
1765 unlock_page(page);
1766 break;
1767 }
1768
1769 if (next && (page->index != next)) {
1770 /* Not next consecutive page */
1771 unlock_page(page);
1772 break;
1773 }
1774
1775 if (wbc->sync_mode != WB_SYNC_NONE)
1776 wait_on_page_writeback(page);
1777
1778 if (PageWriteback(page) ||
1779 !clear_page_dirty_for_io(page)) {
1780 unlock_page(page);
1781 break;
1782 }
1783
1784 /*
1785 * This actually clears the dirty bit in the radix tree.
1786 * See cifs_writepage() for more commentary.
1787 */
1788 set_page_writeback(page);
1789
1790 if (page_offset(page) >= mapping->host->i_size) {
1791 done = true;
1792 unlock_page(page);
1793 end_page_writeback(page);
1794 break;
1795 }
1796
1797 wdata->pages[i] = page;
1798 next = page->index + 1;
1799 ++nr_pages;
1800 }
1801
1802 /* reset index to refind any pages skipped */
1803 if (nr_pages == 0)
1804 index = wdata->pages[0]->index + 1;
1805
1806 /* put any pages we aren't going to use */
1807 for (i = nr_pages; i < found_pages; i++) {
1808 page_cache_release(wdata->pages[i]);
1809 wdata->pages[i] = NULL;
1810 }
1811
1812 /* nothing to write? */
1813 if (nr_pages == 0) {
1814 kref_put(&wdata->refcount, cifs_writedata_release);
1815 continue;
1816 }
1817
1818 wdata->sync_mode = wbc->sync_mode;
1819 wdata->nr_pages = nr_pages;
1820 wdata->offset = page_offset(wdata->pages[0]);
1821 wdata->marshal_iov = cifs_writepages_marshal_iov;
1822
1823 do {
1824 if (wdata->cfile != NULL)
1825 cifsFileInfo_put(wdata->cfile);
1826 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1827 false);
1828 if (!wdata->cfile) {
1829 cERROR(1, "No writable handles for inode");
1830 rc = -EBADF;
1831 break;
1832 }
1833 wdata->pid = wdata->cfile->pid;
1834 rc = cifs_async_writev(wdata);
1835 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1836
1837 for (i = 0; i < nr_pages; ++i)
1838 unlock_page(wdata->pages[i]);
1839
1840 /* send failure -- clean up the mess */
1841 if (rc != 0) {
1842 for (i = 0; i < nr_pages; ++i) {
1843 if (rc == -EAGAIN)
1844 redirty_page_for_writepage(wbc,
1845 wdata->pages[i]);
1846 else
1847 SetPageError(wdata->pages[i]);
1848 end_page_writeback(wdata->pages[i]);
1849 page_cache_release(wdata->pages[i]);
1850 }
1851 if (rc != -EAGAIN)
1852 mapping_set_error(mapping, rc);
1853 }
1854 kref_put(&wdata->refcount, cifs_writedata_release);
1855
1856 wbc->nr_to_write -= nr_pages;
1857 if (wbc->nr_to_write <= 0)
1858 done = true;
1859
1860 index = next;
1861 }
1862
1863 if (!scanned && !done) {
1864 /*
1865 * We hit the last page and there is more work to be done: wrap
1866 * back to the start of the file
1867 */
1868 scanned = true;
1869 index = 0;
1870 goto retry;
1871 }
1872
1873 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1874 mapping->writeback_index = index;
1875
1876 return rc;
1877 }
1878
1879 static int
1880 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1881 {
1882 int rc;
1883 int xid;
1884
1885 xid = GetXid();
1886 /* BB add check for wbc flags */
1887 page_cache_get(page);
1888 if (!PageUptodate(page))
1889 cFYI(1, "ppw - page not up to date");
1890
1891 /*
1892 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1893 *
1894 * A writepage() implementation always needs to do either this,
1895 * or re-dirty the page with "redirty_page_for_writepage()" in
1896 * the case of a failure.
1897 *
1898 * Just unlocking the page will cause the radix tree tag-bits
1899 * to fail to update with the state of the page correctly.
1900 */
1901 set_page_writeback(page);
1902 retry_write:
1903 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1904 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1905 goto retry_write;
1906 else if (rc == -EAGAIN)
1907 redirty_page_for_writepage(wbc, page);
1908 else if (rc != 0)
1909 SetPageError(page);
1910 else
1911 SetPageUptodate(page);
1912 end_page_writeback(page);
1913 page_cache_release(page);
1914 FreeXid(xid);
1915 return rc;
1916 }
1917
1918 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1919 {
1920 int rc = cifs_writepage_locked(page, wbc);
1921 unlock_page(page);
1922 return rc;
1923 }
1924
1925 static int cifs_write_end(struct file *file, struct address_space *mapping,
1926 loff_t pos, unsigned len, unsigned copied,
1927 struct page *page, void *fsdata)
1928 {
1929 int rc;
1930 struct inode *inode = mapping->host;
1931 struct cifsFileInfo *cfile = file->private_data;
1932 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1933 __u32 pid;
1934
1935 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1936 pid = cfile->pid;
1937 else
1938 pid = current->tgid;
1939
1940 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1941 page, pos, copied);
1942
1943 if (PageChecked(page)) {
1944 if (copied == len)
1945 SetPageUptodate(page);
1946 ClearPageChecked(page);
1947 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1948 SetPageUptodate(page);
1949
1950 if (!PageUptodate(page)) {
1951 char *page_data;
1952 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1953 int xid;
1954
1955 xid = GetXid();
1956 /* this is probably better than directly calling
1957 partialpage_write since in this function the file handle is
1958 known which we might as well leverage */
1959 /* BB check if anything else missing out of ppw
1960 such as updating last write time */
1961 page_data = kmap(page);
1962 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1963 /* if (rc < 0) should we set writebehind rc? */
1964 kunmap(page);
1965
1966 FreeXid(xid);
1967 } else {
1968 rc = copied;
1969 pos += copied;
1970 set_page_dirty(page);
1971 }
1972
1973 if (rc > 0) {
1974 spin_lock(&inode->i_lock);
1975 if (pos > inode->i_size)
1976 i_size_write(inode, pos);
1977 spin_unlock(&inode->i_lock);
1978 }
1979
1980 unlock_page(page);
1981 page_cache_release(page);
1982
1983 return rc;
1984 }
1985
1986 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1987 int datasync)
1988 {
1989 int xid;
1990 int rc = 0;
1991 struct cifs_tcon *tcon;
1992 struct cifsFileInfo *smbfile = file->private_data;
1993 struct inode *inode = file->f_path.dentry->d_inode;
1994 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1995
1996 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1997 if (rc)
1998 return rc;
1999 mutex_lock(&inode->i_mutex);
2000
2001 xid = GetXid();
2002
2003 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2004 file->f_path.dentry->d_name.name, datasync);
2005
2006 if (!CIFS_I(inode)->clientCanCacheRead) {
2007 rc = cifs_invalidate_mapping(inode);
2008 if (rc) {
2009 cFYI(1, "rc: %d during invalidate phase", rc);
2010 rc = 0; /* don't care about it in fsync */
2011 }
2012 }
2013
2014 tcon = tlink_tcon(smbfile->tlink);
2015 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2016 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2017
2018 FreeXid(xid);
2019 mutex_unlock(&inode->i_mutex);
2020 return rc;
2021 }
2022
2023 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2024 {
2025 int xid;
2026 int rc = 0;
2027 struct cifs_tcon *tcon;
2028 struct cifsFileInfo *smbfile = file->private_data;
2029 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2030 struct inode *inode = file->f_mapping->host;
2031
2032 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2033 if (rc)
2034 return rc;
2035 mutex_lock(&inode->i_mutex);
2036
2037 xid = GetXid();
2038
2039 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2040 file->f_path.dentry->d_name.name, datasync);
2041
2042 tcon = tlink_tcon(smbfile->tlink);
2043 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2044 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2045
2046 FreeXid(xid);
2047 mutex_unlock(&inode->i_mutex);
2048 return rc;
2049 }
2050
2051 /*
2052 * As file closes, flush all cached write data for this inode checking
2053 * for write behind errors.
2054 */
2055 int cifs_flush(struct file *file, fl_owner_t id)
2056 {
2057 struct inode *inode = file->f_path.dentry->d_inode;
2058 int rc = 0;
2059
2060 if (file->f_mode & FMODE_WRITE)
2061 rc = filemap_write_and_wait(inode->i_mapping);
2062
2063 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2064
2065 return rc;
2066 }
2067
2068 static int
2069 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2070 {
2071 int rc = 0;
2072 unsigned long i;
2073
2074 for (i = 0; i < num_pages; i++) {
2075 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2076 if (!pages[i]) {
2077 /*
2078 * save number of pages we have already allocated and
2079 * return with ENOMEM error
2080 */
2081 num_pages = i;
2082 rc = -ENOMEM;
2083 break;
2084 }
2085 }
2086
2087 if (rc) {
2088 for (i = 0; i < num_pages; i++)
2089 put_page(pages[i]);
2090 }
2091 return rc;
2092 }
2093
2094 static inline
2095 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2096 {
2097 size_t num_pages;
2098 size_t clen;
2099
2100 clen = min_t(const size_t, len, wsize);
2101 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2102
2103 if (cur_len)
2104 *cur_len = clen;
2105
2106 return num_pages;
2107 }
2108
2109 static ssize_t
2110 cifs_iovec_write(struct file *file, const struct iovec *iov,
2111 unsigned long nr_segs, loff_t *poffset)
2112 {
2113 unsigned int written;
2114 unsigned long num_pages, npages, i;
2115 size_t copied, len, cur_len;
2116 ssize_t total_written = 0;
2117 struct kvec *to_send;
2118 struct page **pages;
2119 struct iov_iter it;
2120 struct inode *inode;
2121 struct cifsFileInfo *open_file;
2122 struct cifs_tcon *pTcon;
2123 struct cifs_sb_info *cifs_sb;
2124 struct cifs_io_parms io_parms;
2125 int xid, rc;
2126 __u32 pid;
2127
2128 len = iov_length(iov, nr_segs);
2129 if (!len)
2130 return 0;
2131
2132 rc = generic_write_checks(file, poffset, &len, 0);
2133 if (rc)
2134 return rc;
2135
2136 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2137 num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2138
2139 pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2140 if (!pages)
2141 return -ENOMEM;
2142
2143 to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2144 if (!to_send) {
2145 kfree(pages);
2146 return -ENOMEM;
2147 }
2148
2149 rc = cifs_write_allocate_pages(pages, num_pages);
2150 if (rc) {
2151 kfree(pages);
2152 kfree(to_send);
2153 return rc;
2154 }
2155
2156 xid = GetXid();
2157 open_file = file->private_data;
2158
2159 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2160 pid = open_file->pid;
2161 else
2162 pid = current->tgid;
2163
2164 pTcon = tlink_tcon(open_file->tlink);
2165 inode = file->f_path.dentry->d_inode;
2166
2167 iov_iter_init(&it, iov, nr_segs, len, 0);
2168 npages = num_pages;
2169
2170 do {
2171 size_t save_len = cur_len;
2172 for (i = 0; i < npages; i++) {
2173 copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2174 copied = iov_iter_copy_from_user(pages[i], &it, 0,
2175 copied);
2176 cur_len -= copied;
2177 iov_iter_advance(&it, copied);
2178 to_send[i+1].iov_base = kmap(pages[i]);
2179 to_send[i+1].iov_len = copied;
2180 }
2181
2182 cur_len = save_len - cur_len;
2183
2184 do {
2185 if (open_file->invalidHandle) {
2186 rc = cifs_reopen_file(open_file, false);
2187 if (rc != 0)
2188 break;
2189 }
2190 io_parms.netfid = open_file->netfid;
2191 io_parms.pid = pid;
2192 io_parms.tcon = pTcon;
2193 io_parms.offset = *poffset;
2194 io_parms.length = cur_len;
2195 rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2196 npages, 0);
2197 } while (rc == -EAGAIN);
2198
2199 for (i = 0; i < npages; i++)
2200 kunmap(pages[i]);
2201
2202 if (written) {
2203 len -= written;
2204 total_written += written;
2205 spin_lock(&inode->i_lock);
2206 cifs_update_eof(CIFS_I(inode), *poffset, written);
2207 spin_unlock(&inode->i_lock);
2208 *poffset += written;
2209 } else if (rc < 0) {
2210 if (!total_written)
2211 total_written = rc;
2212 break;
2213 }
2214
2215 /* get length and number of kvecs of the next write */
2216 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2217 } while (len > 0);
2218
2219 if (total_written > 0) {
2220 spin_lock(&inode->i_lock);
2221 if (*poffset > inode->i_size)
2222 i_size_write(inode, *poffset);
2223 spin_unlock(&inode->i_lock);
2224 }
2225
2226 cifs_stats_bytes_written(pTcon, total_written);
2227 mark_inode_dirty_sync(inode);
2228
2229 for (i = 0; i < num_pages; i++)
2230 put_page(pages[i]);
2231 kfree(to_send);
2232 kfree(pages);
2233 FreeXid(xid);
2234 return total_written;
2235 }
2236
2237 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2238 unsigned long nr_segs, loff_t pos)
2239 {
2240 ssize_t written;
2241 struct inode *inode;
2242
2243 inode = iocb->ki_filp->f_path.dentry->d_inode;
2244
2245 /*
2246 * BB - optimize the way when signing is disabled. We can drop this
2247 * extra memory-to-memory copying and use iovec buffers for constructing
2248 * write request.
2249 */
2250
2251 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2252 if (written > 0) {
2253 CIFS_I(inode)->invalid_mapping = true;
2254 iocb->ki_pos = pos;
2255 }
2256
2257 return written;
2258 }
2259
2260 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2261 unsigned long nr_segs, loff_t pos)
2262 {
2263 struct inode *inode;
2264
2265 inode = iocb->ki_filp->f_path.dentry->d_inode;
2266
2267 if (CIFS_I(inode)->clientCanCacheAll)
2268 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2269
2270 /*
2271 * In strict cache mode we need to write the data to the server exactly
2272 * from the pos to pos+len-1 rather than flush all affected pages
2273 * because it may cause a error with mandatory locks on these pages but
2274 * not on the region from pos to ppos+len-1.
2275 */
2276
2277 return cifs_user_writev(iocb, iov, nr_segs, pos);
2278 }
2279
2280 static ssize_t
2281 cifs_iovec_read(struct file *file, const struct iovec *iov,
2282 unsigned long nr_segs, loff_t *poffset)
2283 {
2284 int rc;
2285 int xid;
2286 ssize_t total_read;
2287 unsigned int bytes_read = 0;
2288 size_t len, cur_len;
2289 int iov_offset = 0;
2290 struct cifs_sb_info *cifs_sb;
2291 struct cifs_tcon *pTcon;
2292 struct cifsFileInfo *open_file;
2293 struct smb_com_read_rsp *pSMBr;
2294 struct cifs_io_parms io_parms;
2295 char *read_data;
2296 unsigned int rsize;
2297 __u32 pid;
2298
2299 if (!nr_segs)
2300 return 0;
2301
2302 len = iov_length(iov, nr_segs);
2303 if (!len)
2304 return 0;
2305
2306 xid = GetXid();
2307 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2308
2309 /* FIXME: set up handlers for larger reads and/or convert to async */
2310 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2311
2312 open_file = file->private_data;
2313 pTcon = tlink_tcon(open_file->tlink);
2314
2315 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2316 pid = open_file->pid;
2317 else
2318 pid = current->tgid;
2319
2320 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2321 cFYI(1, "attempting read on write only file instance");
2322
2323 for (total_read = 0; total_read < len; total_read += bytes_read) {
2324 cur_len = min_t(const size_t, len - total_read, rsize);
2325 rc = -EAGAIN;
2326 read_data = NULL;
2327
2328 while (rc == -EAGAIN) {
2329 int buf_type = CIFS_NO_BUFFER;
2330 if (open_file->invalidHandle) {
2331 rc = cifs_reopen_file(open_file, true);
2332 if (rc != 0)
2333 break;
2334 }
2335 io_parms.netfid = open_file->netfid;
2336 io_parms.pid = pid;
2337 io_parms.tcon = pTcon;
2338 io_parms.offset = *poffset;
2339 io_parms.length = cur_len;
2340 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2341 &read_data, &buf_type);
2342 pSMBr = (struct smb_com_read_rsp *)read_data;
2343 if (read_data) {
2344 char *data_offset = read_data + 4 +
2345 le16_to_cpu(pSMBr->DataOffset);
2346 if (memcpy_toiovecend(iov, data_offset,
2347 iov_offset, bytes_read))
2348 rc = -EFAULT;
2349 if (buf_type == CIFS_SMALL_BUFFER)
2350 cifs_small_buf_release(read_data);
2351 else if (buf_type == CIFS_LARGE_BUFFER)
2352 cifs_buf_release(read_data);
2353 read_data = NULL;
2354 iov_offset += bytes_read;
2355 }
2356 }
2357
2358 if (rc || (bytes_read == 0)) {
2359 if (total_read) {
2360 break;
2361 } else {
2362 FreeXid(xid);
2363 return rc;
2364 }
2365 } else {
2366 cifs_stats_bytes_read(pTcon, bytes_read);
2367 *poffset += bytes_read;
2368 }
2369 }
2370
2371 FreeXid(xid);
2372 return total_read;
2373 }
2374
2375 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2376 unsigned long nr_segs, loff_t pos)
2377 {
2378 ssize_t read;
2379
2380 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2381 if (read > 0)
2382 iocb->ki_pos = pos;
2383
2384 return read;
2385 }
2386
2387 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2388 unsigned long nr_segs, loff_t pos)
2389 {
2390 struct inode *inode;
2391
2392 inode = iocb->ki_filp->f_path.dentry->d_inode;
2393
2394 if (CIFS_I(inode)->clientCanCacheRead)
2395 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2396
2397 /*
2398 * In strict cache mode we need to read from the server all the time
2399 * if we don't have level II oplock because the server can delay mtime
2400 * change - so we can't make a decision about inode invalidating.
2401 * And we can also fail with pagereading if there are mandatory locks
2402 * on pages affected by this read but not on the region from pos to
2403 * pos+len-1.
2404 */
2405
2406 return cifs_user_readv(iocb, iov, nr_segs, pos);
2407 }
2408
2409 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2410 loff_t *poffset)
2411 {
2412 int rc = -EACCES;
2413 unsigned int bytes_read = 0;
2414 unsigned int total_read;
2415 unsigned int current_read_size;
2416 unsigned int rsize;
2417 struct cifs_sb_info *cifs_sb;
2418 struct cifs_tcon *pTcon;
2419 int xid;
2420 char *current_offset;
2421 struct cifsFileInfo *open_file;
2422 struct cifs_io_parms io_parms;
2423 int buf_type = CIFS_NO_BUFFER;
2424 __u32 pid;
2425
2426 xid = GetXid();
2427 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2428
2429 /* FIXME: set up handlers for larger reads and/or convert to async */
2430 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2431
2432 if (file->private_data == NULL) {
2433 rc = -EBADF;
2434 FreeXid(xid);
2435 return rc;
2436 }
2437 open_file = file->private_data;
2438 pTcon = tlink_tcon(open_file->tlink);
2439
2440 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2441 pid = open_file->pid;
2442 else
2443 pid = current->tgid;
2444
2445 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2446 cFYI(1, "attempting read on write only file instance");
2447
2448 for (total_read = 0, current_offset = read_data;
2449 read_size > total_read;
2450 total_read += bytes_read, current_offset += bytes_read) {
2451 current_read_size = min_t(uint, read_size - total_read, rsize);
2452
2453 /* For windows me and 9x we do not want to request more
2454 than it negotiated since it will refuse the read then */
2455 if ((pTcon->ses) &&
2456 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2457 current_read_size = min_t(uint, current_read_size,
2458 CIFSMaxBufSize);
2459 }
2460 rc = -EAGAIN;
2461 while (rc == -EAGAIN) {
2462 if (open_file->invalidHandle) {
2463 rc = cifs_reopen_file(open_file, true);
2464 if (rc != 0)
2465 break;
2466 }
2467 io_parms.netfid = open_file->netfid;
2468 io_parms.pid = pid;
2469 io_parms.tcon = pTcon;
2470 io_parms.offset = *poffset;
2471 io_parms.length = current_read_size;
2472 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2473 &current_offset, &buf_type);
2474 }
2475 if (rc || (bytes_read == 0)) {
2476 if (total_read) {
2477 break;
2478 } else {
2479 FreeXid(xid);
2480 return rc;
2481 }
2482 } else {
2483 cifs_stats_bytes_read(pTcon, total_read);
2484 *poffset += bytes_read;
2485 }
2486 }
2487 FreeXid(xid);
2488 return total_read;
2489 }
2490
2491 /*
2492 * If the page is mmap'ed into a process' page tables, then we need to make
2493 * sure that it doesn't change while being written back.
2494 */
2495 static int
2496 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2497 {
2498 struct page *page = vmf->page;
2499
2500 lock_page(page);
2501 return VM_FAULT_LOCKED;
2502 }
2503
2504 static struct vm_operations_struct cifs_file_vm_ops = {
2505 .fault = filemap_fault,
2506 .page_mkwrite = cifs_page_mkwrite,
2507 };
2508
2509 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2510 {
2511 int rc, xid;
2512 struct inode *inode = file->f_path.dentry->d_inode;
2513
2514 xid = GetXid();
2515
2516 if (!CIFS_I(inode)->clientCanCacheRead) {
2517 rc = cifs_invalidate_mapping(inode);
2518 if (rc)
2519 return rc;
2520 }
2521
2522 rc = generic_file_mmap(file, vma);
2523 if (rc == 0)
2524 vma->vm_ops = &cifs_file_vm_ops;
2525 FreeXid(xid);
2526 return rc;
2527 }
2528
2529 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2530 {
2531 int rc, xid;
2532
2533 xid = GetXid();
2534 rc = cifs_revalidate_file(file);
2535 if (rc) {
2536 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2537 FreeXid(xid);
2538 return rc;
2539 }
2540 rc = generic_file_mmap(file, vma);
2541 if (rc == 0)
2542 vma->vm_ops = &cifs_file_vm_ops;
2543 FreeXid(xid);
2544 return rc;
2545 }
2546
2547 static int cifs_readpages(struct file *file, struct address_space *mapping,
2548 struct list_head *page_list, unsigned num_pages)
2549 {
2550 int rc;
2551 struct list_head tmplist;
2552 struct cifsFileInfo *open_file = file->private_data;
2553 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2554 unsigned int rsize = cifs_sb->rsize;
2555 pid_t pid;
2556
2557 /*
2558 * Give up immediately if rsize is too small to read an entire page.
2559 * The VFS will fall back to readpage. We should never reach this
2560 * point however since we set ra_pages to 0 when the rsize is smaller
2561 * than a cache page.
2562 */
2563 if (unlikely(rsize < PAGE_CACHE_SIZE))
2564 return 0;
2565
2566 /*
2567 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2568 * immediately if the cookie is negative
2569 */
2570 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2571 &num_pages);
2572 if (rc == 0)
2573 return rc;
2574
2575 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2576 pid = open_file->pid;
2577 else
2578 pid = current->tgid;
2579
2580 rc = 0;
2581 INIT_LIST_HEAD(&tmplist);
2582
2583 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2584 mapping, num_pages);
2585
2586 /*
2587 * Start with the page at end of list and move it to private
2588 * list. Do the same with any following pages until we hit
2589 * the rsize limit, hit an index discontinuity, or run out of
2590 * pages. Issue the async read and then start the loop again
2591 * until the list is empty.
2592 *
2593 * Note that list order is important. The page_list is in
2594 * the order of declining indexes. When we put the pages in
2595 * the rdata->pages, then we want them in increasing order.
2596 */
2597 while (!list_empty(page_list)) {
2598 unsigned int bytes = PAGE_CACHE_SIZE;
2599 unsigned int expected_index;
2600 unsigned int nr_pages = 1;
2601 loff_t offset;
2602 struct page *page, *tpage;
2603 struct cifs_readdata *rdata;
2604
2605 page = list_entry(page_list->prev, struct page, lru);
2606
2607 /*
2608 * Lock the page and put it in the cache. Since no one else
2609 * should have access to this page, we're safe to simply set
2610 * PG_locked without checking it first.
2611 */
2612 __set_page_locked(page);
2613 rc = add_to_page_cache_locked(page, mapping,
2614 page->index, GFP_KERNEL);
2615
2616 /* give up if we can't stick it in the cache */
2617 if (rc) {
2618 __clear_page_locked(page);
2619 break;
2620 }
2621
2622 /* move first page to the tmplist */
2623 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2624 list_move_tail(&page->lru, &tmplist);
2625
2626 /* now try and add more pages onto the request */
2627 expected_index = page->index + 1;
2628 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2629 /* discontinuity ? */
2630 if (page->index != expected_index)
2631 break;
2632
2633 /* would this page push the read over the rsize? */
2634 if (bytes + PAGE_CACHE_SIZE > rsize)
2635 break;
2636
2637 __set_page_locked(page);
2638 if (add_to_page_cache_locked(page, mapping,
2639 page->index, GFP_KERNEL)) {
2640 __clear_page_locked(page);
2641 break;
2642 }
2643 list_move_tail(&page->lru, &tmplist);
2644 bytes += PAGE_CACHE_SIZE;
2645 expected_index++;
2646 nr_pages++;
2647 }
2648
2649 rdata = cifs_readdata_alloc(nr_pages);
2650 if (!rdata) {
2651 /* best to give up if we're out of mem */
2652 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2653 list_del(&page->lru);
2654 lru_cache_add_file(page);
2655 unlock_page(page);
2656 page_cache_release(page);
2657 }
2658 rc = -ENOMEM;
2659 break;
2660 }
2661
2662 spin_lock(&cifs_file_list_lock);
2663 cifsFileInfo_get(open_file);
2664 spin_unlock(&cifs_file_list_lock);
2665 rdata->cfile = open_file;
2666 rdata->mapping = mapping;
2667 rdata->offset = offset;
2668 rdata->bytes = bytes;
2669 rdata->pid = pid;
2670 list_splice_init(&tmplist, &rdata->pages);
2671
2672 do {
2673 if (open_file->invalidHandle) {
2674 rc = cifs_reopen_file(open_file, true);
2675 if (rc != 0)
2676 continue;
2677 }
2678 rc = cifs_async_readv(rdata);
2679 } while (rc == -EAGAIN);
2680
2681 if (rc != 0) {
2682 list_for_each_entry_safe(page, tpage, &rdata->pages,
2683 lru) {
2684 list_del(&page->lru);
2685 lru_cache_add_file(page);
2686 unlock_page(page);
2687 page_cache_release(page);
2688 }
2689 cifs_readdata_free(rdata);
2690 break;
2691 }
2692 }
2693
2694 return rc;
2695 }
2696
2697 static int cifs_readpage_worker(struct file *file, struct page *page,
2698 loff_t *poffset)
2699 {
2700 char *read_data;
2701 int rc;
2702
2703 /* Is the page cached? */
2704 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2705 if (rc == 0)
2706 goto read_complete;
2707
2708 page_cache_get(page);
2709 read_data = kmap(page);
2710 /* for reads over a certain size could initiate async read ahead */
2711
2712 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2713
2714 if (rc < 0)
2715 goto io_error;
2716 else
2717 cFYI(1, "Bytes read %d", rc);
2718
2719 file->f_path.dentry->d_inode->i_atime =
2720 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2721
2722 if (PAGE_CACHE_SIZE > rc)
2723 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2724
2725 flush_dcache_page(page);
2726 SetPageUptodate(page);
2727
2728 /* send this page to the cache */
2729 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2730
2731 rc = 0;
2732
2733 io_error:
2734 kunmap(page);
2735 page_cache_release(page);
2736
2737 read_complete:
2738 return rc;
2739 }
2740
2741 static int cifs_readpage(struct file *file, struct page *page)
2742 {
2743 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2744 int rc = -EACCES;
2745 int xid;
2746
2747 xid = GetXid();
2748
2749 if (file->private_data == NULL) {
2750 rc = -EBADF;
2751 FreeXid(xid);
2752 return rc;
2753 }
2754
2755 cFYI(1, "readpage %p at offset %d 0x%x\n",
2756 page, (int)offset, (int)offset);
2757
2758 rc = cifs_readpage_worker(file, page, &offset);
2759
2760 unlock_page(page);
2761
2762 FreeXid(xid);
2763 return rc;
2764 }
2765
2766 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2767 {
2768 struct cifsFileInfo *open_file;
2769
2770 spin_lock(&cifs_file_list_lock);
2771 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2772 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2773 spin_unlock(&cifs_file_list_lock);
2774 return 1;
2775 }
2776 }
2777 spin_unlock(&cifs_file_list_lock);
2778 return 0;
2779 }
2780
2781 /* We do not want to update the file size from server for inodes
2782 open for write - to avoid races with writepage extending
2783 the file - in the future we could consider allowing
2784 refreshing the inode only on increases in the file size
2785 but this is tricky to do without racing with writebehind
2786 page caching in the current Linux kernel design */
2787 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2788 {
2789 if (!cifsInode)
2790 return true;
2791
2792 if (is_inode_writable(cifsInode)) {
2793 /* This inode is open for write at least once */
2794 struct cifs_sb_info *cifs_sb;
2795
2796 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2797 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2798 /* since no page cache to corrupt on directio
2799 we can change size safely */
2800 return true;
2801 }
2802
2803 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2804 return true;
2805
2806 return false;
2807 } else
2808 return true;
2809 }
2810
2811 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2812 loff_t pos, unsigned len, unsigned flags,
2813 struct page **pagep, void **fsdata)
2814 {
2815 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2816 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2817 loff_t page_start = pos & PAGE_MASK;
2818 loff_t i_size;
2819 struct page *page;
2820 int rc = 0;
2821
2822 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2823
2824 page = grab_cache_page_write_begin(mapping, index, flags);
2825 if (!page) {
2826 rc = -ENOMEM;
2827 goto out;
2828 }
2829
2830 if (PageUptodate(page))
2831 goto out;
2832
2833 /*
2834 * If we write a full page it will be up to date, no need to read from
2835 * the server. If the write is short, we'll end up doing a sync write
2836 * instead.
2837 */
2838 if (len == PAGE_CACHE_SIZE)
2839 goto out;
2840
2841 /*
2842 * optimize away the read when we have an oplock, and we're not
2843 * expecting to use any of the data we'd be reading in. That
2844 * is, when the page lies beyond the EOF, or straddles the EOF
2845 * and the write will cover all of the existing data.
2846 */
2847 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2848 i_size = i_size_read(mapping->host);
2849 if (page_start >= i_size ||
2850 (offset == 0 && (pos + len) >= i_size)) {
2851 zero_user_segments(page, 0, offset,
2852 offset + len,
2853 PAGE_CACHE_SIZE);
2854 /*
2855 * PageChecked means that the parts of the page
2856 * to which we're not writing are considered up
2857 * to date. Once the data is copied to the
2858 * page, it can be set uptodate.
2859 */
2860 SetPageChecked(page);
2861 goto out;
2862 }
2863 }
2864
2865 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2866 /*
2867 * might as well read a page, it is fast enough. If we get
2868 * an error, we don't need to return it. cifs_write_end will
2869 * do a sync write instead since PG_uptodate isn't set.
2870 */
2871 cifs_readpage_worker(file, page, &page_start);
2872 } else {
2873 /* we could try using another file handle if there is one -
2874 but how would we lock it to prevent close of that handle
2875 racing with this read? In any case
2876 this will be written out by write_end so is fine */
2877 }
2878 out:
2879 *pagep = page;
2880 return rc;
2881 }
2882
2883 static int cifs_release_page(struct page *page, gfp_t gfp)
2884 {
2885 if (PagePrivate(page))
2886 return 0;
2887
2888 return cifs_fscache_release_page(page, gfp);
2889 }
2890
2891 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2892 {
2893 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2894
2895 if (offset == 0)
2896 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2897 }
2898
2899 static int cifs_launder_page(struct page *page)
2900 {
2901 int rc = 0;
2902 loff_t range_start = page_offset(page);
2903 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2904 struct writeback_control wbc = {
2905 .sync_mode = WB_SYNC_ALL,
2906 .nr_to_write = 0,
2907 .range_start = range_start,
2908 .range_end = range_end,
2909 };
2910
2911 cFYI(1, "Launder page: %p", page);
2912
2913 if (clear_page_dirty_for_io(page))
2914 rc = cifs_writepage_locked(page, &wbc);
2915
2916 cifs_fscache_invalidate_page(page, page->mapping->host);
2917 return rc;
2918 }
2919
2920 void cifs_oplock_break(struct work_struct *work)
2921 {
2922 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2923 oplock_break);
2924 struct inode *inode = cfile->dentry->d_inode;
2925 struct cifsInodeInfo *cinode = CIFS_I(inode);
2926 int rc = 0;
2927
2928 if (inode && S_ISREG(inode->i_mode)) {
2929 if (cinode->clientCanCacheRead)
2930 break_lease(inode, O_RDONLY);
2931 else
2932 break_lease(inode, O_WRONLY);
2933 rc = filemap_fdatawrite(inode->i_mapping);
2934 if (cinode->clientCanCacheRead == 0) {
2935 rc = filemap_fdatawait(inode->i_mapping);
2936 mapping_set_error(inode->i_mapping, rc);
2937 invalidate_remote_inode(inode);
2938 }
2939 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2940 }
2941
2942 rc = cifs_push_locks(cfile);
2943 if (rc)
2944 cERROR(1, "Push locks rc = %d", rc);
2945
2946 /*
2947 * releasing stale oplock after recent reconnect of smb session using
2948 * a now incorrect file handle is not a data integrity issue but do
2949 * not bother sending an oplock release if session to server still is
2950 * disconnected since oplock already released by the server
2951 */
2952 if (!cfile->oplock_break_cancelled) {
2953 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2954 current->tgid, 0, 0, 0, 0,
2955 LOCKING_ANDX_OPLOCK_RELEASE, false,
2956 cinode->clientCanCacheRead ? 1 : 0);
2957 cFYI(1, "Oplock release rc = %d", rc);
2958 }
2959 }
2960
2961 const struct address_space_operations cifs_addr_ops = {
2962 .readpage = cifs_readpage,
2963 .readpages = cifs_readpages,
2964 .writepage = cifs_writepage,
2965 .writepages = cifs_writepages,
2966 .write_begin = cifs_write_begin,
2967 .write_end = cifs_write_end,
2968 .set_page_dirty = __set_page_dirty_nobuffers,
2969 .releasepage = cifs_release_page,
2970 .invalidatepage = cifs_invalidate_page,
2971 .launder_page = cifs_launder_page,
2972 };
2973
2974 /*
2975 * cifs_readpages requires the server to support a buffer large enough to
2976 * contain the header plus one complete page of data. Otherwise, we need
2977 * to leave cifs_readpages out of the address space operations.
2978 */
2979 const struct address_space_operations cifs_addr_ops_smallbuf = {
2980 .readpage = cifs_readpage,
2981 .writepage = cifs_writepage,
2982 .writepages = cifs_writepages,
2983 .write_begin = cifs_write_begin,
2984 .write_end = cifs_write_end,
2985 .set_page_dirty = __set_page_dirty_nobuffers,
2986 .releasepage = cifs_release_page,
2987 .invalidatepage = cifs_invalidate_page,
2988 .launder_page = cifs_launder_page,
2989 };
ubuntu-bionic-kernel mirror