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