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