?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
cifs: fix allocation in cifs_write_allocate_pages
[linux-2.6/btrfs-unstable.git] / fs / cifs / file.c
blob70bd5464ffdf3d79060a8ec41976778477fab3b0
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 /* update the file size (if needed) after a write */
1403 void
1404 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1405 unsigned int bytes_written)
1406 {
1407 loff_t end_of_write = offset + bytes_written;
1408
1409 if (end_of_write > cifsi->server_eof)
1410 cifsi->server_eof = end_of_write;
1411 }
1412
1413 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
1414 const char *write_data, size_t write_size,
1415 loff_t *poffset)
1416 {
1417 int rc = 0;
1418 unsigned int bytes_written = 0;
1419 unsigned int total_written;
1420 struct cifs_sb_info *cifs_sb;
1421 struct cifs_tcon *pTcon;
1422 int xid;
1423 struct dentry *dentry = open_file->dentry;
1424 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1425 struct cifs_io_parms io_parms;
1426
1427 cifs_sb = CIFS_SB(dentry->d_sb);
1428
1429 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1430 *poffset, dentry->d_name.name);
1431
1432 pTcon = tlink_tcon(open_file->tlink);
1433
1434 xid = GetXid();
1435
1436 for (total_written = 0; write_size > total_written;
1437 total_written += bytes_written) {
1438 rc = -EAGAIN;
1439 while (rc == -EAGAIN) {
1440 struct kvec iov[2];
1441 unsigned int len;
1442
1443 if (open_file->invalidHandle) {
1444 /* we could deadlock if we called
1445 filemap_fdatawait from here so tell
1446 reopen_file not to flush data to
1447 server now */
1448 rc = cifs_reopen_file(open_file, false);
1449 if (rc != 0)
1450 break;
1451 }
1452
1453 len = min((size_t)cifs_sb->wsize,
1454 write_size - total_written);
1455 /* iov[0] is reserved for smb header */
1456 iov[1].iov_base = (char *)write_data + total_written;
1457 iov[1].iov_len = len;
1458 io_parms.netfid = open_file->netfid;
1459 io_parms.pid = pid;
1460 io_parms.tcon = pTcon;
1461 io_parms.offset = *poffset;
1462 io_parms.length = len;
1463 rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1464 1, 0);
1465 }
1466 if (rc || (bytes_written == 0)) {
1467 if (total_written)
1468 break;
1469 else {
1470 FreeXid(xid);
1471 return rc;
1472 }
1473 } else {
1474 cifs_update_eof(cifsi, *poffset, bytes_written);
1475 *poffset += bytes_written;
1476 }
1477 }
1478
1479 cifs_stats_bytes_written(pTcon, total_written);
1480
1481 if (total_written > 0) {
1482 spin_lock(&dentry->d_inode->i_lock);
1483 if (*poffset > dentry->d_inode->i_size)
1484 i_size_write(dentry->d_inode, *poffset);
1485 spin_unlock(&dentry->d_inode->i_lock);
1486 }
1487 mark_inode_dirty_sync(dentry->d_inode);
1488 FreeXid(xid);
1489 return total_written;
1490 }
1491
1492 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1493 bool fsuid_only)
1494 {
1495 struct cifsFileInfo *open_file = NULL;
1496 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1497
1498 /* only filter by fsuid on multiuser mounts */
1499 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1500 fsuid_only = false;
1501
1502 spin_lock(&cifs_file_list_lock);
1503 /* we could simply get the first_list_entry since write-only entries
1504 are always at the end of the list but since the first entry might
1505 have a close pending, we go through the whole list */
1506 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1507 if (fsuid_only && open_file->uid != current_fsuid())
1508 continue;
1509 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1510 if (!open_file->invalidHandle) {
1511 /* found a good file */
1512 /* lock it so it will not be closed on us */
1513 cifsFileInfo_get(open_file);
1514 spin_unlock(&cifs_file_list_lock);
1515 return open_file;
1516 } /* else might as well continue, and look for
1517 another, or simply have the caller reopen it
1518 again rather than trying to fix this handle */
1519 } else /* write only file */
1520 break; /* write only files are last so must be done */
1521 }
1522 spin_unlock(&cifs_file_list_lock);
1523 return NULL;
1524 }
1525
1526 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1527 bool fsuid_only)
1528 {
1529 struct cifsFileInfo *open_file;
1530 struct cifs_sb_info *cifs_sb;
1531 bool any_available = false;
1532 int rc;
1533
1534 /* Having a null inode here (because mapping->host was set to zero by
1535 the VFS or MM) should not happen but we had reports of on oops (due to
1536 it being zero) during stress testcases so we need to check for it */
1537
1538 if (cifs_inode == NULL) {
1539 cERROR(1, "Null inode passed to cifs_writeable_file");
1540 dump_stack();
1541 return NULL;
1542 }
1543
1544 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1545
1546 /* only filter by fsuid on multiuser mounts */
1547 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1548 fsuid_only = false;
1549
1550 spin_lock(&cifs_file_list_lock);
1551 refind_writable:
1552 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1553 if (!any_available && open_file->pid != current->tgid)
1554 continue;
1555 if (fsuid_only && open_file->uid != current_fsuid())
1556 continue;
1557 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1558 cifsFileInfo_get(open_file);
1559
1560 if (!open_file->invalidHandle) {
1561 /* found a good writable file */
1562 spin_unlock(&cifs_file_list_lock);
1563 return open_file;
1564 }
1565
1566 spin_unlock(&cifs_file_list_lock);
1567
1568 /* Had to unlock since following call can block */
1569 rc = cifs_reopen_file(open_file, false);
1570 if (!rc)
1571 return open_file;
1572
1573 /* if it fails, try another handle if possible */
1574 cFYI(1, "wp failed on reopen file");
1575 cifsFileInfo_put(open_file);
1576
1577 spin_lock(&cifs_file_list_lock);
1578
1579 /* else we simply continue to the next entry. Thus
1580 we do not loop on reopen errors. If we
1581 can not reopen the file, for example if we
1582 reconnected to a server with another client
1583 racing to delete or lock the file we would not
1584 make progress if we restarted before the beginning
1585 of the loop here. */
1586 }
1587 }
1588 /* couldn't find useable FH with same pid, try any available */
1589 if (!any_available) {
1590 any_available = true;
1591 goto refind_writable;
1592 }
1593 spin_unlock(&cifs_file_list_lock);
1594 return NULL;
1595 }
1596
1597 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1598 {
1599 struct address_space *mapping = page->mapping;
1600 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1601 char *write_data;
1602 int rc = -EFAULT;
1603 int bytes_written = 0;
1604 struct inode *inode;
1605 struct cifsFileInfo *open_file;
1606
1607 if (!mapping || !mapping->host)
1608 return -EFAULT;
1609
1610 inode = page->mapping->host;
1611
1612 offset += (loff_t)from;
1613 write_data = kmap(page);
1614 write_data += from;
1615
1616 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1617 kunmap(page);
1618 return -EIO;
1619 }
1620
1621 /* racing with truncate? */
1622 if (offset > mapping->host->i_size) {
1623 kunmap(page);
1624 return 0; /* don't care */
1625 }
1626
1627 /* check to make sure that we are not extending the file */
1628 if (mapping->host->i_size - offset < (loff_t)to)
1629 to = (unsigned)(mapping->host->i_size - offset);
1630
1631 open_file = find_writable_file(CIFS_I(mapping->host), false);
1632 if (open_file) {
1633 bytes_written = cifs_write(open_file, open_file->pid,
1634 write_data, to - from, &offset);
1635 cifsFileInfo_put(open_file);
1636 /* Does mm or vfs already set times? */
1637 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1638 if ((bytes_written > 0) && (offset))
1639 rc = 0;
1640 else if (bytes_written < 0)
1641 rc = bytes_written;
1642 } else {
1643 cFYI(1, "No writeable filehandles for inode");
1644 rc = -EIO;
1645 }
1646
1647 kunmap(page);
1648 return rc;
1649 }
1650
1651 static int cifs_writepages(struct address_space *mapping,
1652 struct writeback_control *wbc)
1653 {
1654 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1655 bool done = false, scanned = false, range_whole = false;
1656 pgoff_t end, index;
1657 struct cifs_writedata *wdata;
1658 struct page *page;
1659 int rc = 0;
1660
1661 /*
1662 * If wsize is smaller than the page cache size, default to writing
1663 * one page at a time via cifs_writepage
1664 */
1665 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1666 return generic_writepages(mapping, wbc);
1667
1668 if (wbc->range_cyclic) {
1669 index = mapping->writeback_index; /* Start from prev offset */
1670 end = -1;
1671 } else {
1672 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1673 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1674 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1675 range_whole = true;
1676 scanned = true;
1677 }
1678 retry:
1679 while (!done && index <= end) {
1680 unsigned int i, nr_pages, found_pages;
1681 pgoff_t next = 0, tofind;
1682 struct page **pages;
1683
1684 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1685 end - index) + 1;
1686
1687 wdata = cifs_writedata_alloc((unsigned int)tofind,
1688 cifs_writev_complete);
1689 if (!wdata) {
1690 rc = -ENOMEM;
1691 break;
1692 }
1693
1694 /*
1695 * find_get_pages_tag seems to return a max of 256 on each
1696 * iteration, so we must call it several times in order to
1697 * fill the array or the wsize is effectively limited to
1698 * 256 * PAGE_CACHE_SIZE.
1699 */
1700 found_pages = 0;
1701 pages = wdata->pages;
1702 do {
1703 nr_pages = find_get_pages_tag(mapping, &index,
1704 PAGECACHE_TAG_DIRTY,
1705 tofind, pages);
1706 found_pages += nr_pages;
1707 tofind -= nr_pages;
1708 pages += nr_pages;
1709 } while (nr_pages && tofind && index <= end);
1710
1711 if (found_pages == 0) {
1712 kref_put(&wdata->refcount, cifs_writedata_release);
1713 break;
1714 }
1715
1716 nr_pages = 0;
1717 for (i = 0; i < found_pages; i++) {
1718 page = wdata->pages[i];
1719 /*
1720 * At this point we hold neither mapping->tree_lock nor
1721 * lock on the page itself: the page may be truncated or
1722 * invalidated (changing page->mapping to NULL), or even
1723 * swizzled back from swapper_space to tmpfs file
1724 * mapping
1725 */
1726
1727 if (nr_pages == 0)
1728 lock_page(page);
1729 else if (!trylock_page(page))
1730 break;
1731
1732 if (unlikely(page->mapping != mapping)) {
1733 unlock_page(page);
1734 break;
1735 }
1736
1737 if (!wbc->range_cyclic && page->index > end) {
1738 done = true;
1739 unlock_page(page);
1740 break;
1741 }
1742
1743 if (next && (page->index != next)) {
1744 /* Not next consecutive page */
1745 unlock_page(page);
1746 break;
1747 }
1748
1749 if (wbc->sync_mode != WB_SYNC_NONE)
1750 wait_on_page_writeback(page);
1751
1752 if (PageWriteback(page) ||
1753 !clear_page_dirty_for_io(page)) {
1754 unlock_page(page);
1755 break;
1756 }
1757
1758 /*
1759 * This actually clears the dirty bit in the radix tree.
1760 * See cifs_writepage() for more commentary.
1761 */
1762 set_page_writeback(page);
1763
1764 if (page_offset(page) >= mapping->host->i_size) {
1765 done = true;
1766 unlock_page(page);
1767 end_page_writeback(page);
1768 break;
1769 }
1770
1771 wdata->pages[i] = page;
1772 next = page->index + 1;
1773 ++nr_pages;
1774 }
1775
1776 /* reset index to refind any pages skipped */
1777 if (nr_pages == 0)
1778 index = wdata->pages[0]->index + 1;
1779
1780 /* put any pages we aren't going to use */
1781 for (i = nr_pages; i < found_pages; i++) {
1782 page_cache_release(wdata->pages[i]);
1783 wdata->pages[i] = NULL;
1784 }
1785
1786 /* nothing to write? */
1787 if (nr_pages == 0) {
1788 kref_put(&wdata->refcount, cifs_writedata_release);
1789 continue;
1790 }
1791
1792 wdata->sync_mode = wbc->sync_mode;
1793 wdata->nr_pages = nr_pages;
1794 wdata->offset = page_offset(wdata->pages[0]);
1795
1796 do {
1797 if (wdata->cfile != NULL)
1798 cifsFileInfo_put(wdata->cfile);
1799 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1800 false);
1801 if (!wdata->cfile) {
1802 cERROR(1, "No writable handles for inode");
1803 rc = -EBADF;
1804 break;
1805 }
1806 wdata->pid = wdata->cfile->pid;
1807 rc = cifs_async_writev(wdata);
1808 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1809
1810 for (i = 0; i < nr_pages; ++i)
1811 unlock_page(wdata->pages[i]);
1812
1813 /* send failure -- clean up the mess */
1814 if (rc != 0) {
1815 for (i = 0; i < nr_pages; ++i) {
1816 if (rc == -EAGAIN)
1817 redirty_page_for_writepage(wbc,
1818 wdata->pages[i]);
1819 else
1820 SetPageError(wdata->pages[i]);
1821 end_page_writeback(wdata->pages[i]);
1822 page_cache_release(wdata->pages[i]);
1823 }
1824 if (rc != -EAGAIN)
1825 mapping_set_error(mapping, rc);
1826 }
1827 kref_put(&wdata->refcount, cifs_writedata_release);
1828
1829 wbc->nr_to_write -= nr_pages;
1830 if (wbc->nr_to_write <= 0)
1831 done = true;
1832
1833 index = next;
1834 }
1835
1836 if (!scanned && !done) {
1837 /*
1838 * We hit the last page and there is more work to be done: wrap
1839 * back to the start of the file
1840 */
1841 scanned = true;
1842 index = 0;
1843 goto retry;
1844 }
1845
1846 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1847 mapping->writeback_index = index;
1848
1849 return rc;
1850 }
1851
1852 static int
1853 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1854 {
1855 int rc;
1856 int xid;
1857
1858 xid = GetXid();
1859 /* BB add check for wbc flags */
1860 page_cache_get(page);
1861 if (!PageUptodate(page))
1862 cFYI(1, "ppw - page not up to date");
1863
1864 /*
1865 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1866 *
1867 * A writepage() implementation always needs to do either this,
1868 * or re-dirty the page with "redirty_page_for_writepage()" in
1869 * the case of a failure.
1870 *
1871 * Just unlocking the page will cause the radix tree tag-bits
1872 * to fail to update with the state of the page correctly.
1873 */
1874 set_page_writeback(page);
1875 retry_write:
1876 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1877 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1878 goto retry_write;
1879 else if (rc == -EAGAIN)
1880 redirty_page_for_writepage(wbc, page);
1881 else if (rc != 0)
1882 SetPageError(page);
1883 else
1884 SetPageUptodate(page);
1885 end_page_writeback(page);
1886 page_cache_release(page);
1887 FreeXid(xid);
1888 return rc;
1889 }
1890
1891 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1892 {
1893 int rc = cifs_writepage_locked(page, wbc);
1894 unlock_page(page);
1895 return rc;
1896 }
1897
1898 static int cifs_write_end(struct file *file, struct address_space *mapping,
1899 loff_t pos, unsigned len, unsigned copied,
1900 struct page *page, void *fsdata)
1901 {
1902 int rc;
1903 struct inode *inode = mapping->host;
1904 struct cifsFileInfo *cfile = file->private_data;
1905 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1906 __u32 pid;
1907
1908 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1909 pid = cfile->pid;
1910 else
1911 pid = current->tgid;
1912
1913 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1914 page, pos, copied);
1915
1916 if (PageChecked(page)) {
1917 if (copied == len)
1918 SetPageUptodate(page);
1919 ClearPageChecked(page);
1920 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1921 SetPageUptodate(page);
1922
1923 if (!PageUptodate(page)) {
1924 char *page_data;
1925 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1926 int xid;
1927
1928 xid = GetXid();
1929 /* this is probably better than directly calling
1930 partialpage_write since in this function the file handle is
1931 known which we might as well leverage */
1932 /* BB check if anything else missing out of ppw
1933 such as updating last write time */
1934 page_data = kmap(page);
1935 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1936 /* if (rc < 0) should we set writebehind rc? */
1937 kunmap(page);
1938
1939 FreeXid(xid);
1940 } else {
1941 rc = copied;
1942 pos += copied;
1943 set_page_dirty(page);
1944 }
1945
1946 if (rc > 0) {
1947 spin_lock(&inode->i_lock);
1948 if (pos > inode->i_size)
1949 i_size_write(inode, pos);
1950 spin_unlock(&inode->i_lock);
1951 }
1952
1953 unlock_page(page);
1954 page_cache_release(page);
1955
1956 return rc;
1957 }
1958
1959 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1960 int datasync)
1961 {
1962 int xid;
1963 int rc = 0;
1964 struct cifs_tcon *tcon;
1965 struct cifsFileInfo *smbfile = file->private_data;
1966 struct inode *inode = file->f_path.dentry->d_inode;
1967 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1968
1969 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1970 if (rc)
1971 return rc;
1972 mutex_lock(&inode->i_mutex);
1973
1974 xid = GetXid();
1975
1976 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1977 file->f_path.dentry->d_name.name, datasync);
1978
1979 if (!CIFS_I(inode)->clientCanCacheRead) {
1980 rc = cifs_invalidate_mapping(inode);
1981 if (rc) {
1982 cFYI(1, "rc: %d during invalidate phase", rc);
1983 rc = 0; /* don't care about it in fsync */
1984 }
1985 }
1986
1987 tcon = tlink_tcon(smbfile->tlink);
1988 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1989 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1990
1991 FreeXid(xid);
1992 mutex_unlock(&inode->i_mutex);
1993 return rc;
1994 }
1995
1996 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1997 {
1998 int xid;
1999 int rc = 0;
2000 struct cifs_tcon *tcon;
2001 struct cifsFileInfo *smbfile = file->private_data;
2002 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2003 struct inode *inode = file->f_mapping->host;
2004
2005 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2006 if (rc)
2007 return rc;
2008 mutex_lock(&inode->i_mutex);
2009
2010 xid = GetXid();
2011
2012 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2013 file->f_path.dentry->d_name.name, datasync);
2014
2015 tcon = tlink_tcon(smbfile->tlink);
2016 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2017 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2018
2019 FreeXid(xid);
2020 mutex_unlock(&inode->i_mutex);
2021 return rc;
2022 }
2023
2024 /*
2025 * As file closes, flush all cached write data for this inode checking
2026 * for write behind errors.
2027 */
2028 int cifs_flush(struct file *file, fl_owner_t id)
2029 {
2030 struct inode *inode = file->f_path.dentry->d_inode;
2031 int rc = 0;
2032
2033 if (file->f_mode & FMODE_WRITE)
2034 rc = filemap_write_and_wait(inode->i_mapping);
2035
2036 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2037
2038 return rc;
2039 }
2040
2041 static int
2042 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2043 {
2044 int rc = 0;
2045 unsigned long i;
2046
2047 for (i = 0; i < num_pages; i++) {
2048 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2049 if (!pages[i]) {
2050 /*
2051 * save number of pages we have already allocated and
2052 * return with ENOMEM error
2053 */
2054 num_pages = i;
2055 rc = -ENOMEM;
2056 break;
2057 }
2058 }
2059
2060 if (rc) {
2061 for (i = 0; i < num_pages; i++)
2062 put_page(pages[i]);
2063 }
2064 return rc;
2065 }
2066
2067 static inline
2068 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2069 {
2070 size_t num_pages;
2071 size_t clen;
2072
2073 clen = min_t(const size_t, len, wsize);
2074 num_pages = clen / PAGE_CACHE_SIZE;
2075 if (clen % PAGE_CACHE_SIZE)
2076 num_pages++;
2077
2078 if (cur_len)
2079 *cur_len = clen;
2080
2081 return num_pages;
2082 }
2083
2084 static ssize_t
2085 cifs_iovec_write(struct file *file, const struct iovec *iov,
2086 unsigned long nr_segs, loff_t *poffset)
2087 {
2088 unsigned int written;
2089 unsigned long num_pages, npages, i;
2090 size_t copied, len, cur_len;
2091 ssize_t total_written = 0;
2092 struct kvec *to_send;
2093 struct page **pages;
2094 struct iov_iter it;
2095 struct inode *inode;
2096 struct cifsFileInfo *open_file;
2097 struct cifs_tcon *pTcon;
2098 struct cifs_sb_info *cifs_sb;
2099 struct cifs_io_parms io_parms;
2100 int xid, rc;
2101 __u32 pid;
2102
2103 len = iov_length(iov, nr_segs);
2104 if (!len)
2105 return 0;
2106
2107 rc = generic_write_checks(file, poffset, &len, 0);
2108 if (rc)
2109 return rc;
2110
2111 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2112 num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2113
2114 pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2115 if (!pages)
2116 return -ENOMEM;
2117
2118 to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2119 if (!to_send) {
2120 kfree(pages);
2121 return -ENOMEM;
2122 }
2123
2124 rc = cifs_write_allocate_pages(pages, num_pages);
2125 if (rc) {
2126 kfree(pages);
2127 kfree(to_send);
2128 return rc;
2129 }
2130
2131 xid = GetXid();
2132 open_file = file->private_data;
2133
2134 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2135 pid = open_file->pid;
2136 else
2137 pid = current->tgid;
2138
2139 pTcon = tlink_tcon(open_file->tlink);
2140 inode = file->f_path.dentry->d_inode;
2141
2142 iov_iter_init(&it, iov, nr_segs, len, 0);
2143 npages = num_pages;
2144
2145 do {
2146 size_t save_len = cur_len;
2147 for (i = 0; i < npages; i++) {
2148 copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2149 copied = iov_iter_copy_from_user(pages[i], &it, 0,
2150 copied);
2151 cur_len -= copied;
2152 iov_iter_advance(&it, copied);
2153 to_send[i+1].iov_base = kmap(pages[i]);
2154 to_send[i+1].iov_len = copied;
2155 }
2156
2157 cur_len = save_len - cur_len;
2158
2159 do {
2160 if (open_file->invalidHandle) {
2161 rc = cifs_reopen_file(open_file, false);
2162 if (rc != 0)
2163 break;
2164 }
2165 io_parms.netfid = open_file->netfid;
2166 io_parms.pid = pid;
2167 io_parms.tcon = pTcon;
2168 io_parms.offset = *poffset;
2169 io_parms.length = cur_len;
2170 rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2171 npages, 0);
2172 } while (rc == -EAGAIN);
2173
2174 for (i = 0; i < npages; i++)
2175 kunmap(pages[i]);
2176
2177 if (written) {
2178 len -= written;
2179 total_written += written;
2180 cifs_update_eof(CIFS_I(inode), *poffset, written);
2181 *poffset += written;
2182 } else if (rc < 0) {
2183 if (!total_written)
2184 total_written = rc;
2185 break;
2186 }
2187
2188 /* get length and number of kvecs of the next write */
2189 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2190 } while (len > 0);
2191
2192 if (total_written > 0) {
2193 spin_lock(&inode->i_lock);
2194 if (*poffset > inode->i_size)
2195 i_size_write(inode, *poffset);
2196 spin_unlock(&inode->i_lock);
2197 }
2198
2199 cifs_stats_bytes_written(pTcon, total_written);
2200 mark_inode_dirty_sync(inode);
2201
2202 for (i = 0; i < num_pages; i++)
2203 put_page(pages[i]);
2204 kfree(to_send);
2205 kfree(pages);
2206 FreeXid(xid);
2207 return total_written;
2208 }
2209
2210 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2211 unsigned long nr_segs, loff_t pos)
2212 {
2213 ssize_t written;
2214 struct inode *inode;
2215
2216 inode = iocb->ki_filp->f_path.dentry->d_inode;
2217
2218 /*
2219 * BB - optimize the way when signing is disabled. We can drop this
2220 * extra memory-to-memory copying and use iovec buffers for constructing
2221 * write request.
2222 */
2223
2224 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2225 if (written > 0) {
2226 CIFS_I(inode)->invalid_mapping = true;
2227 iocb->ki_pos = pos;
2228 }
2229
2230 return written;
2231 }
2232
2233 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2234 unsigned long nr_segs, loff_t pos)
2235 {
2236 struct inode *inode;
2237
2238 inode = iocb->ki_filp->f_path.dentry->d_inode;
2239
2240 if (CIFS_I(inode)->clientCanCacheAll)
2241 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2242
2243 /*
2244 * In strict cache mode we need to write the data to the server exactly
2245 * from the pos to pos+len-1 rather than flush all affected pages
2246 * because it may cause a error with mandatory locks on these pages but
2247 * not on the region from pos to ppos+len-1.
2248 */
2249
2250 return cifs_user_writev(iocb, iov, nr_segs, pos);
2251 }
2252
2253 static ssize_t
2254 cifs_iovec_read(struct file *file, const struct iovec *iov,
2255 unsigned long nr_segs, loff_t *poffset)
2256 {
2257 int rc;
2258 int xid;
2259 ssize_t total_read;
2260 unsigned int bytes_read = 0;
2261 size_t len, cur_len;
2262 int iov_offset = 0;
2263 struct cifs_sb_info *cifs_sb;
2264 struct cifs_tcon *pTcon;
2265 struct cifsFileInfo *open_file;
2266 struct smb_com_read_rsp *pSMBr;
2267 struct cifs_io_parms io_parms;
2268 char *read_data;
2269 unsigned int rsize;
2270 __u32 pid;
2271
2272 if (!nr_segs)
2273 return 0;
2274
2275 len = iov_length(iov, nr_segs);
2276 if (!len)
2277 return 0;
2278
2279 xid = GetXid();
2280 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2281
2282 /* FIXME: set up handlers for larger reads and/or convert to async */
2283 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2284
2285 open_file = file->private_data;
2286 pTcon = tlink_tcon(open_file->tlink);
2287
2288 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2289 pid = open_file->pid;
2290 else
2291 pid = current->tgid;
2292
2293 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2294 cFYI(1, "attempting read on write only file instance");
2295
2296 for (total_read = 0; total_read < len; total_read += bytes_read) {
2297 cur_len = min_t(const size_t, len - total_read, rsize);
2298 rc = -EAGAIN;
2299 read_data = NULL;
2300
2301 while (rc == -EAGAIN) {
2302 int buf_type = CIFS_NO_BUFFER;
2303 if (open_file->invalidHandle) {
2304 rc = cifs_reopen_file(open_file, true);
2305 if (rc != 0)
2306 break;
2307 }
2308 io_parms.netfid = open_file->netfid;
2309 io_parms.pid = pid;
2310 io_parms.tcon = pTcon;
2311 io_parms.offset = *poffset;
2312 io_parms.length = cur_len;
2313 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2314 &read_data, &buf_type);
2315 pSMBr = (struct smb_com_read_rsp *)read_data;
2316 if (read_data) {
2317 char *data_offset = read_data + 4 +
2318 le16_to_cpu(pSMBr->DataOffset);
2319 if (memcpy_toiovecend(iov, data_offset,
2320 iov_offset, bytes_read))
2321 rc = -EFAULT;
2322 if (buf_type == CIFS_SMALL_BUFFER)
2323 cifs_small_buf_release(read_data);
2324 else if (buf_type == CIFS_LARGE_BUFFER)
2325 cifs_buf_release(read_data);
2326 read_data = NULL;
2327 iov_offset += bytes_read;
2328 }
2329 }
2330
2331 if (rc || (bytes_read == 0)) {
2332 if (total_read) {
2333 break;
2334 } else {
2335 FreeXid(xid);
2336 return rc;
2337 }
2338 } else {
2339 cifs_stats_bytes_read(pTcon, bytes_read);
2340 *poffset += bytes_read;
2341 }
2342 }
2343
2344 FreeXid(xid);
2345 return total_read;
2346 }
2347
2348 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2349 unsigned long nr_segs, loff_t pos)
2350 {
2351 ssize_t read;
2352
2353 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2354 if (read > 0)
2355 iocb->ki_pos = pos;
2356
2357 return read;
2358 }
2359
2360 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2361 unsigned long nr_segs, loff_t pos)
2362 {
2363 struct inode *inode;
2364
2365 inode = iocb->ki_filp->f_path.dentry->d_inode;
2366
2367 if (CIFS_I(inode)->clientCanCacheRead)
2368 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2369
2370 /*
2371 * In strict cache mode we need to read from the server all the time
2372 * if we don't have level II oplock because the server can delay mtime
2373 * change - so we can't make a decision about inode invalidating.
2374 * And we can also fail with pagereading if there are mandatory locks
2375 * on pages affected by this read but not on the region from pos to
2376 * pos+len-1.
2377 */
2378
2379 return cifs_user_readv(iocb, iov, nr_segs, pos);
2380 }
2381
2382 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2383 loff_t *poffset)
2384 {
2385 int rc = -EACCES;
2386 unsigned int bytes_read = 0;
2387 unsigned int total_read;
2388 unsigned int current_read_size;
2389 unsigned int rsize;
2390 struct cifs_sb_info *cifs_sb;
2391 struct cifs_tcon *pTcon;
2392 int xid;
2393 char *current_offset;
2394 struct cifsFileInfo *open_file;
2395 struct cifs_io_parms io_parms;
2396 int buf_type = CIFS_NO_BUFFER;
2397 __u32 pid;
2398
2399 xid = GetXid();
2400 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2401
2402 /* FIXME: set up handlers for larger reads and/or convert to async */
2403 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2404
2405 if (file->private_data == NULL) {
2406 rc = -EBADF;
2407 FreeXid(xid);
2408 return rc;
2409 }
2410 open_file = file->private_data;
2411 pTcon = tlink_tcon(open_file->tlink);
2412
2413 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2414 pid = open_file->pid;
2415 else
2416 pid = current->tgid;
2417
2418 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2419 cFYI(1, "attempting read on write only file instance");
2420
2421 for (total_read = 0, current_offset = read_data;
2422 read_size > total_read;
2423 total_read += bytes_read, current_offset += bytes_read) {
2424 current_read_size = min_t(uint, read_size - total_read, rsize);
2425
2426 /* For windows me and 9x we do not want to request more
2427 than it negotiated since it will refuse the read then */
2428 if ((pTcon->ses) &&
2429 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2430 current_read_size = min_t(uint, current_read_size,
2431 CIFSMaxBufSize);
2432 }
2433 rc = -EAGAIN;
2434 while (rc == -EAGAIN) {
2435 if (open_file->invalidHandle) {
2436 rc = cifs_reopen_file(open_file, true);
2437 if (rc != 0)
2438 break;
2439 }
2440 io_parms.netfid = open_file->netfid;
2441 io_parms.pid = pid;
2442 io_parms.tcon = pTcon;
2443 io_parms.offset = *poffset;
2444 io_parms.length = current_read_size;
2445 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2446 &current_offset, &buf_type);
2447 }
2448 if (rc || (bytes_read == 0)) {
2449 if (total_read) {
2450 break;
2451 } else {
2452 FreeXid(xid);
2453 return rc;
2454 }
2455 } else {
2456 cifs_stats_bytes_read(pTcon, total_read);
2457 *poffset += bytes_read;
2458 }
2459 }
2460 FreeXid(xid);
2461 return total_read;
2462 }
2463
2464 /*
2465 * If the page is mmap'ed into a process' page tables, then we need to make
2466 * sure that it doesn't change while being written back.
2467 */
2468 static int
2469 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2470 {
2471 struct page *page = vmf->page;
2472
2473 lock_page(page);
2474 return VM_FAULT_LOCKED;
2475 }
2476
2477 static struct vm_operations_struct cifs_file_vm_ops = {
2478 .fault = filemap_fault,
2479 .page_mkwrite = cifs_page_mkwrite,
2480 };
2481
2482 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2483 {
2484 int rc, xid;
2485 struct inode *inode = file->f_path.dentry->d_inode;
2486
2487 xid = GetXid();
2488
2489 if (!CIFS_I(inode)->clientCanCacheRead) {
2490 rc = cifs_invalidate_mapping(inode);
2491 if (rc)
2492 return rc;
2493 }
2494
2495 rc = generic_file_mmap(file, vma);
2496 if (rc == 0)
2497 vma->vm_ops = &cifs_file_vm_ops;
2498 FreeXid(xid);
2499 return rc;
2500 }
2501
2502 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2503 {
2504 int rc, xid;
2505
2506 xid = GetXid();
2507 rc = cifs_revalidate_file(file);
2508 if (rc) {
2509 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2510 FreeXid(xid);
2511 return rc;
2512 }
2513 rc = generic_file_mmap(file, vma);
2514 if (rc == 0)
2515 vma->vm_ops = &cifs_file_vm_ops;
2516 FreeXid(xid);
2517 return rc;
2518 }
2519
2520 static int cifs_readpages(struct file *file, struct address_space *mapping,
2521 struct list_head *page_list, unsigned num_pages)
2522 {
2523 int rc;
2524 struct list_head tmplist;
2525 struct cifsFileInfo *open_file = file->private_data;
2526 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2527 unsigned int rsize = cifs_sb->rsize;
2528 pid_t pid;
2529
2530 /*
2531 * Give up immediately if rsize is too small to read an entire page.
2532 * The VFS will fall back to readpage. We should never reach this
2533 * point however since we set ra_pages to 0 when the rsize is smaller
2534 * than a cache page.
2535 */
2536 if (unlikely(rsize < PAGE_CACHE_SIZE))
2537 return 0;
2538
2539 /*
2540 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2541 * immediately if the cookie is negative
2542 */
2543 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2544 &num_pages);
2545 if (rc == 0)
2546 return rc;
2547
2548 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2549 pid = open_file->pid;
2550 else
2551 pid = current->tgid;
2552
2553 rc = 0;
2554 INIT_LIST_HEAD(&tmplist);
2555
2556 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2557 mapping, num_pages);
2558
2559 /*
2560 * Start with the page at end of list and move it to private
2561 * list. Do the same with any following pages until we hit
2562 * the rsize limit, hit an index discontinuity, or run out of
2563 * pages. Issue the async read and then start the loop again
2564 * until the list is empty.
2565 *
2566 * Note that list order is important. The page_list is in
2567 * the order of declining indexes. When we put the pages in
2568 * the rdata->pages, then we want them in increasing order.
2569 */
2570 while (!list_empty(page_list)) {
2571 unsigned int bytes = PAGE_CACHE_SIZE;
2572 unsigned int expected_index;
2573 unsigned int nr_pages = 1;
2574 loff_t offset;
2575 struct page *page, *tpage;
2576 struct cifs_readdata *rdata;
2577
2578 page = list_entry(page_list->prev, struct page, lru);
2579
2580 /*
2581 * Lock the page and put it in the cache. Since no one else
2582 * should have access to this page, we're safe to simply set
2583 * PG_locked without checking it first.
2584 */
2585 __set_page_locked(page);
2586 rc = add_to_page_cache_locked(page, mapping,
2587 page->index, GFP_KERNEL);
2588
2589 /* give up if we can't stick it in the cache */
2590 if (rc) {
2591 __clear_page_locked(page);
2592 break;
2593 }
2594
2595 /* move first page to the tmplist */
2596 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2597 list_move_tail(&page->lru, &tmplist);
2598
2599 /* now try and add more pages onto the request */
2600 expected_index = page->index + 1;
2601 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2602 /* discontinuity ? */
2603 if (page->index != expected_index)
2604 break;
2605
2606 /* would this page push the read over the rsize? */
2607 if (bytes + PAGE_CACHE_SIZE > rsize)
2608 break;
2609
2610 __set_page_locked(page);
2611 if (add_to_page_cache_locked(page, mapping,
2612 page->index, GFP_KERNEL)) {
2613 __clear_page_locked(page);
2614 break;
2615 }
2616 list_move_tail(&page->lru, &tmplist);
2617 bytes += PAGE_CACHE_SIZE;
2618 expected_index++;
2619 nr_pages++;
2620 }
2621
2622 rdata = cifs_readdata_alloc(nr_pages);
2623 if (!rdata) {
2624 /* best to give up if we're out of mem */
2625 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2626 list_del(&page->lru);
2627 lru_cache_add_file(page);
2628 unlock_page(page);
2629 page_cache_release(page);
2630 }
2631 rc = -ENOMEM;
2632 break;
2633 }
2634
2635 spin_lock(&cifs_file_list_lock);
2636 cifsFileInfo_get(open_file);
2637 spin_unlock(&cifs_file_list_lock);
2638 rdata->cfile = open_file;
2639 rdata->mapping = mapping;
2640 rdata->offset = offset;
2641 rdata->bytes = bytes;
2642 rdata->pid = pid;
2643 list_splice_init(&tmplist, &rdata->pages);
2644
2645 do {
2646 if (open_file->invalidHandle) {
2647 rc = cifs_reopen_file(open_file, true);
2648 if (rc != 0)
2649 continue;
2650 }
2651 rc = cifs_async_readv(rdata);
2652 } while (rc == -EAGAIN);
2653
2654 if (rc != 0) {
2655 list_for_each_entry_safe(page, tpage, &rdata->pages,
2656 lru) {
2657 list_del(&page->lru);
2658 lru_cache_add_file(page);
2659 unlock_page(page);
2660 page_cache_release(page);
2661 }
2662 cifs_readdata_free(rdata);
2663 break;
2664 }
2665 }
2666
2667 return rc;
2668 }
2669
2670 static int cifs_readpage_worker(struct file *file, struct page *page,
2671 loff_t *poffset)
2672 {
2673 char *read_data;
2674 int rc;
2675
2676 /* Is the page cached? */
2677 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2678 if (rc == 0)
2679 goto read_complete;
2680
2681 page_cache_get(page);
2682 read_data = kmap(page);
2683 /* for reads over a certain size could initiate async read ahead */
2684
2685 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2686
2687 if (rc < 0)
2688 goto io_error;
2689 else
2690 cFYI(1, "Bytes read %d", rc);
2691
2692 file->f_path.dentry->d_inode->i_atime =
2693 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2694
2695 if (PAGE_CACHE_SIZE > rc)
2696 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2697
2698 flush_dcache_page(page);
2699 SetPageUptodate(page);
2700
2701 /* send this page to the cache */
2702 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2703
2704 rc = 0;
2705
2706 io_error:
2707 kunmap(page);
2708 page_cache_release(page);
2709
2710 read_complete:
2711 return rc;
2712 }
2713
2714 static int cifs_readpage(struct file *file, struct page *page)
2715 {
2716 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2717 int rc = -EACCES;
2718 int xid;
2719
2720 xid = GetXid();
2721
2722 if (file->private_data == NULL) {
2723 rc = -EBADF;
2724 FreeXid(xid);
2725 return rc;
2726 }
2727
2728 cFYI(1, "readpage %p at offset %d 0x%x\n",
2729 page, (int)offset, (int)offset);
2730
2731 rc = cifs_readpage_worker(file, page, &offset);
2732
2733 unlock_page(page);
2734
2735 FreeXid(xid);
2736 return rc;
2737 }
2738
2739 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2740 {
2741 struct cifsFileInfo *open_file;
2742
2743 spin_lock(&cifs_file_list_lock);
2744 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2745 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2746 spin_unlock(&cifs_file_list_lock);
2747 return 1;
2748 }
2749 }
2750 spin_unlock(&cifs_file_list_lock);
2751 return 0;
2752 }
2753
2754 /* We do not want to update the file size from server for inodes
2755 open for write - to avoid races with writepage extending
2756 the file - in the future we could consider allowing
2757 refreshing the inode only on increases in the file size
2758 but this is tricky to do without racing with writebehind
2759 page caching in the current Linux kernel design */
2760 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2761 {
2762 if (!cifsInode)
2763 return true;
2764
2765 if (is_inode_writable(cifsInode)) {
2766 /* This inode is open for write at least once */
2767 struct cifs_sb_info *cifs_sb;
2768
2769 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2770 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2771 /* since no page cache to corrupt on directio
2772 we can change size safely */
2773 return true;
2774 }
2775
2776 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2777 return true;
2778
2779 return false;
2780 } else
2781 return true;
2782 }
2783
2784 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2785 loff_t pos, unsigned len, unsigned flags,
2786 struct page **pagep, void **fsdata)
2787 {
2788 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2789 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2790 loff_t page_start = pos & PAGE_MASK;
2791 loff_t i_size;
2792 struct page *page;
2793 int rc = 0;
2794
2795 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2796
2797 page = grab_cache_page_write_begin(mapping, index, flags);
2798 if (!page) {
2799 rc = -ENOMEM;
2800 goto out;
2801 }
2802
2803 if (PageUptodate(page))
2804 goto out;
2805
2806 /*
2807 * If we write a full page it will be up to date, no need to read from
2808 * the server. If the write is short, we'll end up doing a sync write
2809 * instead.
2810 */
2811 if (len == PAGE_CACHE_SIZE)
2812 goto out;
2813
2814 /*
2815 * optimize away the read when we have an oplock, and we're not
2816 * expecting to use any of the data we'd be reading in. That
2817 * is, when the page lies beyond the EOF, or straddles the EOF
2818 * and the write will cover all of the existing data.
2819 */
2820 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2821 i_size = i_size_read(mapping->host);
2822 if (page_start >= i_size ||
2823 (offset == 0 && (pos + len) >= i_size)) {
2824 zero_user_segments(page, 0, offset,
2825 offset + len,
2826 PAGE_CACHE_SIZE);
2827 /*
2828 * PageChecked means that the parts of the page
2829 * to which we're not writing are considered up
2830 * to date. Once the data is copied to the
2831 * page, it can be set uptodate.
2832 */
2833 SetPageChecked(page);
2834 goto out;
2835 }
2836 }
2837
2838 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2839 /*
2840 * might as well read a page, it is fast enough. If we get
2841 * an error, we don't need to return it. cifs_write_end will
2842 * do a sync write instead since PG_uptodate isn't set.
2843 */
2844 cifs_readpage_worker(file, page, &page_start);
2845 } else {
2846 /* we could try using another file handle if there is one -
2847 but how would we lock it to prevent close of that handle
2848 racing with this read? In any case
2849 this will be written out by write_end so is fine */
2850 }
2851 out:
2852 *pagep = page;
2853 return rc;
2854 }
2855
2856 static int cifs_release_page(struct page *page, gfp_t gfp)
2857 {
2858 if (PagePrivate(page))
2859 return 0;
2860
2861 return cifs_fscache_release_page(page, gfp);
2862 }
2863
2864 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2865 {
2866 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2867
2868 if (offset == 0)
2869 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2870 }
2871
2872 static int cifs_launder_page(struct page *page)
2873 {
2874 int rc = 0;
2875 loff_t range_start = page_offset(page);
2876 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2877 struct writeback_control wbc = {
2878 .sync_mode = WB_SYNC_ALL,
2879 .nr_to_write = 0,
2880 .range_start = range_start,
2881 .range_end = range_end,
2882 };
2883
2884 cFYI(1, "Launder page: %p", page);
2885
2886 if (clear_page_dirty_for_io(page))
2887 rc = cifs_writepage_locked(page, &wbc);
2888
2889 cifs_fscache_invalidate_page(page, page->mapping->host);
2890 return rc;
2891 }
2892
2893 void cifs_oplock_break(struct work_struct *work)
2894 {
2895 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2896 oplock_break);
2897 struct inode *inode = cfile->dentry->d_inode;
2898 struct cifsInodeInfo *cinode = CIFS_I(inode);
2899 int rc = 0;
2900
2901 if (inode && S_ISREG(inode->i_mode)) {
2902 if (cinode->clientCanCacheRead)
2903 break_lease(inode, O_RDONLY);
2904 else
2905 break_lease(inode, O_WRONLY);
2906 rc = filemap_fdatawrite(inode->i_mapping);
2907 if (cinode->clientCanCacheRead == 0) {
2908 rc = filemap_fdatawait(inode->i_mapping);
2909 mapping_set_error(inode->i_mapping, rc);
2910 invalidate_remote_inode(inode);
2911 }
2912 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2913 }
2914
2915 rc = cifs_push_locks(cfile);
2916 if (rc)
2917 cERROR(1, "Push locks rc = %d", rc);
2918
2919 /*
2920 * releasing stale oplock after recent reconnect of smb session using
2921 * a now incorrect file handle is not a data integrity issue but do
2922 * not bother sending an oplock release if session to server still is
2923 * disconnected since oplock already released by the server
2924 */
2925 if (!cfile->oplock_break_cancelled) {
2926 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2927 current->tgid, 0, 0, 0, 0,
2928 LOCKING_ANDX_OPLOCK_RELEASE, false,
2929 cinode->clientCanCacheRead ? 1 : 0);
2930 cFYI(1, "Oplock release rc = %d", rc);
2931 }
2932 }
2933
2934 const struct address_space_operations cifs_addr_ops = {
2935 .readpage = cifs_readpage,
2936 .readpages = cifs_readpages,
2937 .writepage = cifs_writepage,
2938 .writepages = cifs_writepages,
2939 .write_begin = cifs_write_begin,
2940 .write_end = cifs_write_end,
2941 .set_page_dirty = __set_page_dirty_nobuffers,
2942 .releasepage = cifs_release_page,
2943 .invalidatepage = cifs_invalidate_page,
2944 .launder_page = cifs_launder_page,
2945 };
2946
2947 /*
2948 * cifs_readpages requires the server to support a buffer large enough to
2949 * contain the header plus one complete page of data. Otherwise, we need
2950 * to leave cifs_readpages out of the address space operations.
2951 */
2952 const struct address_space_operations cifs_addr_ops_smallbuf = {
2953 .readpage = cifs_readpage,
2954 .writepage = cifs_writepage,
2955 .writepages = cifs_writepages,
2956 .write_begin = cifs_write_begin,
2957 .write_end = cifs_write_end,
2958 .set_page_dirty = __set_page_dirty_nobuffers,
2959 .releasepage = cifs_release_page,
2960 .invalidatepage = cifs_invalidate_page,
2961 .launder_page = cifs_launder_page,
2962 };
(deprecated) Btrfs devel tree