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