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