~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/cifs/file.c

Version: ~ [ linux-5.18-rc6 ] ~ [ linux-5.17.6 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.38 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.114 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.192 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.241 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.277 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.312 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *   fs/cifs/file.c
  3  *
  4  *   vfs operations that deal with files
  5  *
  6  *   Copyright (C) International Business Machines  Corp., 2002,2010
  7  *   Author(s): Steve French (sfrench@us.ibm.com)
  8  *              Jeremy Allison (jra@samba.org)
  9  *
 10  *   This library is free software; you can redistribute it and/or modify
 11  *   it under the terms of the GNU Lesser General Public License as published
 12  *   by the Free Software Foundation; either version 2.1 of the License, or
 13  *   (at your option) any later version.
 14  *
 15  *   This library is distributed in the hope that it will be useful,
 16  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 17  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 18  *   the GNU Lesser General Public License for more details.
 19  *
 20  *   You should have received a copy of the GNU Lesser General Public License
 21  *   along with this library; if not, write to the Free Software
 22  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 23  */
 24 #include <linux/fs.h>
 25 #include <linux/backing-dev.h>
 26 #include <linux/stat.h>
 27 #include <linux/fcntl.h>
 28 #include <linux/pagemap.h>
 29 #include <linux/pagevec.h>
 30 #include <linux/writeback.h>
 31 #include <linux/task_io_accounting_ops.h>
 32 #include <linux/delay.h>
 33 #include <linux/mount.h>
 34 #include <linux/slab.h>
 35 #include <linux/swap.h>
 36 #include <asm/div64.h>
 37 #include "cifsfs.h"
 38 #include "cifspdu.h"
 39 #include "cifsglob.h"
 40 #include "cifsproto.h"
 41 #include "cifs_unicode.h"
 42 #include "cifs_debug.h"
 43 #include "cifs_fs_sb.h"
 44 #include "fscache.h"
 45 
 46 
 47 static inline int cifs_convert_flags(unsigned int flags)
 48 {
 49         if ((flags & O_ACCMODE) == O_RDONLY)
 50                 return GENERIC_READ;
 51         else if ((flags & O_ACCMODE) == O_WRONLY)
 52                 return GENERIC_WRITE;
 53         else if ((flags & O_ACCMODE) == O_RDWR) {
 54                 /* GENERIC_ALL is too much permission to request
 55                    can cause unnecessary access denied on create */
 56                 /* return GENERIC_ALL; */
 57                 return (GENERIC_READ | GENERIC_WRITE);
 58         }
 59 
 60         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
 61                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
 62                 FILE_READ_DATA);
 63 }
 64 
 65 static u32 cifs_posix_convert_flags(unsigned int flags)
 66 {
 67         u32 posix_flags = 0;
 68 
 69         if ((flags & O_ACCMODE) == O_RDONLY)
 70                 posix_flags = SMB_O_RDONLY;
 71         else if ((flags & O_ACCMODE) == O_WRONLY)
 72                 posix_flags = SMB_O_WRONLY;
 73         else if ((flags & O_ACCMODE) == O_RDWR)
 74                 posix_flags = SMB_O_RDWR;
 75 
 76         if (flags & O_CREAT) {
 77                 posix_flags |= SMB_O_CREAT;
 78                 if (flags & O_EXCL)
 79                         posix_flags |= SMB_O_EXCL;
 80         } else if (flags & O_EXCL)
 81                 cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
 82                          current->comm, current->tgid);
 83 
 84         if (flags & O_TRUNC)
 85                 posix_flags |= SMB_O_TRUNC;
 86         /* be safe and imply O_SYNC for O_DSYNC */
 87         if (flags & O_DSYNC)
 88                 posix_flags |= SMB_O_SYNC;
 89         if (flags & O_DIRECTORY)
 90                 posix_flags |= SMB_O_DIRECTORY;
 91         if (flags & O_NOFOLLOW)
 92                 posix_flags |= SMB_O_NOFOLLOW;
 93         if (flags & O_DIRECT)
 94                 posix_flags |= SMB_O_DIRECT;
 95 
 96         return posix_flags;
 97 }
 98 
 99 static inline int cifs_get_disposition(unsigned int flags)
100 {
101         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
102                 return FILE_CREATE;
103         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
104                 return FILE_OVERWRITE_IF;
105         else if ((flags & O_CREAT) == O_CREAT)
106                 return FILE_OPEN_IF;
107         else if ((flags & O_TRUNC) == O_TRUNC)
108                 return FILE_OVERWRITE;
109         else
110                 return FILE_OPEN;
111 }
112 
113 int cifs_posix_open(char *full_path, struct inode **pinode,
114                         struct super_block *sb, int mode, unsigned int f_flags,
115                         __u32 *poplock, __u16 *pnetfid, unsigned int xid)
116 {
117         int rc;
118         FILE_UNIX_BASIC_INFO *presp_data;
119         __u32 posix_flags = 0;
120         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
121         struct cifs_fattr fattr;
122         struct tcon_link *tlink;
123         struct cifs_tcon *tcon;
124 
125         cifs_dbg(FYI, "posix open %s\n", full_path);
126 
127         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
128         if (presp_data == NULL)
129                 return -ENOMEM;
130 
131         tlink = cifs_sb_tlink(cifs_sb);
132         if (IS_ERR(tlink)) {
133                 rc = PTR_ERR(tlink);
134                 goto posix_open_ret;
135         }
136 
137         tcon = tlink_tcon(tlink);
138         mode &= ~current_umask();
139 
140         posix_flags = cifs_posix_convert_flags(f_flags);
141         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
142                              poplock, full_path, cifs_sb->local_nls,
143                              cifs_remap(cifs_sb));
144         cifs_put_tlink(tlink);
145 
146         if (rc)
147                 goto posix_open_ret;
148 
149         if (presp_data->Type == cpu_to_le32(-1))
150                 goto posix_open_ret; /* open ok, caller does qpathinfo */
151 
152         if (!pinode)
153                 goto posix_open_ret; /* caller does not need info */
154 
155         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
156 
157         /* get new inode and set it up */
158         if (*pinode == NULL) {
159                 cifs_fill_uniqueid(sb, &fattr);
160                 *pinode = cifs_iget(sb, &fattr);
161                 if (!*pinode) {
162                         rc = -ENOMEM;
163                         goto posix_open_ret;
164                 }
165         } else {
166                 cifs_fattr_to_inode(*pinode, &fattr);
167         }
168 
169 posix_open_ret:
170         kfree(presp_data);
171         return rc;
172 }
173 
174 static int
175 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
176              struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
177              struct cifs_fid *fid, unsigned int xid)
178 {
179         int rc;
180         int desired_access;
181         int disposition;
182         int create_options = CREATE_NOT_DIR;
183         FILE_ALL_INFO *buf;
184         struct TCP_Server_Info *server = tcon->ses->server;
185         struct cifs_open_parms oparms;
186 
187         if (!server->ops->open)
188                 return -ENOSYS;
189 
190         desired_access = cifs_convert_flags(f_flags);
191 
192 /*********************************************************************
193  *  open flag mapping table:
194  *
195  *      POSIX Flag            CIFS Disposition
196  *      ----------            ----------------
197  *      O_CREAT               FILE_OPEN_IF
198  *      O_CREAT | O_EXCL      FILE_CREATE
199  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
200  *      O_TRUNC               FILE_OVERWRITE
201  *      none of the above     FILE_OPEN
202  *
203  *      Note that there is not a direct match between disposition
204  *      FILE_SUPERSEDE (ie create whether or not file exists although
205  *      O_CREAT | O_TRUNC is similar but truncates the existing
206  *      file rather than creating a new file as FILE_SUPERSEDE does
207  *      (which uses the attributes / metadata passed in on open call)
208  *?
209  *?  O_SYNC is a reasonable match to CIFS writethrough flag
210  *?  and the read write flags match reasonably.  O_LARGEFILE
211  *?  is irrelevant because largefile support is always used
212  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
213  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
214  *********************************************************************/
215 
216         disposition = cifs_get_disposition(f_flags);
217 
218         /* BB pass O_SYNC flag through on file attributes .. BB */
219 
220         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
221         if (!buf)
222                 return -ENOMEM;
223 
224         if (backup_cred(cifs_sb))
225                 create_options |= CREATE_OPEN_BACKUP_INTENT;
226 
227         /* O_SYNC also has bit for O_DSYNC so following check picks up either */
228         if (f_flags & O_SYNC)
229                 create_options |= CREATE_WRITE_THROUGH;
230 
231         if (f_flags & O_DIRECT)
232                 create_options |= CREATE_NO_BUFFER;
233 
234         oparms.tcon = tcon;
235         oparms.cifs_sb = cifs_sb;
236         oparms.desired_access = desired_access;
237         oparms.create_options = create_options;
238         oparms.disposition = disposition;
239         oparms.path = full_path;
240         oparms.fid = fid;
241         oparms.reconnect = false;
242 
243         rc = server->ops->open(xid, &oparms, oplock, buf);
244 
245         if (rc)
246                 goto out;
247 
248         if (tcon->unix_ext)
249                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
250                                               xid);
251         else
252                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
253                                          xid, fid);
254 
255 out:
256         kfree(buf);
257         return rc;
258 }
259 
260 static bool
261 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
262 {
263         struct cifs_fid_locks *cur;
264         bool has_locks = false;
265 
266         down_read(&cinode->lock_sem);
267         list_for_each_entry(cur, &cinode->llist, llist) {
268                 if (!list_empty(&cur->locks)) {
269                         has_locks = true;
270                         break;
271                 }
272         }
273         up_read(&cinode->lock_sem);
274         return has_locks;
275 }
276 
277 struct cifsFileInfo *
278 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
279                   struct tcon_link *tlink, __u32 oplock)
280 {
281         struct dentry *dentry = file_dentry(file);
282         struct inode *inode = d_inode(dentry);
283         struct cifsInodeInfo *cinode = CIFS_I(inode);
284         struct cifsFileInfo *cfile;
285         struct cifs_fid_locks *fdlocks;
286         struct cifs_tcon *tcon = tlink_tcon(tlink);
287         struct TCP_Server_Info *server = tcon->ses->server;
288 
289         cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
290         if (cfile == NULL)
291                 return cfile;
292 
293         fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
294         if (!fdlocks) {
295                 kfree(cfile);
296                 return NULL;
297         }
298 
299         INIT_LIST_HEAD(&fdlocks->locks);
300         fdlocks->cfile = cfile;
301         cfile->llist = fdlocks;
302         down_write(&cinode->lock_sem);
303         list_add(&fdlocks->llist, &cinode->llist);
304         up_write(&cinode->lock_sem);
305 
306         cfile->count = 1;
307         cfile->pid = current->tgid;
308         cfile->uid = current_fsuid();
309         cfile->dentry = dget(dentry);
310         cfile->f_flags = file->f_flags;
311         cfile->invalidHandle = false;
312         cfile->tlink = cifs_get_tlink(tlink);
313         INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
314         mutex_init(&cfile->fh_mutex);
315         spin_lock_init(&cfile->file_info_lock);
316 
317         cifs_sb_active(inode->i_sb);
318 
319         /*
320          * If the server returned a read oplock and we have mandatory brlocks,
321          * set oplock level to None.
322          */
323         if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
324                 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
325                 oplock = 0;
326         }
327 
328         spin_lock(&tcon->open_file_lock);
329         if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
330                 oplock = fid->pending_open->oplock;
331         list_del(&fid->pending_open->olist);
332 
333         fid->purge_cache = false;
334         server->ops->set_fid(cfile, fid, oplock);
335 
336         list_add(&cfile->tlist, &tcon->openFileList);
337 
338         /* if readable file instance put first in list*/
339         if (file->f_mode & FMODE_READ)
340                 list_add(&cfile->flist, &cinode->openFileList);
341         else
342                 list_add_tail(&cfile->flist, &cinode->openFileList);
343         spin_unlock(&tcon->open_file_lock);
344 
345         if (fid->purge_cache)
346                 cifs_zap_mapping(inode);
347 
348         file->private_data = cfile;
349         return cfile;
350 }
351 
352 struct cifsFileInfo *
353 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
354 {
355         spin_lock(&cifs_file->file_info_lock);
356         cifsFileInfo_get_locked(cifs_file);
357         spin_unlock(&cifs_file->file_info_lock);
358         return cifs_file;
359 }
360 
361 /*
362  * Release a reference on the file private data. This may involve closing
363  * the filehandle out on the server. Must be called without holding
364  * tcon->open_file_lock and cifs_file->file_info_lock.
365  */
366 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
367 {
368         struct inode *inode = d_inode(cifs_file->dentry);
369         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
370         struct TCP_Server_Info *server = tcon->ses->server;
371         struct cifsInodeInfo *cifsi = CIFS_I(inode);
372         struct super_block *sb = inode->i_sb;
373         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
374         struct cifsLockInfo *li, *tmp;
375         struct cifs_fid fid;
376         struct cifs_pending_open open;
377         bool oplock_break_cancelled;
378 
379         spin_lock(&tcon->open_file_lock);
380 
381         spin_lock(&cifs_file->file_info_lock);
382         if (--cifs_file->count > 0) {
383                 spin_unlock(&cifs_file->file_info_lock);
384                 spin_unlock(&tcon->open_file_lock);
385                 return;
386         }
387         spin_unlock(&cifs_file->file_info_lock);
388 
389         if (server->ops->get_lease_key)
390                 server->ops->get_lease_key(inode, &fid);
391 
392         /* store open in pending opens to make sure we don't miss lease break */
393         cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
394 
395         /* remove it from the lists */
396         list_del(&cifs_file->flist);
397         list_del(&cifs_file->tlist);
398 
399         if (list_empty(&cifsi->openFileList)) {
400                 cifs_dbg(FYI, "closing last open instance for inode %p\n",
401                          d_inode(cifs_file->dentry));
402                 /*
403                  * In strict cache mode we need invalidate mapping on the last
404                  * close  because it may cause a error when we open this file
405                  * again and get at least level II oplock.
406                  */
407                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
408                         set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
409                 cifs_set_oplock_level(cifsi, 0);
410         }
411 
412         spin_unlock(&tcon->open_file_lock);
413 
414         oplock_break_cancelled = cancel_work_sync(&cifs_file->oplock_break);
415 
416         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
417                 struct TCP_Server_Info *server = tcon->ses->server;
418                 unsigned int xid;
419 
420                 xid = get_xid();
421                 if (server->ops->close)
422                         server->ops->close(xid, tcon, &cifs_file->fid);
423                 _free_xid(xid);
424         }
425 
426         if (oplock_break_cancelled)
427                 cifs_done_oplock_break(cifsi);
428 
429         cifs_del_pending_open(&open);
430 
431         /*
432          * Delete any outstanding lock records. We'll lose them when the file
433          * is closed anyway.
434          */
435         down_write(&cifsi->lock_sem);
436         list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
437                 list_del(&li->llist);
438                 cifs_del_lock_waiters(li);
439                 kfree(li);
440         }
441         list_del(&cifs_file->llist->llist);
442         kfree(cifs_file->llist);
443         up_write(&cifsi->lock_sem);
444 
445         cifs_put_tlink(cifs_file->tlink);
446         dput(cifs_file->dentry);
447         cifs_sb_deactive(sb);
448         kfree(cifs_file);
449 }
450 
451 int cifs_open(struct inode *inode, struct file *file)
452 
453 {
454         int rc = -EACCES;
455         unsigned int xid;
456         __u32 oplock;
457         struct cifs_sb_info *cifs_sb;
458         struct TCP_Server_Info *server;
459         struct cifs_tcon *tcon;
460         struct tcon_link *tlink;
461         struct cifsFileInfo *cfile = NULL;
462         char *full_path = NULL;
463         bool posix_open_ok = false;
464         struct cifs_fid fid;
465         struct cifs_pending_open open;
466 
467         xid = get_xid();
468 
469         cifs_sb = CIFS_SB(inode->i_sb);
470         tlink = cifs_sb_tlink(cifs_sb);
471         if (IS_ERR(tlink)) {
472                 free_xid(xid);
473                 return PTR_ERR(tlink);
474         }
475         tcon = tlink_tcon(tlink);
476         server = tcon->ses->server;
477 
478         full_path = build_path_from_dentry(file_dentry(file));
479         if (full_path == NULL) {
480                 rc = -ENOMEM;
481                 goto out;
482         }
483 
484         cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
485                  inode, file->f_flags, full_path);
486 
487         if (file->f_flags & O_DIRECT &&
488             cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
489                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
490                         file->f_op = &cifs_file_direct_nobrl_ops;
491                 else
492                         file->f_op = &cifs_file_direct_ops;
493         }
494 
495         if (server->oplocks)
496                 oplock = REQ_OPLOCK;
497         else
498                 oplock = 0;
499 
500         if (!tcon->broken_posix_open && tcon->unix_ext &&
501             cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
502                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
503                 /* can not refresh inode info since size could be stale */
504                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
505                                 cifs_sb->mnt_file_mode /* ignored */,
506                                 file->f_flags, &oplock, &fid.netfid, xid);
507                 if (rc == 0) {
508                         cifs_dbg(FYI, "posix open succeeded\n");
509                         posix_open_ok = true;
510                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
511                         if (tcon->ses->serverNOS)
512                                 cifs_dbg(VFS, "server %s of type %s returned unexpected error on SMB posix open, disabling posix open support. Check if server update available.\n",
513                                          tcon->ses->serverName,
514                                          tcon->ses->serverNOS);
515                         tcon->broken_posix_open = true;
516                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
517                          (rc != -EOPNOTSUPP)) /* path not found or net err */
518                         goto out;
519                 /*
520                  * Else fallthrough to retry open the old way on network i/o
521                  * or DFS errors.
522                  */
523         }
524 
525         if (server->ops->get_lease_key)
526                 server->ops->get_lease_key(inode, &fid);
527 
528         cifs_add_pending_open(&fid, tlink, &open);
529 
530         if (!posix_open_ok) {
531                 if (server->ops->get_lease_key)
532                         server->ops->get_lease_key(inode, &fid);
533 
534                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
535                                   file->f_flags, &oplock, &fid, xid);
536                 if (rc) {
537                         cifs_del_pending_open(&open);
538                         goto out;
539                 }
540         }
541 
542         cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
543         if (cfile == NULL) {
544                 if (server->ops->close)
545                         server->ops->close(xid, tcon, &fid);
546                 cifs_del_pending_open(&open);
547                 rc = -ENOMEM;
548                 goto out;
549         }
550 
551         cifs_fscache_set_inode_cookie(inode, file);
552 
553         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
554                 /*
555                  * Time to set mode which we can not set earlier due to
556                  * problems creating new read-only files.
557                  */
558                 struct cifs_unix_set_info_args args = {
559                         .mode   = inode->i_mode,
560                         .uid    = INVALID_UID, /* no change */
561                         .gid    = INVALID_GID, /* no change */
562                         .ctime  = NO_CHANGE_64,
563                         .atime  = NO_CHANGE_64,
564                         .mtime  = NO_CHANGE_64,
565                         .device = 0,
566                 };
567                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
568                                        cfile->pid);
569         }
570 
571 out:
572         kfree(full_path);
573         free_xid(xid);
574         cifs_put_tlink(tlink);
575         return rc;
576 }
577 
578 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
579 
580 /*
581  * Try to reacquire byte range locks that were released when session
582  * to server was lost.
583  */
584 static int
585 cifs_relock_file(struct cifsFileInfo *cfile)
586 {
587         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
588         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
589         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
590         int rc = 0;
591 
592         down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
593         if (cinode->can_cache_brlcks) {
594                 /* can cache locks - no need to relock */
595                 up_read(&cinode->lock_sem);
596                 return rc;
597         }
598 
599         if (cap_unix(tcon->ses) &&
600             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
601             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
602                 rc = cifs_push_posix_locks(cfile);
603         else
604                 rc = tcon->ses->server->ops->push_mand_locks(cfile);
605 
606         up_read(&cinode->lock_sem);
607         return rc;
608 }
609 
610 static int
611 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
612 {
613         int rc = -EACCES;
614         unsigned int xid;
615         __u32 oplock;
616         struct cifs_sb_info *cifs_sb;
617         struct cifs_tcon *tcon;
618         struct TCP_Server_Info *server;
619         struct cifsInodeInfo *cinode;
620         struct inode *inode;
621         char *full_path = NULL;
622         int desired_access;
623         int disposition = FILE_OPEN;
624         int create_options = CREATE_NOT_DIR;
625         struct cifs_open_parms oparms;
626 
627         xid = get_xid();
628         mutex_lock(&cfile->fh_mutex);
629         if (!cfile->invalidHandle) {
630                 mutex_unlock(&cfile->fh_mutex);
631                 rc = 0;
632                 free_xid(xid);
633                 return rc;
634         }
635 
636         inode = d_inode(cfile->dentry);
637         cifs_sb = CIFS_SB(inode->i_sb);
638         tcon = tlink_tcon(cfile->tlink);
639         server = tcon->ses->server;
640 
641         /*
642          * Can not grab rename sem here because various ops, including those
643          * that already have the rename sem can end up causing writepage to get
644          * called and if the server was down that means we end up here, and we
645          * can never tell if the caller already has the rename_sem.
646          */
647         full_path = build_path_from_dentry(cfile->dentry);
648         if (full_path == NULL) {
649                 rc = -ENOMEM;
650                 mutex_unlock(&cfile->fh_mutex);
651                 free_xid(xid);
652                 return rc;
653         }
654 
655         cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
656                  inode, cfile->f_flags, full_path);
657 
658         if (tcon->ses->server->oplocks)
659                 oplock = REQ_OPLOCK;
660         else
661                 oplock = 0;
662 
663         if (tcon->unix_ext && cap_unix(tcon->ses) &&
664             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
665                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
666                 /*
667                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
668                  * original open. Must mask them off for a reopen.
669                  */
670                 unsigned int oflags = cfile->f_flags &
671                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
672 
673                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
674                                      cifs_sb->mnt_file_mode /* ignored */,
675                                      oflags, &oplock, &cfile->fid.netfid, xid);
676                 if (rc == 0) {
677                         cifs_dbg(FYI, "posix reopen succeeded\n");
678                         oparms.reconnect = true;
679                         goto reopen_success;
680                 }
681                 /*
682                  * fallthrough to retry open the old way on errors, especially
683                  * in the reconnect path it is important to retry hard
684                  */
685         }
686 
687         desired_access = cifs_convert_flags(cfile->f_flags);
688 
689         if (backup_cred(cifs_sb))
690                 create_options |= CREATE_OPEN_BACKUP_INTENT;
691 
692         if (server->ops->get_lease_key)
693                 server->ops->get_lease_key(inode, &cfile->fid);
694 
695         oparms.tcon = tcon;
696         oparms.cifs_sb = cifs_sb;
697         oparms.desired_access = desired_access;
698         oparms.create_options = create_options;
699         oparms.disposition = disposition;
700         oparms.path = full_path;
701         oparms.fid = &cfile->fid;
702         oparms.reconnect = true;
703 
704         /*
705          * Can not refresh inode by passing in file_info buf to be returned by
706          * ops->open and then calling get_inode_info with returned buf since
707          * file might have write behind data that needs to be flushed and server
708          * version of file size can be stale. If we knew for sure that inode was
709          * not dirty locally we could do this.
710          */
711         rc = server->ops->open(xid, &oparms, &oplock, NULL);
712         if (rc == -ENOENT && oparms.reconnect == false) {
713                 /* durable handle timeout is expired - open the file again */
714                 rc = server->ops->open(xid, &oparms, &oplock, NULL);
715                 /* indicate that we need to relock the file */
716                 oparms.reconnect = true;
717         }
718 
719         if (rc) {
720                 mutex_unlock(&cfile->fh_mutex);
721                 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
722                 cifs_dbg(FYI, "oplock: %d\n", oplock);
723                 goto reopen_error_exit;
724         }
725 
726 reopen_success:
727         cfile->invalidHandle = false;
728         mutex_unlock(&cfile->fh_mutex);
729         cinode = CIFS_I(inode);
730 
731         if (can_flush) {
732                 rc = filemap_write_and_wait(inode->i_mapping);
733                 mapping_set_error(inode->i_mapping, rc);
734 
735                 if (tcon->unix_ext)
736                         rc = cifs_get_inode_info_unix(&inode, full_path,
737                                                       inode->i_sb, xid);
738                 else
739                         rc = cifs_get_inode_info(&inode, full_path, NULL,
740                                                  inode->i_sb, xid, NULL);
741         }
742         /*
743          * Else we are writing out data to server already and could deadlock if
744          * we tried to flush data, and since we do not know if we have data that
745          * would invalidate the current end of file on the server we can not go
746          * to the server to get the new inode info.
747          */
748 
749         /*
750          * If the server returned a read oplock and we have mandatory brlocks,
751          * set oplock level to None.
752          */
753         if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
754                 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
755                 oplock = 0;
756         }
757 
758         server->ops->set_fid(cfile, &cfile->fid, oplock);
759         if (oparms.reconnect)
760                 cifs_relock_file(cfile);
761 
762 reopen_error_exit:
763         kfree(full_path);
764         free_xid(xid);
765         return rc;
766 }
767 
768 int cifs_close(struct inode *inode, struct file *file)
769 {
770         if (file->private_data != NULL) {
771                 cifsFileInfo_put(file->private_data);
772                 file->private_data = NULL;
773         }
774 
775         /* return code from the ->release op is always ignored */
776         return 0;
777 }
778 
779 void
780 cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
781 {
782         struct cifsFileInfo *open_file;
783         struct list_head *tmp;
784         struct list_head *tmp1;
785         struct list_head tmp_list;
786 
787         if (!tcon->use_persistent || !tcon->need_reopen_files)
788                 return;
789 
790         tcon->need_reopen_files = false;
791 
792         cifs_dbg(FYI, "Reopen persistent handles");
793         INIT_LIST_HEAD(&tmp_list);
794 
795         /* list all files open on tree connection, reopen resilient handles  */
796         spin_lock(&tcon->open_file_lock);
797         list_for_each(tmp, &tcon->openFileList) {
798                 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
799                 if (!open_file->invalidHandle)
800                         continue;
801                 cifsFileInfo_get(open_file);
802                 list_add_tail(&open_file->rlist, &tmp_list);
803         }
804         spin_unlock(&tcon->open_file_lock);
805 
806         list_for_each_safe(tmp, tmp1, &tmp_list) {
807                 open_file = list_entry(tmp, struct cifsFileInfo, rlist);
808                 if (cifs_reopen_file(open_file, false /* do not flush */))
809                         tcon->need_reopen_files = true;
810                 list_del_init(&open_file->rlist);
811                 cifsFileInfo_put(open_file);
812         }
813 }
814 
815 int cifs_closedir(struct inode *inode, struct file *file)
816 {
817         int rc = 0;
818         unsigned int xid;
819         struct cifsFileInfo *cfile = file->private_data;
820         struct cifs_tcon *tcon;
821         struct TCP_Server_Info *server;
822         char *buf;
823 
824         cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
825 
826         if (cfile == NULL)
827                 return rc;
828 
829         xid = get_xid();
830         tcon = tlink_tcon(cfile->tlink);
831         server = tcon->ses->server;
832 
833         cifs_dbg(FYI, "Freeing private data in close dir\n");
834         spin_lock(&cfile->file_info_lock);
835         if (server->ops->dir_needs_close(cfile)) {
836                 cfile->invalidHandle = true;
837                 spin_unlock(&cfile->file_info_lock);
838                 if (server->ops->close_dir)
839                         rc = server->ops->close_dir(xid, tcon, &cfile->fid);
840                 else
841                         rc = -ENOSYS;
842                 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
843                 /* not much we can do if it fails anyway, ignore rc */
844                 rc = 0;
845         } else
846                 spin_unlock(&cfile->file_info_lock);
847 
848         buf = cfile->srch_inf.ntwrk_buf_start;
849         if (buf) {
850                 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
851                 cfile->srch_inf.ntwrk_buf_start = NULL;
852                 if (cfile->srch_inf.smallBuf)
853                         cifs_small_buf_release(buf);
854                 else
855                         cifs_buf_release(buf);
856         }
857 
858         cifs_put_tlink(cfile->tlink);
859         kfree(file->private_data);
860         file->private_data = NULL;
861         /* BB can we lock the filestruct while this is going on? */
862         free_xid(xid);
863         return rc;
864 }
865 
866 static struct cifsLockInfo *
867 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
868 {
869         struct cifsLockInfo *lock =
870                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
871         if (!lock)
872                 return lock;
873         lock->offset = offset;
874         lock->length = length;
875         lock->type = type;
876         lock->pid = current->tgid;
877         INIT_LIST_HEAD(&lock->blist);
878         init_waitqueue_head(&lock->block_q);
879         return lock;
880 }
881 
882 void
883 cifs_del_lock_waiters(struct cifsLockInfo *lock)
884 {
885         struct cifsLockInfo *li, *tmp;
886         list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
887                 list_del_init(&li->blist);
888                 wake_up(&li->block_q);
889         }
890 }
891 
892 #define CIFS_LOCK_OP    0
893 #define CIFS_READ_OP    1
894 #define CIFS_WRITE_OP   2
895 
896 /* @rw_check : 0 - no op, 1 - read, 2 - write */
897 static bool
898 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
899                             __u64 length, __u8 type, struct cifsFileInfo *cfile,
900                             struct cifsLockInfo **conf_lock, int rw_check)
901 {
902         struct cifsLockInfo *li;
903         struct cifsFileInfo *cur_cfile = fdlocks->cfile;
904         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
905 
906         list_for_each_entry(li, &fdlocks->locks, llist) {
907                 if (offset + length <= li->offset ||
908                     offset >= li->offset + li->length)
909                         continue;
910                 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
911                     server->ops->compare_fids(cfile, cur_cfile)) {
912                         /* shared lock prevents write op through the same fid */
913                         if (!(li->type & server->vals->shared_lock_type) ||
914                             rw_check != CIFS_WRITE_OP)
915                                 continue;
916                 }
917                 if ((type & server->vals->shared_lock_type) &&
918                     ((server->ops->compare_fids(cfile, cur_cfile) &&
919                      current->tgid == li->pid) || type == li->type))
920                         continue;
921                 if (conf_lock)
922                         *conf_lock = li;
923                 return true;
924         }
925         return false;
926 }
927 
928 bool
929 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
930                         __u8 type, struct cifsLockInfo **conf_lock,
931                         int rw_check)
932 {
933         bool rc = false;
934         struct cifs_fid_locks *cur;
935         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
936 
937         list_for_each_entry(cur, &cinode->llist, llist) {
938                 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
939                                                  cfile, conf_lock, rw_check);
940                 if (rc)
941                         break;
942         }
943 
944         return rc;
945 }
946 
947 /*
948  * Check if there is another lock that prevents us to set the lock (mandatory
949  * style). If such a lock exists, update the flock structure with its
950  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
951  * or leave it the same if we can't. Returns 0 if we don't need to request to
952  * the server or 1 otherwise.
953  */
954 static int
955 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
956                __u8 type, struct file_lock *flock)
957 {
958         int rc = 0;
959         struct cifsLockInfo *conf_lock;
960         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
961         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
962         bool exist;
963 
964         down_read(&cinode->lock_sem);
965 
966         exist = cifs_find_lock_conflict(cfile, offset, length, type,
967                                         &conf_lock, CIFS_LOCK_OP);
968         if (exist) {
969                 flock->fl_start = conf_lock->offset;
970                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
971                 flock->fl_pid = conf_lock->pid;
972                 if (conf_lock->type & server->vals->shared_lock_type)
973                         flock->fl_type = F_RDLCK;
974                 else
975                         flock->fl_type = F_WRLCK;
976         } else if (!cinode->can_cache_brlcks)
977                 rc = 1;
978         else
979                 flock->fl_type = F_UNLCK;
980 
981         up_read(&cinode->lock_sem);
982         return rc;
983 }
984 
985 static void
986 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
987 {
988         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
989         down_write(&cinode->lock_sem);
990         list_add_tail(&lock->llist, &cfile->llist->locks);
991         up_write(&cinode->lock_sem);
992 }
993 
994 /*
995  * Set the byte-range lock (mandatory style). Returns:
996  * 1) 0, if we set the lock and don't need to request to the server;
997  * 2) 1, if no locks prevent us but we need to request to the server;
998  * 3) -EACCESS, if there is a lock that prevents us and wait is false.
999  */
1000 static int
1001 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1002                  bool wait)
1003 {
1004         struct cifsLockInfo *conf_lock;
1005         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1006         bool exist;
1007         int rc = 0;
1008 
1009 try_again:
1010         exist = false;
1011         down_write(&cinode->lock_sem);
1012 
1013         exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1014                                         lock->type, &conf_lock, CIFS_LOCK_OP);
1015         if (!exist && cinode->can_cache_brlcks) {
1016                 list_add_tail(&lock->llist, &cfile->llist->locks);
1017                 up_write(&cinode->lock_sem);
1018                 return rc;
1019         }
1020 
1021         if (!exist)
1022                 rc = 1;
1023         else if (!wait)
1024                 rc = -EACCES;
1025         else {
1026                 list_add_tail(&lock->blist, &conf_lock->blist);
1027                 up_write(&cinode->lock_sem);
1028                 rc = wait_event_interruptible(lock->block_q,
1029                                         (lock->blist.prev == &lock->blist) &&
1030                                         (lock->blist.next == &lock->blist));
1031                 if (!rc)
1032                         goto try_again;
1033                 down_write(&cinode->lock_sem);
1034                 list_del_init(&lock->blist);
1035         }
1036 
1037         up_write(&cinode->lock_sem);
1038         return rc;
1039 }
1040 
1041 /*
1042  * Check if there is another lock that prevents us to set the lock (posix
1043  * style). If such a lock exists, update the flock structure with its
1044  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1045  * or leave it the same if we can't. Returns 0 if we don't need to request to
1046  * the server or 1 otherwise.
1047  */
1048 static int
1049 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1050 {
1051         int rc = 0;
1052         struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1053         unsigned char saved_type = flock->fl_type;
1054 
1055         if ((flock->fl_flags & FL_POSIX) == 0)
1056                 return 1;
1057 
1058         down_read(&cinode->lock_sem);
1059         posix_test_lock(file, flock);
1060 
1061         if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1062                 flock->fl_type = saved_type;
1063                 rc = 1;
1064         }
1065 
1066         up_read(&cinode->lock_sem);
1067         return rc;
1068 }
1069 
1070 /*
1071  * Set the byte-range lock (posix style). Returns:
1072  * 1) 0, if we set the lock and don't need to request to the server;
1073  * 2) 1, if we need to request to the server;
1074  * 3) <0, if the error occurs while setting the lock.
1075  */
1076 static int
1077 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1078 {
1079         struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1080         int rc = 1;
1081 
1082         if ((flock->fl_flags & FL_POSIX) == 0)
1083                 return rc;
1084 
1085 try_again:
1086         down_write(&cinode->lock_sem);
1087         if (!cinode->can_cache_brlcks) {
1088                 up_write(&cinode->lock_sem);
1089                 return rc;
1090         }
1091 
1092         rc = posix_lock_file(file, flock, NULL);
1093         up_write(&cinode->lock_sem);
1094         if (rc == FILE_LOCK_DEFERRED) {
1095                 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
1096                 if (!rc)
1097                         goto try_again;
1098                 posix_unblock_lock(flock);
1099         }
1100         return rc;
1101 }
1102 
1103 int
1104 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1105 {
1106         unsigned int xid;
1107         int rc = 0, stored_rc;
1108         struct cifsLockInfo *li, *tmp;
1109         struct cifs_tcon *tcon;
1110         unsigned int num, max_num, max_buf;
1111         LOCKING_ANDX_RANGE *buf, *cur;
1112         int types[] = {LOCKING_ANDX_LARGE_FILES,
1113                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1114         int i;
1115 
1116         xid = get_xid();
1117         tcon = tlink_tcon(cfile->tlink);
1118 
1119         /*
1120          * Accessing maxBuf is racy with cifs_reconnect - need to store value
1121          * and check it for zero before using.
1122          */
1123         max_buf = tcon->ses->server->maxBuf;
1124         if (!max_buf) {
1125                 free_xid(xid);
1126                 return -EINVAL;
1127         }
1128 
1129         max_num = (max_buf - sizeof(struct smb_hdr)) /
1130                                                 sizeof(LOCKING_ANDX_RANGE);
1131         buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1132         if (!buf) {
1133                 free_xid(xid);
1134                 return -ENOMEM;
1135         }
1136 
1137         for (i = 0; i < 2; i++) {
1138                 cur = buf;
1139                 num = 0;
1140                 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1141                         if (li->type != types[i])
1142                                 continue;
1143                         cur->Pid = cpu_to_le16(li->pid);
1144                         cur->LengthLow = cpu_to_le32((u32)li->length);
1145                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1146                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
1147                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1148                         if (++num == max_num) {
1149                                 stored_rc = cifs_lockv(xid, tcon,
1150                                                        cfile->fid.netfid,
1151                                                        (__u8)li->type, 0, num,
1152                                                        buf);
1153                                 if (stored_rc)
1154                                         rc = stored_rc;
1155                                 cur = buf;
1156                                 num = 0;
1157                         } else
1158                                 cur++;
1159                 }
1160 
1161                 if (num) {
1162                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1163                                                (__u8)types[i], 0, num, buf);
1164                         if (stored_rc)
1165                                 rc = stored_rc;
1166                 }
1167         }
1168 
1169         kfree(buf);
1170         free_xid(xid);
1171         return rc;
1172 }
1173 
1174 static __u32
1175 hash_lockowner(fl_owner_t owner)
1176 {
1177         return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1178 }
1179 
1180 struct lock_to_push {
1181         struct list_head llist;
1182         __u64 offset;
1183         __u64 length;
1184         __u32 pid;
1185         __u16 netfid;
1186         __u8 type;
1187 };
1188 
1189 static int
1190 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1191 {
1192         struct inode *inode = d_inode(cfile->dentry);
1193         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1194         struct file_lock *flock;
1195         struct file_lock_context *flctx = inode->i_flctx;
1196         unsigned int count = 0, i;
1197         int rc = 0, xid, type;
1198         struct list_head locks_to_send, *el;
1199         struct lock_to_push *lck, *tmp;
1200         __u64 length;
1201 
1202         xid = get_xid();
1203 
1204         if (!flctx)
1205                 goto out;
1206 
1207         spin_lock(&flctx->flc_lock);
1208         list_for_each(el, &flctx->flc_posix) {
1209                 count++;
1210         }
1211         spin_unlock(&flctx->flc_lock);
1212 
1213         INIT_LIST_HEAD(&locks_to_send);
1214 
1215         /*
1216          * Allocating count locks is enough because no FL_POSIX locks can be
1217          * added to the list while we are holding cinode->lock_sem that
1218          * protects locking operations of this inode.
1219          */
1220         for (i = 0; i < count; i++) {
1221                 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1222                 if (!lck) {
1223                         rc = -ENOMEM;
1224                         goto err_out;
1225                 }
1226                 list_add_tail(&lck->llist, &locks_to_send);
1227         }
1228 
1229         el = locks_to_send.next;
1230         spin_lock(&flctx->flc_lock);
1231         list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1232                 if (el == &locks_to_send) {
1233                         /*
1234                          * The list ended. We don't have enough allocated
1235                          * structures - something is really wrong.
1236                          */
1237                         cifs_dbg(VFS, "Can't push all brlocks!\n");
1238                         break;
1239                 }
1240                 length = 1 + flock->fl_end - flock->fl_start;
1241                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1242                         type = CIFS_RDLCK;
1243                 else
1244                         type = CIFS_WRLCK;
1245                 lck = list_entry(el, struct lock_to_push, llist);
1246                 lck->pid = hash_lockowner(flock->fl_owner);
1247                 lck->netfid = cfile->fid.netfid;
1248                 lck->length = length;
1249                 lck->type = type;
1250                 lck->offset = flock->fl_start;
1251         }
1252         spin_unlock(&flctx->flc_lock);
1253 
1254         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1255                 int stored_rc;
1256 
1257                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1258                                              lck->offset, lck->length, NULL,
1259                                              lck->type, 0);
1260                 if (stored_rc)
1261                         rc = stored_rc;
1262                 list_del(&lck->llist);
1263                 kfree(lck);
1264         }
1265 
1266 out:
1267         free_xid(xid);
1268         return rc;
1269 err_out:
1270         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1271                 list_del(&lck->llist);
1272                 kfree(lck);
1273         }
1274         goto out;
1275 }
1276 
1277 static int
1278 cifs_push_locks(struct cifsFileInfo *cfile)
1279 {
1280         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1281         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1282         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1283         int rc = 0;
1284 
1285         /* we are going to update can_cache_brlcks here - need a write access */
1286         down_write(&cinode->lock_sem);
1287         if (!cinode->can_cache_brlcks) {
1288                 up_write(&cinode->lock_sem);
1289                 return rc;
1290         }
1291 
1292         if (cap_unix(tcon->ses) &&
1293             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1294             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1295                 rc = cifs_push_posix_locks(cfile);
1296         else
1297                 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1298 
1299         cinode->can_cache_brlcks = false;
1300         up_write(&cinode->lock_sem);
1301         return rc;
1302 }
1303 
1304 static void
1305 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1306                 bool *wait_flag, struct TCP_Server_Info *server)
1307 {
1308         if (flock->fl_flags & FL_POSIX)
1309                 cifs_dbg(FYI, "Posix\n");
1310         if (flock->fl_flags & FL_FLOCK)
1311                 cifs_dbg(FYI, "Flock\n");
1312         if (flock->fl_flags & FL_SLEEP) {
1313                 cifs_dbg(FYI, "Blocking lock\n");
1314                 *wait_flag = true;
1315         }
1316         if (flock->fl_flags & FL_ACCESS)
1317                 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1318         if (flock->fl_flags & FL_LEASE)
1319                 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1320         if (flock->fl_flags &
1321             (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1322                FL_ACCESS | FL_LEASE | FL_CLOSE)))
1323                 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1324 
1325         *type = server->vals->large_lock_type;
1326         if (flock->fl_type == F_WRLCK) {
1327                 cifs_dbg(FYI, "F_WRLCK\n");
1328                 *type |= server->vals->exclusive_lock_type;
1329                 *lock = 1;
1330         } else if (flock->fl_type == F_UNLCK) {
1331                 cifs_dbg(FYI, "F_UNLCK\n");
1332                 *type |= server->vals->unlock_lock_type;
1333                 *unlock = 1;
1334                 /* Check if unlock includes more than one lock range */
1335         } else if (flock->fl_type == F_RDLCK) {
1336                 cifs_dbg(FYI, "F_RDLCK\n");
1337                 *type |= server->vals->shared_lock_type;
1338                 *lock = 1;
1339         } else if (flock->fl_type == F_EXLCK) {
1340                 cifs_dbg(FYI, "F_EXLCK\n");
1341                 *type |= server->vals->exclusive_lock_type;
1342                 *lock = 1;
1343         } else if (flock->fl_type == F_SHLCK) {
1344                 cifs_dbg(FYI, "F_SHLCK\n");
1345                 *type |= server->vals->shared_lock_type;
1346                 *lock = 1;
1347         } else
1348                 cifs_dbg(FYI, "Unknown type of lock\n");
1349 }
1350 
1351 static int
1352 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1353            bool wait_flag, bool posix_lck, unsigned int xid)
1354 {
1355         int rc = 0;
1356         __u64 length = 1 + flock->fl_end - flock->fl_start;
1357         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1358         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1359         struct TCP_Server_Info *server = tcon->ses->server;
1360         __u16 netfid = cfile->fid.netfid;
1361 
1362         if (posix_lck) {
1363                 int posix_lock_type;
1364 
1365                 rc = cifs_posix_lock_test(file, flock);
1366                 if (!rc)
1367                         return rc;
1368 
1369                 if (type & server->vals->shared_lock_type)
1370                         posix_lock_type = CIFS_RDLCK;
1371                 else
1372                         posix_lock_type = CIFS_WRLCK;
1373                 rc = CIFSSMBPosixLock(xid, tcon, netfid,
1374                                       hash_lockowner(flock->fl_owner),
1375                                       flock->fl_start, length, flock,
1376                                       posix_lock_type, wait_flag);
1377                 return rc;
1378         }
1379 
1380         rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1381         if (!rc)
1382                 return rc;
1383 
1384         /* BB we could chain these into one lock request BB */
1385         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1386                                     1, 0, false);
1387         if (rc == 0) {
1388                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1389                                             type, 0, 1, false);
1390                 flock->fl_type = F_UNLCK;
1391                 if (rc != 0)
1392                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1393                                  rc);
1394                 return 0;
1395         }
1396 
1397         if (type & server->vals->shared_lock_type) {
1398                 flock->fl_type = F_WRLCK;
1399                 return 0;
1400         }
1401 
1402         type &= ~server->vals->exclusive_lock_type;
1403 
1404         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1405                                     type | server->vals->shared_lock_type,
1406                                     1, 0, false);
1407         if (rc == 0) {
1408                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1409                         type | server->vals->shared_lock_type, 0, 1, false);
1410                 flock->fl_type = F_RDLCK;
1411                 if (rc != 0)
1412                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1413                                  rc);
1414         } else
1415                 flock->fl_type = F_WRLCK;
1416 
1417         return 0;
1418 }
1419 
1420 void
1421 cifs_move_llist(struct list_head *source, struct list_head *dest)
1422 {
1423         struct list_head *li, *tmp;
1424         list_for_each_safe(li, tmp, source)
1425                 list_move(li, dest);
1426 }
1427 
1428 void
1429 cifs_free_llist(struct list_head *llist)
1430 {
1431         struct cifsLockInfo *li, *tmp;
1432         list_for_each_entry_safe(li, tmp, llist, llist) {
1433                 cifs_del_lock_waiters(li);
1434                 list_del(&li->llist);
1435                 kfree(li);
1436         }
1437 }
1438 
1439 int
1440 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1441                   unsigned int xid)
1442 {
1443         int rc = 0, stored_rc;
1444         int types[] = {LOCKING_ANDX_LARGE_FILES,
1445                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1446         unsigned int i;
1447         unsigned int max_num, num, max_buf;
1448         LOCKING_ANDX_RANGE *buf, *cur;
1449         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1450         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1451         struct cifsLockInfo *li, *tmp;
1452         __u64 length = 1 + flock->fl_end - flock->fl_start;
1453         struct list_head tmp_llist;
1454 
1455         INIT_LIST_HEAD(&tmp_llist);
1456 
1457         /*
1458          * Accessing maxBuf is racy with cifs_reconnect - need to store value
1459          * and check it for zero before using.
1460          */
1461         max_buf = tcon->ses->server->maxBuf;
1462         if (!max_buf)
1463                 return -EINVAL;
1464 
1465         max_num = (max_buf - sizeof(struct smb_hdr)) /
1466                                                 sizeof(LOCKING_ANDX_RANGE);
1467         buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1468         if (!buf)
1469                 return -ENOMEM;
1470 
1471         down_write(&cinode->lock_sem);
1472         for (i = 0; i < 2; i++) {
1473                 cur = buf;
1474                 num = 0;
1475                 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1476                         if (flock->fl_start > li->offset ||
1477                             (flock->fl_start + length) <
1478                             (li->offset + li->length))
1479                                 continue;
1480                         if (current->tgid != li->pid)
1481                                 continue;
1482                         if (types[i] != li->type)
1483                                 continue;
1484                         if (cinode->can_cache_brlcks) {
1485                                 /*
1486                                  * We can cache brlock requests - simply remove
1487                                  * a lock from the file's list.
1488                                  */
1489                                 list_del(&li->llist);
1490                                 cifs_del_lock_waiters(li);
1491                                 kfree(li);
1492                                 continue;
1493                         }
1494                         cur->Pid = cpu_to_le16(li->pid);
1495                         cur->LengthLow = cpu_to_le32((u32)li->length);
1496                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1497                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
1498                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1499                         /*
1500                          * We need to save a lock here to let us add it again to
1501                          * the file's list if the unlock range request fails on
1502                          * the server.
1503                          */
1504                         list_move(&li->llist, &tmp_llist);
1505                         if (++num == max_num) {
1506                                 stored_rc = cifs_lockv(xid, tcon,
1507                                                        cfile->fid.netfid,
1508                                                        li->type, num, 0, buf);
1509                                 if (stored_rc) {
1510                                         /*
1511                                          * We failed on the unlock range
1512                                          * request - add all locks from the tmp
1513                                          * list to the head of the file's list.
1514                                          */
1515                                         cifs_move_llist(&tmp_llist,
1516                                                         &cfile->llist->locks);
1517                                         rc = stored_rc;
1518                                 } else
1519                                         /*
1520                                          * The unlock range request succeed -
1521                                          * free the tmp list.
1522                                          */
1523                                         cifs_free_llist(&tmp_llist);
1524                                 cur = buf;
1525                                 num = 0;
1526                         } else
1527                                 cur++;
1528                 }
1529                 if (num) {
1530                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1531                                                types[i], num, 0, buf);
1532                         if (stored_rc) {
1533                                 cifs_move_llist(&tmp_llist,
1534                                                 &cfile->llist->locks);
1535                                 rc = stored_rc;
1536                         } else
1537                                 cifs_free_llist(&tmp_llist);
1538                 }
1539         }
1540 
1541         up_write(&cinode->lock_sem);
1542         kfree(buf);
1543         return rc;
1544 }
1545 
1546 static int
1547 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1548            bool wait_flag, bool posix_lck, int lock, int unlock,
1549            unsigned int xid)
1550 {
1551         int rc = 0;
1552         __u64 length = 1 + flock->fl_end - flock->fl_start;
1553         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1554         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1555         struct TCP_Server_Info *server = tcon->ses->server;
1556         struct inode *inode = d_inode(cfile->dentry);
1557 
1558         if (posix_lck) {
1559                 int posix_lock_type;
1560 
1561                 rc = cifs_posix_lock_set(file, flock);
1562                 if (!rc || rc < 0)
1563                         return rc;
1564 
1565                 if (type & server->vals->shared_lock_type)
1566                         posix_lock_type = CIFS_RDLCK;
1567                 else
1568                         posix_lock_type = CIFS_WRLCK;
1569 
1570                 if (unlock == 1)
1571                         posix_lock_type = CIFS_UNLCK;
1572 
1573                 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1574                                       hash_lockowner(flock->fl_owner),
1575                                       flock->fl_start, length,
1576                                       NULL, posix_lock_type, wait_flag);
1577                 goto out;
1578         }
1579 
1580         if (lock) {
1581                 struct cifsLockInfo *lock;
1582 
1583                 lock = cifs_lock_init(flock->fl_start, length, type);
1584                 if (!lock)
1585                         return -ENOMEM;
1586 
1587                 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1588                 if (rc < 0) {
1589                         kfree(lock);
1590                         return rc;
1591                 }
1592                 if (!rc)
1593                         goto out;
1594 
1595                 /*
1596                  * Windows 7 server can delay breaking lease from read to None
1597                  * if we set a byte-range lock on a file - break it explicitly
1598                  * before sending the lock to the server to be sure the next
1599                  * read won't conflict with non-overlapted locks due to
1600                  * pagereading.
1601                  */
1602                 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1603                                         CIFS_CACHE_READ(CIFS_I(inode))) {
1604                         cifs_zap_mapping(inode);
1605                         cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1606                                  inode);
1607                         CIFS_I(inode)->oplock = 0;
1608                 }
1609 
1610                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1611                                             type, 1, 0, wait_flag);
1612                 if (rc) {
1613                         kfree(lock);
1614                         return rc;
1615                 }
1616 
1617                 cifs_lock_add(cfile, lock);
1618         } else if (unlock)
1619                 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1620 
1621 out:
1622         if (flock->fl_flags & FL_POSIX && !rc)
1623                 rc = locks_lock_file_wait(file, flock);
1624         return rc;
1625 }
1626 
1627 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1628 {
1629         int rc, xid;
1630         int lock = 0, unlock = 0;
1631         bool wait_flag = false;
1632         bool posix_lck = false;
1633         struct cifs_sb_info *cifs_sb;
1634         struct cifs_tcon *tcon;
1635         struct cifsInodeInfo *cinode;
1636         struct cifsFileInfo *cfile;
1637         __u16 netfid;
1638         __u32 type;
1639 
1640         rc = -EACCES;
1641         xid = get_xid();
1642 
1643         cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1644                  cmd, flock->fl_flags, flock->fl_type,
1645                  flock->fl_start, flock->fl_end);
1646 
1647         cfile = (struct cifsFileInfo *)file->private_data;
1648         tcon = tlink_tcon(cfile->tlink);
1649 
1650         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1651                         tcon->ses->server);
1652 
1653         cifs_sb = CIFS_FILE_SB(file);
1654         netfid = cfile->fid.netfid;
1655         cinode = CIFS_I(file_inode(file));
1656 
1657         if (cap_unix(tcon->ses) &&
1658             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1659             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1660                 posix_lck = true;
1661         /*
1662          * BB add code here to normalize offset and length to account for
1663          * negative length which we can not accept over the wire.
1664          */
1665         if (IS_GETLK(cmd)) {
1666                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1667                 free_xid(xid);
1668                 return rc;
1669         }
1670 
1671         if (!lock && !unlock) {
1672                 /*
1673                  * if no lock or unlock then nothing to do since we do not
1674                  * know what it is
1675                  */
1676                 free_xid(xid);
1677                 return -EOPNOTSUPP;
1678         }
1679 
1680         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1681                         xid);
1682         free_xid(xid);
1683         return rc;
1684 }
1685 
1686 /*
1687  * update the file size (if needed) after a write. Should be called with
1688  * the inode->i_lock held
1689  */
1690 void
1691 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1692                       unsigned int bytes_written)
1693 {
1694         loff_t end_of_write = offset + bytes_written;
1695 
1696         if (end_of_write > cifsi->server_eof)
1697                 cifsi->server_eof = end_of_write;
1698 }
1699 
1700 static ssize_t
1701 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1702            size_t write_size, loff_t *offset)
1703 {
1704         int rc = 0;
1705         unsigned int bytes_written = 0;
1706         unsigned int total_written;
1707         struct cifs_sb_info *cifs_sb;
1708         struct cifs_tcon *tcon;
1709         struct TCP_Server_Info *server;
1710         unsigned int xid;
1711         struct dentry *dentry = open_file->dentry;
1712         struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1713         struct cifs_io_parms io_parms;
1714 
1715         cifs_sb = CIFS_SB(dentry->d_sb);
1716 
1717         cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1718                  write_size, *offset, dentry);
1719 
1720         tcon = tlink_tcon(open_file->tlink);
1721         server = tcon->ses->server;
1722 
1723         if (!server->ops->sync_write)
1724                 return -ENOSYS;
1725 
1726         xid = get_xid();
1727 
1728         for (total_written = 0; write_size > total_written;
1729              total_written += bytes_written) {
1730                 rc = -EAGAIN;
1731                 while (rc == -EAGAIN) {
1732                         struct kvec iov[2];
1733                         unsigned int len;
1734 
1735                         if (open_file->invalidHandle) {
1736                                 /* we could deadlock if we called
1737                                    filemap_fdatawait from here so tell
1738                                    reopen_file not to flush data to
1739                                    server now */
1740                                 rc = cifs_reopen_file(open_file, false);
1741                                 if (rc != 0)
1742                                         break;
1743                         }
1744 
1745                         len = min(server->ops->wp_retry_size(d_inode(dentry)),
1746                                   (unsigned int)write_size - total_written);
1747                         /* iov[0] is reserved for smb header */
1748                         iov[1].iov_base = (char *)write_data + total_written;
1749                         iov[1].iov_len = len;
1750                         io_parms.pid = pid;
1751                         io_parms.tcon = tcon;
1752                         io_parms.offset = *offset;
1753                         io_parms.length = len;
1754                         rc = server->ops->sync_write(xid, &open_file->fid,
1755                                         &io_parms, &bytes_written, iov, 1);
1756                 }
1757                 if (rc || (bytes_written == 0)) {
1758                         if (total_written)
1759                                 break;
1760                         else {
1761                                 free_xid(xid);
1762                                 return rc;
1763                         }
1764                 } else {
1765                         spin_lock(&d_inode(dentry)->i_lock);
1766                         cifs_update_eof(cifsi, *offset, bytes_written);
1767                         spin_unlock(&d_inode(dentry)->i_lock);
1768                         *offset += bytes_written;
1769                 }
1770         }
1771 
1772         cifs_stats_bytes_written(tcon, total_written);
1773 
1774         if (total_written > 0) {
1775                 spin_lock(&d_inode(dentry)->i_lock);
1776                 if (*offset > d_inode(dentry)->i_size)
1777                         i_size_write(d_inode(dentry), *offset);
1778                 spin_unlock(&d_inode(dentry)->i_lock);
1779         }
1780         mark_inode_dirty_sync(d_inode(dentry));
1781         free_xid(xid);
1782         return total_written;
1783 }
1784 
1785 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1786                                         bool fsuid_only)
1787 {
1788         struct cifsFileInfo *open_file = NULL;
1789         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1790         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1791 
1792         /* only filter by fsuid on multiuser mounts */
1793         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1794                 fsuid_only = false;
1795 
1796         spin_lock(&tcon->open_file_lock);
1797         /* we could simply get the first_list_entry since write-only entries
1798            are always at the end of the list but since the first entry might
1799            have a close pending, we go through the whole list */
1800         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1801                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1802                         continue;
1803                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1804                         if (!open_file->invalidHandle) {
1805                                 /* found a good file */
1806                                 /* lock it so it will not be closed on us */
1807                                 cifsFileInfo_get(open_file);
1808                                 spin_unlock(&tcon->open_file_lock);
1809                                 return open_file;
1810                         } /* else might as well continue, and look for
1811                              another, or simply have the caller reopen it
1812                              again rather than trying to fix this handle */
1813                 } else /* write only file */
1814                         break; /* write only files are last so must be done */
1815         }
1816         spin_unlock(&tcon->open_file_lock);
1817         return NULL;
1818 }
1819 
1820 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1821                                         bool fsuid_only)
1822 {
1823         struct cifsFileInfo *open_file, *inv_file = NULL;
1824         struct cifs_sb_info *cifs_sb;
1825         struct cifs_tcon *tcon;
1826         bool any_available = false;
1827         int rc;
1828         unsigned int refind = 0;
1829 
1830         /* Having a null inode here (because mapping->host was set to zero by
1831         the VFS or MM) should not happen but we had reports of on oops (due to
1832         it being zero) during stress testcases so we need to check for it */
1833 
1834         if (cifs_inode == NULL) {
1835                 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1836                 dump_stack();
1837                 return NULL;
1838         }
1839 
1840         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1841         tcon = cifs_sb_master_tcon(cifs_sb);
1842 
1843         /* only filter by fsuid on multiuser mounts */
1844         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1845                 fsuid_only = false;
1846 
1847         spin_lock(&tcon->open_file_lock);
1848 refind_writable:
1849         if (refind > MAX_REOPEN_ATT) {
1850                 spin_unlock(&tcon->open_file_lock);
1851                 return NULL;
1852         }
1853         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1854                 if (!any_available && open_file->pid != current->tgid)
1855                         continue;
1856                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1857                         continue;
1858                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1859                         if (!open_file->invalidHandle) {
1860                                 /* found a good writable file */
1861                                 cifsFileInfo_get(open_file);
1862                                 spin_unlock(&tcon->open_file_lock);
1863                                 return open_file;
1864                         } else {
1865                                 if (!inv_file)
1866                                         inv_file = open_file;
1867                         }
1868                 }
1869         }
1870         /* couldn't find useable FH with same pid, try any available */
1871         if (!any_available) {
1872                 any_available = true;
1873                 goto refind_writable;
1874         }
1875 
1876         if (inv_file) {
1877                 any_available = false;
1878                 cifsFileInfo_get(inv_file);
1879         }
1880 
1881         spin_unlock(&tcon->open_file_lock);
1882 
1883         if (inv_file) {
1884                 rc = cifs_reopen_file(inv_file, false);
1885                 if (!rc)
1886                         return inv_file;
1887                 else {
1888                         spin_lock(&tcon->open_file_lock);
1889                         list_move_tail(&inv_file->flist,
1890                                         &cifs_inode->openFileList);
1891                         spin_unlock(&tcon->open_file_lock);
1892                         cifsFileInfo_put(inv_file);
1893                         ++refind;
1894                         inv_file = NULL;
1895                         spin_lock(&tcon->open_file_lock);
1896                         goto refind_writable;
1897                 }
1898         }
1899 
1900         return NULL;
1901 }
1902 
1903 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1904 {
1905         struct address_space *mapping = page->mapping;
1906         loff_t offset = (loff_t)page->index << PAGE_SHIFT;
1907         char *write_data;
1908         int rc = -EFAULT;
1909         int bytes_written = 0;
1910         struct inode *inode;
1911         struct cifsFileInfo *open_file;
1912 
1913         if (!mapping || !mapping->host)
1914                 return -EFAULT;
1915 
1916         inode = page->mapping->host;
1917 
1918         offset += (loff_t)from;
1919         write_data = kmap(page);
1920         write_data += from;
1921 
1922         if ((to > PAGE_SIZE) || (from > to)) {
1923                 kunmap(page);
1924                 return -EIO;
1925         }
1926 
1927         /* racing with truncate? */
1928         if (offset > mapping->host->i_size) {
1929                 kunmap(page);
1930                 return 0; /* don't care */
1931         }
1932 
1933         /* check to make sure that we are not extending the file */
1934         if (mapping->host->i_size - offset < (loff_t)to)
1935                 to = (unsigned)(mapping->host->i_size - offset);
1936 
1937         open_file = find_writable_file(CIFS_I(mapping->host), false);
1938         if (open_file) {
1939                 bytes_written = cifs_write(open_file, open_file->pid,
1940                                            write_data, to - from, &offset);
1941                 cifsFileInfo_put(open_file);
1942                 /* Does mm or vfs already set times? */
1943                 inode->i_atime = inode->i_mtime = current_time(inode);
1944                 if ((bytes_written > 0) && (offset))
1945                         rc = 0;
1946                 else if (bytes_written < 0)
1947                         rc = bytes_written;
1948         } else {
1949                 cifs_dbg(FYI, "No writeable filehandles for inode\n");
1950                 rc = -EIO;
1951         }
1952 
1953         kunmap(page);
1954         return rc;
1955 }
1956 
1957 static struct cifs_writedata *
1958 wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
1959                           pgoff_t end, pgoff_t *index,
1960                           unsigned int *found_pages)
1961 {
1962         unsigned int nr_pages;
1963         struct page **pages;
1964         struct cifs_writedata *wdata;
1965 
1966         wdata = cifs_writedata_alloc((unsigned int)tofind,
1967                                      cifs_writev_complete);
1968         if (!wdata)
1969                 return NULL;
1970 
1971         /*
1972          * find_get_pages_tag seems to return a max of 256 on each
1973          * iteration, so we must call it several times in order to
1974          * fill the array or the wsize is effectively limited to
1975          * 256 * PAGE_SIZE.
1976          */
1977         *found_pages = 0;
1978         pages = wdata->pages;
1979         do {
1980                 nr_pages = find_get_pages_tag(mapping, index,
1981                                               PAGECACHE_TAG_DIRTY, tofind,
1982                                               pages);
1983                 *found_pages += nr_pages;
1984                 tofind -= nr_pages;
1985                 pages += nr_pages;
1986         } while (nr_pages && tofind && *index <= end);
1987 
1988         return wdata;
1989 }
1990 
1991 static unsigned int
1992 wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
1993                     struct address_space *mapping,
1994                     struct writeback_control *wbc,
1995                     pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
1996 {
1997         unsigned int nr_pages = 0, i;
1998         struct page *page;
1999 
2000         for (i = 0; i < found_pages; i++) {
2001                 page = wdata->pages[i];
2002                 /*
2003                  * At this point we hold neither mapping->tree_lock nor
2004                  * lock on the page itself: the page may be truncated or
2005                  * invalidated (changing page->mapping to NULL), or even
2006                  * swizzled back from swapper_space to tmpfs file
2007                  * mapping
2008                  */
2009 
2010                 if (nr_pages == 0)
2011                         lock_page(page);
2012                 else if (!trylock_page(page))
2013                         break;
2014 
2015                 if (unlikely(page->mapping != mapping)) {
2016                         unlock_page(page);
2017                         break;
2018                 }
2019 
2020                 if (!wbc->range_cyclic && page->index > end) {
2021                         *done = true;
2022                         unlock_page(page);
2023                         break;
2024                 }
2025 
2026                 if (*next && (page->index != *next)) {
2027                         /* Not next consecutive page */
2028                         unlock_page(page);
2029                         break;
2030                 }
2031 
2032                 if (wbc->sync_mode != WB_SYNC_NONE)
2033                         wait_on_page_writeback(page);
2034 
2035                 if (PageWriteback(page) ||
2036                                 !clear_page_dirty_for_io(page)) {
2037                         unlock_page(page);
2038                         break;
2039                 }
2040 
2041                 /*
2042                  * This actually clears the dirty bit in the radix tree.
2043                  * See cifs_writepage() for more commentary.
2044                  */
2045                 set_page_writeback(page);
2046                 if (page_offset(page) >= i_size_read(mapping->host)) {
2047                         *done = true;
2048                         unlock_page(page);
2049                         end_page_writeback(page);
2050                         break;
2051                 }
2052 
2053                 wdata->pages[i] = page;
2054                 *next = page->index + 1;
2055                 ++nr_pages;
2056         }
2057 
2058         /* reset index to refind any pages skipped */
2059         if (nr_pages == 0)
2060                 *index = wdata->pages[0]->index + 1;
2061 
2062         /* put any pages we aren't going to use */
2063         for (i = nr_pages; i < found_pages; i++) {
2064                 put_page(wdata->pages[i]);
2065                 wdata->pages[i] = NULL;
2066         }
2067 
2068         return nr_pages;
2069 }
2070 
2071 static int
2072 wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2073                  struct address_space *mapping, struct writeback_control *wbc)
2074 {
2075         int rc = 0;
2076         struct TCP_Server_Info *server;
2077         unsigned int i;
2078 
2079         wdata->sync_mode = wbc->sync_mode;
2080         wdata->nr_pages = nr_pages;
2081         wdata->offset = page_offset(wdata->pages[0]);
2082         wdata->pagesz = PAGE_SIZE;
2083         wdata->tailsz = min(i_size_read(mapping->host) -
2084                         page_offset(wdata->pages[nr_pages - 1]),
2085                         (loff_t)PAGE_SIZE);
2086         wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2087 
2088         if (wdata->cfile != NULL)
2089                 cifsFileInfo_put(wdata->cfile);
2090         wdata->cfile = find_writable_file(CIFS_I(mapping->host), false);
2091         if (!wdata->cfile) {
2092                 cifs_dbg(VFS, "No writable handles for inode\n");
2093                 rc = -EBADF;
2094         } else {
2095                 wdata->pid = wdata->cfile->pid;
2096                 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2097                 rc = server->ops->async_writev(wdata, cifs_writedata_release);
2098         }
2099 
2100         for (i = 0; i < nr_pages; ++i)
2101                 unlock_page(wdata->pages[i]);
2102 
2103         return rc;
2104 }
2105 
2106 static int cifs_writepages(struct address_space *mapping,
2107                            struct writeback_control *wbc)
2108 {
2109         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
2110         struct TCP_Server_Info *server;
2111         bool done = false, scanned = false, range_whole = false;
2112         pgoff_t end, index;
2113         struct cifs_writedata *wdata;
2114         int rc = 0;
2115 
2116         /*
2117          * If wsize is smaller than the page cache size, default to writing
2118          * one page at a time via cifs_writepage
2119          */
2120         if (cifs_sb->wsize < PAGE_SIZE)
2121                 return generic_writepages(mapping, wbc);
2122 
2123         if (wbc->range_cyclic) {
2124                 index = mapping->writeback_index; /* Start from prev offset */
2125                 end = -1;
2126         } else {
2127                 index = wbc->range_start >> PAGE_SHIFT;
2128                 end = wbc->range_end >> PAGE_SHIFT;
2129                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2130                         range_whole = true;
2131                 scanned = true;
2132         }
2133         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2134 retry:
2135         while (!done && index <= end) {
2136                 unsigned int i, nr_pages, found_pages, wsize, credits;
2137                 pgoff_t next = 0, tofind, saved_index = index;
2138 
2139                 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2140                                                    &wsize, &credits);
2141                 if (rc)
2142                         break;
2143 
2144                 tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2145 
2146                 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2147                                                   &found_pages);
2148                 if (!wdata) {
2149                         rc = -ENOMEM;
2150                         add_credits_and_wake_if(server, credits, 0);
2151                         break;
2152                 }
2153 
2154                 if (found_pages == 0) {
2155                         kref_put(&wdata->refcount, cifs_writedata_release);
2156                         add_credits_and_wake_if(server, credits, 0);
2157                         break;
2158                 }
2159 
2160                 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2161                                                end, &index, &next, &done);
2162 
2163                 /* nothing to write? */
2164                 if (nr_pages == 0) {
2165                         kref_put(&wdata->refcount, cifs_writedata_release);
2166                         add_credits_and_wake_if(server, credits, 0);
2167                         continue;
2168                 }
2169 
2170                 wdata->credits = credits;
2171 
2172                 rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2173 
2174                 /* send failure -- clean up the mess */
2175                 if (rc != 0) {
2176                         add_credits_and_wake_if(server, wdata->credits, 0);
2177                         for (i = 0; i < nr_pages; ++i) {
2178                                 if (rc == -EAGAIN)
2179                                         redirty_page_for_writepage(wbc,
2180                                                            wdata->pages[i]);
2181                                 else
2182                                         SetPageError(wdata->pages[i]);
2183                                 end_page_writeback(wdata->pages[i]);
2184                                 put_page(wdata->pages[i]);
2185                         }
2186                         if (rc != -EAGAIN)
2187                                 mapping_set_error(mapping, rc);
2188                 }
2189                 kref_put(&wdata->refcount, cifs_writedata_release);
2190 
2191                 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2192                         index = saved_index;
2193                         continue;
2194                 }
2195 
2196                 wbc->nr_to_write -= nr_pages;
2197                 if (wbc->nr_to_write <= 0)
2198                         done = true;
2199 
2200                 index = next;
2201         }
2202 
2203         if (!scanned && !done) {
2204                 /*
2205                  * We hit the last page and there is more work to be done: wrap
2206                  * back to the start of the file
2207                  */
2208                 scanned = true;
2209                 index = 0;
2210                 goto retry;
2211         }
2212 
2213         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2214                 mapping->writeback_index = index;
2215 
2216         return rc;
2217 }
2218 
2219 static int
2220 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2221 {
2222         int rc;
2223         unsigned int xid;
2224 
2225         xid = get_xid();
2226 /* BB add check for wbc flags */
2227         get_page(page);
2228         if (!PageUptodate(page))
2229                 cifs_dbg(FYI, "ppw - page not up to date\n");
2230 
2231         /*
2232          * Set the "writeback" flag, and clear "dirty" in the radix tree.
2233          *
2234          * A writepage() implementation always needs to do either this,
2235          * or re-dirty the page with "redirty_page_for_writepage()" in
2236          * the case of a failure.
2237          *
2238          * Just unlocking the page will cause the radix tree tag-bits
2239          * to fail to update with the state of the page correctly.
2240          */
2241         set_page_writeback(page);
2242 retry_write:
2243         rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2244         if (rc == -EAGAIN) {
2245                 if (wbc->sync_mode == WB_SYNC_ALL)
2246                         goto retry_write;
2247                 redirty_page_for_writepage(wbc, page);
2248         } else if (rc != 0) {
2249                 SetPageError(page);
2250                 mapping_set_error(page->mapping, rc);
2251         } else {
2252                 SetPageUptodate(page);
2253         }
2254         end_page_writeback(page);
2255         put_page(page);
2256         free_xid(xid);
2257         return rc;
2258 }
2259 
2260 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2261 {
2262         int rc = cifs_writepage_locked(page, wbc);
2263         unlock_page(page);
2264         return rc;
2265 }
2266 
2267 static int cifs_write_end(struct file *file, struct address_space *mapping,
2268                         loff_t pos, unsigned len, unsigned copied,
2269                         struct page *page, void *fsdata)
2270 {
2271         int rc;
2272         struct inode *inode = mapping->host;
2273         struct cifsFileInfo *cfile = file->private_data;
2274         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2275         __u32 pid;
2276 
2277         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2278                 pid = cfile->pid;
2279         else
2280                 pid = current->tgid;
2281 
2282         cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2283                  page, pos, copied);
2284 
2285         if (PageChecked(page)) {
2286                 if (copied == len)
2287                         SetPageUptodate(page);
2288                 ClearPageChecked(page);
2289         } else if (!PageUptodate(page) && copied == PAGE_SIZE)
2290                 SetPageUptodate(page);
2291 
2292         if (!PageUptodate(page)) {
2293                 char *page_data;
2294                 unsigned offset = pos & (PAGE_SIZE - 1);
2295                 unsigned int xid;
2296 
2297                 xid = get_xid();
2298                 /* this is probably better than directly calling
2299                    partialpage_write since in this function the file handle is
2300                    known which we might as well leverage */
2301                 /* BB check if anything else missing out of ppw
2302                    such as updating last write time */
2303                 page_data = kmap(page);
2304                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2305                 /* if (rc < 0) should we set writebehind rc? */
2306                 kunmap(page);
2307 
2308                 free_xid(xid);
2309         } else {
2310                 rc = copied;
2311                 pos += copied;
2312                 set_page_dirty(page);
2313         }
2314 
2315         if (rc > 0) {
2316                 spin_lock(&inode->i_lock);
2317                 if (pos > inode->i_size)
2318                         i_size_write(inode, pos);
2319                 spin_unlock(&inode->i_lock);
2320         }
2321 
2322         unlock_page(page);
2323         put_page(page);
2324 
2325         return rc;
2326 }
2327 
2328 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2329                       int datasync)
2330 {
2331         unsigned int xid;
2332         int rc = 0;
2333         struct cifs_tcon *tcon;
2334         struct TCP_Server_Info *server;
2335         struct cifsFileInfo *smbfile = file->private_data;
2336         struct inode *inode = file_inode(file);
2337         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2338 
2339         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2340         if (rc)
2341                 return rc;
2342         inode_lock(inode);
2343 
2344         xid = get_xid();
2345 
2346         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2347                  file, datasync);
2348 
2349         if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2350                 rc = cifs_zap_mapping(inode);
2351                 if (rc) {
2352                         cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2353                         rc = 0; /* don't care about it in fsync */
2354                 }
2355         }
2356 
2357         tcon = tlink_tcon(smbfile->tlink);
2358         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2359                 server = tcon->ses->server;
2360                 if (server->ops->flush)
2361                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2362                 else
2363                         rc = -ENOSYS;
2364         }
2365 
2366         free_xid(xid);
2367         inode_unlock(inode);
2368         return rc;
2369 }
2370 
2371 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2372 {
2373         unsigned int xid;
2374         int rc = 0;
2375         struct cifs_tcon *tcon;
2376         struct TCP_Server_Info *server;
2377         struct cifsFileInfo *smbfile = file->private_data;
2378         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2379         struct inode *inode = file->f_mapping->host;
2380 
2381         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2382         if (rc)
2383                 return rc;
2384         inode_lock(inode);
2385 
2386         xid = get_xid();
2387 
2388         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2389                  file, datasync);
2390 
2391         tcon = tlink_tcon(smbfile->tlink);
2392         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2393                 server = tcon->ses->server;
2394                 if (server->ops->flush)
2395                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2396                 else
2397                         rc = -ENOSYS;
2398         }
2399 
2400         free_xid(xid);
2401         inode_unlock(inode);
2402         return rc;
2403 }
2404 
2405 /*
2406  * As file closes, flush all cached write data for this inode checking
2407  * for write behind errors.
2408  */
2409 int cifs_flush(struct file *file, fl_owner_t id)
2410 {
2411         struct inode *inode = file_inode(file);
2412         int rc = 0;
2413 
2414         if (file->f_mode & FMODE_WRITE)
2415                 rc = filemap_write_and_wait(inode->i_mapping);
2416 
2417         cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2418 
2419         return rc;
2420 }
2421 
2422 static int
2423 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2424 {
2425         int rc = 0;
2426         unsigned long i;
2427 
2428         for (i = 0; i < num_pages; i++) {
2429                 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2430                 if (!pages[i]) {
2431                         /*
2432                          * save number of pages we have already allocated and
2433                          * return with ENOMEM error
2434                          */
2435                         num_pages = i;
2436                         rc = -ENOMEM;
2437                         break;
2438                 }
2439         }
2440 
2441         if (rc) {
2442                 for (i = 0; i < num_pages; i++)
2443                         put_page(pages[i]);
2444         }
2445         return rc;
2446 }
2447 
2448 static inline
2449 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2450 {
2451         size_t num_pages;
2452         size_t clen;
2453 
2454         clen = min_t(const size_t, len, wsize);
2455         num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2456 
2457         if (cur_len)
2458                 *cur_len = clen;
2459 
2460         return num_pages;
2461 }
2462 
2463 static void
2464 cifs_uncached_writedata_release(struct kref *refcount)
2465 {
2466         int i;
2467         struct cifs_writedata *wdata = container_of(refcount,
2468                                         struct cifs_writedata, refcount);
2469 
2470         kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2471         for (i = 0; i < wdata->nr_pages; i++)
2472                 put_page(wdata->pages[i]);
2473         cifs_writedata_release(refcount);
2474 }
2475 
2476 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);
2477 
2478 static void
2479 cifs_uncached_writev_complete(struct work_struct *work)
2480 {
2481         struct cifs_writedata *wdata = container_of(work,
2482                                         struct cifs_writedata, work);
2483         struct inode *inode = d_inode(wdata->cfile->dentry);
2484         struct cifsInodeInfo *cifsi = CIFS_I(inode);
2485 
2486         spin_lock(&inode->i_lock);
2487         cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2488         if (cifsi->server_eof > inode->i_size)
2489                 i_size_write(inode, cifsi->server_eof);
2490         spin_unlock(&inode->i_lock);
2491 
2492         complete(&wdata->done);
2493         collect_uncached_write_data(wdata->ctx);
2494         /* the below call can possibly free the last ref to aio ctx */
2495         kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2496 }
2497 
2498 static int
2499 wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2500                       size_t *len, unsigned long *num_pages)
2501 {
2502         size_t save_len, copied, bytes, cur_len = *len;
2503         unsigned long i, nr_pages = *num_pages;
2504 
2505         save_len = cur_len;
2506         for (i = 0; i < nr_pages; i++) {
2507                 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2508                 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2509                 cur_len -= copied;
2510                 /*
2511                  * If we didn't copy as much as we expected, then that
2512                  * may mean we trod into an unmapped area. Stop copying
2513                  * at that point. On the next pass through the big
2514                  * loop, we'll likely end up getting a zero-length
2515                  * write and bailing out of it.
2516                  */
2517                 if (copied < bytes)
2518                         break;
2519         }
2520         cur_len = save_len - cur_len;
2521         *len = cur_len;
2522 
2523         /*
2524          * If we have no data to send, then that probably means that
2525          * the copy above failed altogether. That's most likely because
2526          * the address in the iovec was bogus. Return -EFAULT and let
2527          * the caller free anything we allocated and bail out.
2528          */
2529         if (!cur_len)
2530                 return -EFAULT;
2531 
2532         /*
2533          * i + 1 now represents the number of pages we actually used in
2534          * the copy phase above.
2535          */
2536         *num_pages = i + 1;
2537         return 0;
2538 }
2539 
2540 static int
2541 cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2542                      struct cifsFileInfo *open_file,
2543                      struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
2544                      struct cifs_aio_ctx *ctx)
2545 {
2546         int rc = 0;
2547         size_t cur_len;
2548         unsigned long nr_pages, num_pages, i;
2549         struct cifs_writedata *wdata;
2550         struct iov_iter saved_from = *from;
2551         loff_t saved_offset = offset;
2552         pid_t pid;
2553         struct TCP_Server_Info *server;
2554 
2555         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2556                 pid = open_file->pid;
2557         else
2558                 pid = current->tgid;
2559 
2560         server = tlink_tcon(open_file->tlink)->ses->server;
2561 
2562         do {
2563                 unsigned int wsize, credits;
2564 
2565                 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2566                                                    &wsize, &credits);
2567                 if (rc)
2568                         break;
2569 
2570                 nr_pages = get_numpages(wsize, len, &cur_len);
2571                 wdata = cifs_writedata_alloc(nr_pages,
2572                                              cifs_uncached_writev_complete);
2573                 if (!wdata) {
2574                         rc = -ENOMEM;
2575                         add_credits_and_wake_if(server, credits, 0);
2576                         break;
2577                 }
2578 
2579                 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2580                 if (rc) {
2581                         kfree(wdata);
2582                         add_credits_and_wake_if(server, credits, 0);
2583                         break;
2584                 }
2585 
2586                 num_pages = nr_pages;
2587                 rc = wdata_fill_from_iovec(wdata, from, &cur_len, &num_pages);
2588                 if (rc) {
2589                         for (i = 0; i < nr_pages; i++)
2590                                 put_page(wdata->pages[i]);
2591                         kfree(wdata);
2592                         add_credits_and_wake_if(server, credits, 0);
2593                         break;
2594                 }
2595 
2596                 /*
2597                  * Bring nr_pages down to the number of pages we actually used,
2598                  * and free any pages that we didn't use.
2599                  */
2600                 for ( ; nr_pages > num_pages; nr_pages--)
2601                         put_page(wdata->pages[nr_pages - 1]);
2602 
2603                 wdata->sync_mode = WB_SYNC_ALL;
2604                 wdata->nr_pages = nr_pages;
2605                 wdata->offset = (__u64)offset;
2606                 wdata->cfile = cifsFileInfo_get(open_file);
2607                 wdata->pid = pid;
2608                 wdata->bytes = cur_len;
2609                 wdata->pagesz = PAGE_SIZE;
2610                 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2611                 wdata->credits = credits;
2612                 wdata->ctx = ctx;
2613                 kref_get(&ctx->refcount);
2614 
2615                 if (!wdata->cfile->invalidHandle ||
2616                     !(rc = cifs_reopen_file(wdata->cfile, false)))
2617                         rc = server->ops->async_writev(wdata,
2618                                         cifs_uncached_writedata_release);
2619                 if (rc) {
2620                         add_credits_and_wake_if(server, wdata->credits, 0);
2621                         kref_put(&wdata->refcount,
2622                                  cifs_uncached_writedata_release);
2623                         if (rc == -EAGAIN) {
2624                                 *from = saved_from;
2625                                 iov_iter_advance(from, offset - saved_offset);
2626                                 continue;
2627                         }
2628                         break;
2629                 }
2630 
2631                 list_add_tail(&wdata->list, wdata_list);
2632                 offset += cur_len;
2633                 len -= cur_len;
2634         } while (len > 0);
2635 
2636         return rc;
2637 }
2638 
2639 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
2640 {
2641         struct cifs_writedata *wdata, *tmp;
2642         struct cifs_tcon *tcon;
2643         struct cifs_sb_info *cifs_sb;
2644         struct dentry *dentry = ctx->cfile->dentry;
2645         unsigned int i;
2646         int rc;
2647 
2648         tcon = tlink_tcon(ctx->cfile->tlink);
2649         cifs_sb = CIFS_SB(dentry->d_sb);
2650 
2651         mutex_lock(&ctx->aio_mutex);
2652 
2653         if (list_empty(&ctx->list)) {
2654                 mutex_unlock(&ctx->aio_mutex);
2655                 return;
2656         }
2657 
2658         rc = ctx->rc;
2659         /*
2660          * Wait for and collect replies for any successful sends in order of
2661          * increasing offset. Once an error is hit, then return without waiting
2662          * for any more replies.
2663          */
2664 restart_loop:
2665         list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
2666                 if (!rc) {
2667                         if (!try_wait_for_completion(&wdata->done)) {
2668                                 mutex_unlock(&ctx->aio_mutex);
2669                                 return;
2670                         }
2671 
2672                         if (wdata->result)
2673                                 rc = wdata->result;
2674                         else
2675                                 ctx->total_len += wdata->bytes;
2676 
2677                         /* resend call if it's a retryable error */
2678                         if (rc == -EAGAIN) {
2679                                 struct list_head tmp_list;
2680                                 struct iov_iter tmp_from = ctx->iter;
2681 
2682                                 INIT_LIST_HEAD(&tmp_list);
2683                                 list_del_init(&wdata->list);
2684 
2685                                 iov_iter_advance(&tmp_from,
2686                                                  wdata->offset - ctx->pos);
2687 
2688                                 rc = cifs_write_from_iter(wdata->offset,
2689                                                 wdata->bytes, &tmp_from,
2690                                                 ctx->cfile, cifs_sb, &tmp_list,
2691                                                 ctx);
2692 
2693                                 list_splice(&tmp_list, &ctx->list);
2694 
2695                                 kref_put(&wdata->refcount,
2696                                          cifs_uncached_writedata_release);
2697                                 goto restart_loop;
2698                         }
2699                 }
2700                 list_del_init(&wdata->list);
2701                 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2702         }
2703 
2704         for (i = 0; i < ctx->npages; i++)
2705                 put_page(ctx->bv[i].bv_page);
2706 
2707         cifs_stats_bytes_written(tcon, ctx->total_len);
2708         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
2709 
2710         ctx->rc = (rc == 0) ? ctx->total_len : rc;
2711 
2712         mutex_unlock(&ctx->aio_mutex);
2713 
2714         if (ctx->iocb && ctx->iocb->ki_complete)
2715                 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
2716         else
2717                 complete(&ctx->done);
2718 }
2719 
2720 ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
2721 {
2722         struct file *file = iocb->ki_filp;
2723         ssize_t total_written = 0;
2724         struct cifsFileInfo *cfile;
2725         struct cifs_tcon *tcon;
2726         struct cifs_sb_info *cifs_sb;
2727         struct cifs_aio_ctx *ctx;
2728         struct iov_iter saved_from = *from;
2729         int rc;
2730 
2731         /*
2732          * BB - optimize the way when signing is disabled. We can drop this
2733          * extra memory-to-memory copying and use iovec buffers for constructing
2734          * write request.
2735          */
2736 
2737         rc = generic_write_checks(iocb, from);
2738         if (rc <= 0)
2739                 return rc;
2740 
2741         cifs_sb = CIFS_FILE_SB(file);
2742         cfile = file->private_data;
2743         tcon = tlink_tcon(cfile->tlink);
2744 
2745         if (!tcon->ses->server->ops->async_writev)
2746                 return -ENOSYS;
2747 
2748         ctx = cifs_aio_ctx_alloc();
2749         if (!ctx)
2750                 return -ENOMEM;
2751 
2752         ctx->cfile = cifsFileInfo_get(cfile);
2753 
2754         if (!is_sync_kiocb(iocb))
2755                 ctx->iocb = iocb;
2756 
2757         ctx->pos = iocb->ki_pos;
2758 
2759         rc = setup_aio_ctx_iter(ctx, from, WRITE);
2760         if (rc) {
2761                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
2762                 return rc;
2763         }
2764 
2765         /* grab a lock here due to read response handlers can access ctx */
2766         mutex_lock(&ctx->aio_mutex);
2767 
2768         rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
2769                                   cfile, cifs_sb, &ctx->list, ctx);
2770 
2771         /*
2772          * If at least one write was successfully sent, then discard any rc
2773          * value from the later writes. If the other write succeeds, then
2774          * we'll end up returning whatever was written. If it fails, then
2775          * we'll get a new rc value from that.
2776          */
2777         if (!list_empty(&ctx->list))
2778                 rc = 0;
2779 
2780         mutex_unlock(&ctx->aio_mutex);
2781 
2782         if (rc) {
2783                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
2784                 return rc;
2785         }
2786 
2787         if (!is_sync_kiocb(iocb)) {
2788                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
2789                 return -EIOCBQUEUED;
2790         }
2791 
2792         rc = wait_for_completion_killable(&ctx->done);
2793         if (rc) {
2794                 mutex_lock(&ctx->aio_mutex);
2795                 ctx->rc = rc = -EINTR;
2796                 total_written = ctx->total_len;
2797                 mutex_unlock(&ctx->aio_mutex);
2798         } else {
2799                 rc = ctx->rc;
2800                 total_written = ctx->total_len;
2801         }
2802 
2803         kref_put(&ctx->refcount, cifs_aio_ctx_release);
2804 
2805         if (unlikely(!total_written))
2806                 return rc;
2807 
2808         iocb->ki_pos += total_written;
2809         return total_written;
2810 }
2811 
2812 static ssize_t
2813 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
2814 {
2815         struct file *file = iocb->ki_filp;
2816         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2817         struct inode *inode = file->f_mapping->host;
2818         struct cifsInodeInfo *cinode = CIFS_I(inode);
2819         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2820         ssize_t rc;
2821 
2822         inode_lock(inode);
2823         /*
2824          * We need to hold the sem to be sure nobody modifies lock list
2825          * with a brlock that prevents writing.
2826          */
2827         down_read(&cinode->lock_sem);
2828 
2829         rc = generic_write_checks(iocb, from);
2830         if (rc <= 0)
2831                 goto out;
2832 
2833         if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
2834                                      server->vals->exclusive_lock_type, NULL,
2835                                      CIFS_WRITE_OP))
2836                 rc = __generic_file_write_iter(iocb, from);
2837         else
2838                 rc = -EACCES;
2839 out:
2840         up_read(&cinode->lock_sem);
2841         inode_unlock(inode);
2842 
2843         if (rc > 0)
2844                 rc = generic_write_sync(iocb, rc);
2845         return rc;
2846 }
2847 
2848 ssize_t
2849 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
2850 {
2851         struct inode *inode = file_inode(iocb->ki_filp);
2852         struct cifsInodeInfo *cinode = CIFS_I(inode);
2853         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2854         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2855                                                 iocb->ki_filp->private_data;
2856         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2857         ssize_t written;
2858 
2859         written = cifs_get_writer(cinode);
2860         if (written)
2861                 return written;
2862 
2863         if (CIFS_CACHE_WRITE(cinode)) {
2864                 if (cap_unix(tcon->ses) &&
2865                 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2866                   && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
2867                         written = generic_file_write_iter(iocb, from);
2868                         goto out;
2869                 }
2870                 written = cifs_writev(iocb, from);
2871                 goto out;
2872         }
2873         /*
2874          * For non-oplocked files in strict cache mode we need to write the data
2875          * to the server exactly from the pos to pos+len-1 rather than flush all
2876          * affected pages because it may cause a error with mandatory locks on
2877          * these pages but not on the region from pos to ppos+len-1.
2878          */
2879         written = cifs_user_writev(iocb, from);
2880         if (written > 0 && CIFS_CACHE_READ(cinode)) {
2881                 /*
2882                  * Windows 7 server can delay breaking level2 oplock if a write
2883                  * request comes - break it on the client to prevent reading
2884                  * an old data.
2885                  */
2886                 cifs_zap_mapping(inode);
2887                 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2888                          inode);
2889                 cinode->oplock = 0;
2890         }
2891 out:
2892         cifs_put_writer(cinode);
2893         return written;
2894 }
2895 
2896 static struct cifs_readdata *
2897 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2898 {
2899         struct cifs_readdata *rdata;
2900 
2901         rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2902                         GFP_KERNEL);
2903         if (rdata != NULL) {
2904                 kref_init(&rdata->refcount);
2905                 INIT_LIST_HEAD(&rdata->list);
2906                 init_completion(&rdata->done);
2907                 INIT_WORK(&rdata->work, complete);
2908         }
2909 
2910         return rdata;
2911 }
2912 
2913 void
2914 cifs_readdata_release(struct kref *refcount)
2915 {
2916         struct cifs_readdata *rdata = container_of(refcount,
2917                                         struct cifs_readdata, refcount);
2918 
2919         if (rdata->cfile)
2920                 cifsFileInfo_put(rdata->cfile);
2921 
2922         kfree(rdata);
2923 }
2924 
2925 static int
2926 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2927 {
2928         int rc = 0;
2929         struct page *page;
2930         unsigned int i;
2931 
2932         for (i = 0; i < nr_pages; i++) {
2933                 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2934                 if (!page) {
2935                         rc = -ENOMEM;
2936                         break;
2937                 }
2938                 rdata->pages[i] = page;
2939         }
2940 
2941         if (rc) {
2942                 for (i = 0; i < nr_pages; i++) {
2943                         put_page(rdata->pages[i]);
2944                         rdata->pages[i] = NULL;
2945                 }
2946         }
2947         return rc;
2948 }
2949 
2950 static void
2951 cifs_uncached_readdata_release(struct kref *refcount)
2952 {
2953         struct cifs_readdata *rdata = container_of(refcount,
2954                                         struct cifs_readdata, refcount);
2955         unsigned int i;
2956 
2957         kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
2958         for (i = 0; i < rdata->nr_pages; i++) {
2959                 put_page(rdata->pages[i]);
2960                 rdata->pages[i] = NULL;
2961         }
2962         cifs_readdata_release(refcount);
2963 }
2964 
2965 /**
2966  * cifs_readdata_to_iov - copy data from pages in response to an iovec
2967  * @rdata:      the readdata response with list of pages holding data
2968  * @iter:       destination for our data
2969  *
2970  * This function copies data from a list of pages in a readdata response into
2971  * an array of iovecs. It will first calculate where the data should go
2972  * based on the info in the readdata and then copy the data into that spot.
2973  */
2974 static int
2975 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
2976 {
2977         size_t remaining = rdata->got_bytes;
2978         unsigned int i;
2979 
2980         for (i = 0; i < rdata->nr_pages; i++) {
2981                 struct page *page = rdata->pages[i];
2982                 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
2983                 size_t written;
2984 
2985                 if (unlikely(iter->type & ITER_PIPE)) {
2986                         void *addr = kmap_atomic(page);
2987 
2988                         written = copy_to_iter(addr, copy, iter);
2989                         kunmap_atomic(addr);
2990                 } else
2991                         written = copy_page_to_iter(page, 0, copy, iter);
2992                 remaining -= written;
2993                 if (written < copy && iov_iter_count(iter) > 0)
2994                         break;
2995         }
2996         return remaining ? -EFAULT : 0;
2997 }
2998 
2999 static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);
3000 
3001 static void
3002 cifs_uncached_readv_complete(struct work_struct *work)
3003 {
3004         struct cifs_readdata *rdata = container_of(work,
3005                                                 struct cifs_readdata, work);
3006 
3007         complete(&rdata->done);
3008         collect_uncached_read_data(rdata->ctx);
3009         /* the below call can possibly free the last ref to aio ctx */
3010         kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3011 }
3012 
3013 static int
3014 uncached_fill_pages(struct TCP_Server_Info *server,
3015                     struct cifs_readdata *rdata, struct iov_iter *iter,
3016                     unsigned int len)
3017 {
3018         int result = 0;
3019         unsigned int i;
3020         unsigned int nr_pages = rdata->nr_pages;
3021 
3022         rdata->got_bytes = 0;
3023         rdata->tailsz = PAGE_SIZE;
3024         for (i = 0; i < nr_pages; i++) {
3025                 struct page *page = rdata->pages[i];
3026                 size_t n;
3027 
3028                 if (len <= 0) {
3029                         /* no need to hold page hostage */
3030                         rdata->pages[i] = NULL;
3031                         rdata->nr_pages--;
3032                         put_page(page);
3033                         continue;
3034                 }
3035                 n = len;
3036                 if (len >= PAGE_SIZE) {
3037                         /* enough data to fill the page */
3038                         n = PAGE_SIZE;
3039                         len -= n;
3040                 } else {
3041                         zero_user(page, len, PAGE_SIZE - len);
3042                         rdata->tailsz = len;
3043                         len = 0;
3044                 }
3045                 if (iter)
3046                         result = copy_page_from_iter(page, 0, n, iter);
3047                 else
3048                         result = cifs_read_page_from_socket(server, page, n);
3049                 if (result < 0)
3050                         break;
3051 
3052                 rdata->got_bytes += result;
3053         }
3054 
3055         return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3056                                                 rdata->got_bytes : result;
3057 }
3058 
3059 static int
3060 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
3061                               struct cifs_readdata *rdata, unsigned int len)
3062 {
3063         return uncached_fill_pages(server, rdata, NULL, len);
3064 }
3065 
3066 static int
3067 cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
3068                               struct cifs_readdata *rdata,
3069                               struct iov_iter *iter)
3070 {
3071         return uncached_fill_pages(server, rdata, iter, iter->count);
3072 }
3073 
3074 static int
3075 cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3076                      struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
3077                      struct cifs_aio_ctx *ctx)
3078 {
3079         struct cifs_readdata *rdata;
3080         unsigned int npages, rsize, credits;
3081         size_t cur_len;
3082         int rc;
3083         pid_t pid;
3084         struct TCP_Server_Info *server;
3085 
3086         server = tlink_tcon(open_file->tlink)->ses->server;
3087 
3088         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3089                 pid = open_file->pid;
3090         else
3091                 pid = current->tgid;
3092 
3093         do {
3094                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3095                                                    &rsize, &credits);
3096                 if (rc)
3097                         break;
3098 
3099                 cur_len = min_t(const size_t, len, rsize);
3100                 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3101 
3102                 /* allocate a readdata struct */
3103                 rdata = cifs_readdata_alloc(npages,
3104                                             cifs_uncached_readv_complete);
3105                 if (!rdata) {
3106                         add_credits_and_wake_if(server, credits, 0);
3107                         rc = -ENOMEM;
3108                         break;
3109                 }
3110 
3111                 rc = cifs_read_allocate_pages(rdata, npages);
3112                 if (rc)
3113                         goto error;
3114 
3115                 rdata->cfile = cifsFileInfo_get(open_file);
3116                 rdata->nr_pages = npages;
3117                 rdata->offset = offset;
3118                 rdata->bytes = cur_len;
3119                 rdata->pid = pid;
3120                 rdata->pagesz = PAGE_SIZE;
3121                 rdata->read_into_pages = cifs_uncached_read_into_pages;
3122                 rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3123                 rdata->credits = credits;
3124                 rdata->ctx = ctx;
3125                 kref_get(&ctx->refcount);
3126 
3127                 if (!rdata->cfile->invalidHandle ||
3128                     !(rc = cifs_reopen_file(rdata->cfile, true)))
3129                         rc = server->ops->async_readv(rdata);
3130 error:
3131                 if (rc) {
3132                         add_credits_and_wake_if(server, rdata->credits, 0);
3133                         kref_put(&rdata->refcount,
3134                                  cifs_uncached_readdata_release);
3135                         if (rc == -EAGAIN)
3136                                 continue;
3137                         break;
3138                 }
3139 
3140                 list_add_tail(&rdata->list, rdata_list);
3141                 offset += cur_len;
3142                 len -= cur_len;
3143         } while (len > 0);
3144 
3145         return rc;
3146 }
3147 
3148 static void
3149 collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3150 {
3151         struct cifs_readdata *rdata, *tmp;
3152         struct iov_iter *to = &ctx->iter;
3153         struct cifs_sb_info *cifs_sb;
3154         struct cifs_tcon *tcon;
3155         unsigned int i;
3156         int rc;
3157 
3158         tcon = tlink_tcon(ctx->cfile->tlink);
3159         cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3160 
3161         mutex_lock(&ctx->aio_mutex);
3162 
3163         if (list_empty(&ctx->list)) {
3164                 mutex_unlock(&ctx->aio_mutex);
3165                 return;
3166         }
3167 
3168         rc = ctx->rc;
3169         /* the loop below should proceed in the order of increasing offsets */
3170 again:
3171         list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3172                 if (!rc) {
3173                         if (!try_wait_for_completion(&rdata->done)) {
3174                                 mutex_unlock(&ctx->aio_mutex);
3175                                 return;
3176                         }
3177 
3178                         if (rdata->result == -EAGAIN) {
3179                                 /* resend call if it's a retryable error */
3180                                 struct list_head tmp_list;
3181                                 unsigned int got_bytes = rdata->got_bytes;
3182 
3183                                 list_del_init(&rdata->list);
3184                                 INIT_LIST_HEAD(&tmp_list);
3185 
3186                                 /*
3187                                  * Got a part of data and then reconnect has
3188                                  * happened -- fill the buffer and continue
3189                                  * reading.
3190                                  */
3191                                 if (got_bytes && got_bytes < rdata->bytes) {
3192                                         rc = cifs_readdata_to_iov(rdata, to);
3193                                         if (rc) {
3194                                                 kref_put(&rdata->refcount,
3195                                                 cifs_uncached_readdata_release);
3196                                                 continue;
3197                                         }
3198                                 }
3199 
3200                                 rc = cifs_send_async_read(
3201                                                 rdata->offset + got_bytes,
3202                                                 rdata->bytes - got_bytes,
3203                                                 rdata->cfile, cifs_sb,
3204                                                 &tmp_list, ctx);
3205 
3206                                 list_splice(&tmp_list, &ctx->list);
3207 
3208                                 kref_put(&rdata->refcount,
3209                                          cifs_uncached_readdata_release);
3210                                 goto again;
3211                         } else if (rdata->result)
3212                                 rc = rdata->result;
3213                         else
3214                                 rc = cifs_readdata_to_iov(rdata, to);
3215 
3216                         /* if there was a short read -- discard anything left */
3217                         if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3218                                 rc = -ENODATA;
3219                 }
3220                 list_del_init(&rdata->list);
3221                 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3222         }
3223 
3224         for (i = 0; i < ctx->npages; i++) {
3225                 if (ctx->should_dirty)
3226                         set_page_dirty(ctx->bv[i].bv_page);
3227                 put_page(ctx->bv[i].bv_page);
3228         }
3229 
3230         ctx->total_len = ctx->len - iov_iter_count(to);
3231 
3232         cifs_stats_bytes_read(tcon, ctx->total_len);
3233 
3234         /* mask nodata case */
3235         if (rc == -ENODATA)
3236                 rc = 0;
3237 
3238         ctx->rc = (rc == 0) ? ctx->total_len : rc;
3239 
3240         mutex_unlock(&ctx->aio_mutex);
3241 
3242         if (ctx->iocb && ctx->iocb->ki_complete)
3243                 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3244         else
3245                 complete(&ctx->done);
3246 }
3247 
3248 ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
3249 {
3250         struct file *file = iocb->ki_filp;
3251         ssize_t rc;
3252         size_t len;
3253         ssize_t total_read = 0;
3254         loff_t offset = iocb->ki_pos;
3255         struct cifs_sb_info *cifs_sb;
3256         struct cifs_tcon *tcon;
3257         struct cifsFileInfo *cfile;
3258         struct cifs_aio_ctx *ctx;
3259 
3260         len = iov_iter_count(to);
3261         if (!len)
3262                 return 0;
3263 
3264         cifs_sb = CIFS_FILE_SB(file);
3265         cfile = file->private_data;
3266         tcon = tlink_tcon(cfile->tlink);
3267 
3268         if (!tcon->ses->server->ops->async_readv)
3269                 return -ENOSYS;
3270 
3271         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3272                 cifs_dbg(FYI, "attempting read on write only file instance\n");
3273 
3274         ctx = cifs_aio_ctx_alloc();
3275         if (!ctx)
3276                 return -ENOMEM;
3277 
3278         ctx->cfile = cifsFileInfo_get(cfile);
3279 
3280         if (!is_sync_kiocb(iocb))
3281                 ctx->iocb = iocb;
3282 
3283         if (to->type == ITER_IOVEC)
3284                 ctx->should_dirty = true;
3285 
3286         rc = setup_aio_ctx_iter(ctx, to, READ);
3287         if (rc) {
3288                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3289                 return rc;
3290         }
3291 
3292         len = ctx->len;
3293 
3294         /* grab a lock here due to read response handlers can access ctx */
3295         mutex_lock(&ctx->aio_mutex);
3296 
3297         rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);
3298 
3299         /* if at least one read request send succeeded, then reset rc */
3300         if (!list_empty(&ctx->list))
3301                 rc = 0;
3302 
3303         mutex_unlock(&ctx->aio_mutex);
3304 
3305         if (rc) {
3306                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3307                 return rc;
3308         }
3309 
3310         if (!is_sync_kiocb(iocb)) {
3311                 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3312                 return -EIOCBQUEUED;
3313         }
3314 
3315         rc = wait_for_completion_killable(&ctx->done);
3316         if (rc) {
3317                 mutex_lock(&ctx->aio_mutex);
3318                 ctx->rc = rc = -EINTR;
3319                 total_read = ctx->total_len;
3320                 mutex_unlock(&ctx->aio_mutex);
3321         } else {
3322                 rc = ctx->rc;
3323                 total_read = ctx->total_len;
3324         }
3325 
3326         kref_put(&ctx->refcount, cifs_aio_ctx_release);
3327 
3328         if (total_read) {
3329                 iocb->ki_pos += total_read;
3330                 return total_read;
3331         }
3332         return rc;
3333 }
3334 
3335 ssize_t
3336 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3337 {
3338         struct inode *inode = file_inode(iocb->ki_filp);
3339         struct cifsInodeInfo *cinode = CIFS_I(inode);
3340         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3341         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3342                                                 iocb->ki_filp->private_data;
3343         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3344         int rc = -EACCES;
3345 
3346         /*
3347          * In strict cache mode we need to read from the server all the time
3348          * if we don't have level II oplock because the server can delay mtime
3349          * change - so we can't make a decision about inode invalidating.
3350          * And we can also fail with pagereading if there are mandatory locks
3351          * on pages affected by this read but not on the region from pos to
3352          * pos+len-1.
3353          */
3354         if (!CIFS_CACHE_READ(cinode))
3355                 return cifs_user_readv(iocb, to);
3356 
3357         if (cap_unix(tcon->ses) &&
3358             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3359             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3360                 return generic_file_read_iter(iocb, to);
3361 
3362         /*
3363          * We need to hold the sem to be sure nobody modifies lock list
3364          * with a brlock that prevents reading.
3365          */
3366         down_read(&cinode->lock_sem);
3367         if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3368                                      tcon->ses->server->vals->shared_lock_type,
3369                                      NULL, CIFS_READ_OP))
3370                 rc = generic_file_read_iter(iocb, to);
3371         up_read(&cinode->lock_sem);
3372         return rc;
3373 }
3374 
3375 static ssize_t
3376 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
3377 {
3378         int rc = -EACCES;
3379         unsigned int bytes_read = 0;
3380         unsigned int total_read;
3381         unsigned int current_read_size;
3382         unsigned int rsize;
3383         struct cifs_sb_info *cifs_sb;
3384         struct cifs_tcon *tcon;
3385         struct TCP_Server_Info *server;
3386         unsigned int xid;
3387         char *cur_offset;
3388         struct cifsFileInfo *open_file;
3389         struct cifs_io_parms io_parms;
3390         int buf_type = CIFS_NO_BUFFER;
3391         __u32 pid;
3392 
3393         xid = get_xid();
3394         cifs_sb = CIFS_FILE_SB(file);
3395 
3396         /* FIXME: set up handlers for larger reads and/or convert to async */
3397         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3398 
3399         if (file->private_data == NULL) {
3400                 rc = -EBADF;
3401                 free_xid(xid);
3402                 return rc;
3403         }
3404         open_file = file->private_data;
3405         tcon = tlink_tcon(open_file->tlink);
3406         server = tcon->ses->server;
3407 
3408         if (!server->ops->sync_read) {
3409                 free_xid(xid);
3410                 return -ENOSYS;
3411         }
3412 
3413         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3414                 pid = open_file->pid;
3415         else
3416                 pid = current->tgid;
3417 
3418         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3419                 cifs_dbg(FYI, "attempting read on write only file instance\n");
3420 
3421         for (total_read = 0, cur_offset = read_data; read_size > total_read;
3422              total_read += bytes_read, cur_offset += bytes_read) {
3423                 do {
3424                         current_read_size = min_t(uint, read_size - total_read,
3425                                                   rsize);
3426                         /*
3427                          * For windows me and 9x we do not want to request more
3428                          * than it negotiated since it will refuse the read
3429                          * then.
3430                          */
3431                         if ((tcon->ses) && !(tcon->ses->capabilities &
3432                                 tcon->ses->server->vals->cap_large_files)) {
3433                                 current_read_size = min_t(uint,
3434                                         current_read_size, CIFSMaxBufSize);
3435                         }
3436                         if (open_file->invalidHandle) {
3437                                 rc = cifs_reopen_file(open_file, true);
3438                                 if (rc != 0)
3439                                         break;
3440                         }
3441                         io_parms.pid = pid;
3442                         io_parms.tcon = tcon;
3443                         io_parms.offset = *offset;
3444                         io_parms.length = current_read_size;
3445                         rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3446                                                     &bytes_read, &cur_offset,
3447                                                     &buf_type);
3448                 } while (rc == -EAGAIN);
3449 
3450                 if (rc || (bytes_read == 0)) {
3451                         if (total_read) {
3452                                 break;
3453                         } else {
3454                                 free_xid(xid);
3455                                 return rc;
3456                         }
3457                 } else {
3458                         cifs_stats_bytes_read(tcon, total_read);
3459                         *offset += bytes_read;
3460                 }
3461         }
3462         free_xid(xid);
3463         return total_read;
3464 }
3465 
3466 /*
3467  * If the page is mmap'ed into a process' page tables, then we need to make
3468  * sure that it doesn't change while being written back.
3469  */
3470 static int
3471 cifs_page_mkwrite(struct vm_fault *vmf)
3472 {
3473         struct page *page = vmf->page;
3474 
3475         lock_page(page);
3476         return VM_FAULT_LOCKED;
3477 }
3478 
3479 static const struct vm_operations_struct cifs_file_vm_ops = {
3480         .fault = filemap_fault,
3481         .map_pages = filemap_map_pages,
3482         .page_mkwrite = cifs_page_mkwrite,
3483 };
3484 
3485 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3486 {
3487         int rc, xid;
3488         struct inode *inode = file_inode(file);
3489 
3490         xid = get_xid();
3491 
3492         if (!CIFS_CACHE_READ(CIFS_I(inode))) {
3493                 rc = cifs_zap_mapping(inode);
3494                 if (rc)
3495                         return rc;
3496         }
3497 
3498         rc = generic_file_mmap(file, vma);
3499         if (rc == 0)
3500                 vma->vm_ops = &cifs_file_vm_ops;
3501         free_xid(xid);
3502         return rc;
3503 }
3504 
3505 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3506 {
3507         int rc, xid;
3508 
3509         xid = get_xid();
3510         rc = cifs_revalidate_file(file);
3511         if (rc) {
3512                 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3513                          rc);
3514                 free_xid(xid);
3515                 return rc;
3516         }
3517         rc = generic_file_mmap(file, vma);
3518         if (rc == 0)
3519                 vma->vm_ops = &cifs_file_vm_ops;
3520         free_xid(xid);
3521         return rc;
3522 }
3523 
3524 static void
3525 cifs_readv_complete(struct work_struct *work)
3526 {
3527         unsigned int i, got_bytes;
3528         struct cifs_readdata *rdata = container_of(work,
3529                                                 struct cifs_readdata, work);
3530 
3531         got_bytes = rdata->got_bytes;
3532         for (i = 0; i < rdata->nr_pages; i++) {
3533                 struct page *page = rdata->pages[i];
3534 
3535                 lru_cache_add_file(page);
3536 
3537                 if (rdata->result == 0 ||
3538                     (rdata->result == -EAGAIN && got_bytes)) {
3539                         flush_dcache_page(page);
3540                         SetPageUptodate(page);
3541                 }
3542 
3543                 unlock_page(page);
3544 
3545                 if (rdata->result == 0 ||
3546                     (rdata->result == -EAGAIN && got_bytes))
3547                         cifs_readpage_to_fscache(rdata->mapping->host, page);
3548 
3549                 got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
3550 
3551                 put_page(page);
3552                 rdata->pages[i] = NULL;
3553         }
3554         kref_put(&rdata->refcount, cifs_readdata_release);
3555 }
3556 
3557 static int
3558 readpages_fill_pages(struct TCP_Server_Info *server,
3559                      struct cifs_readdata *rdata, struct iov_iter *iter,
3560                      unsigned int len)
3561 {
3562         int result = 0;
3563         unsigned int i;
3564         u64 eof;
3565         pgoff_t eof_index;
3566         unsigned int nr_pages = rdata->nr_pages;
3567 
3568         /* determine the eof that the server (probably) has */
3569         eof = CIFS_I(rdata->mapping->host)->server_eof;
3570         eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
3571         cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
3572 
3573         rdata->got_bytes = 0;
3574         rdata->tailsz = PAGE_SIZE;
3575         for (i = 0; i < nr_pages; i++) {
3576                 struct page *page = rdata->pages[i];
3577                 size_t n = PAGE_SIZE;
3578 
3579                 if (len >= PAGE_SIZE) {
3580                         len -= PAGE_SIZE;
3581                 } else if (len > 0) {
3582                         /* enough for partial page, fill and zero the rest */
3583                         zero_user(page, len, PAGE_SIZE - len);
3584                         n = rdata->tailsz = len;
3585                         len = 0;
3586                 } else if (page->index > eof_index) {
3587                         /*
3588                          * The VFS will not try to do readahead past the
3589                          * i_size, but it's possible that we have outstanding
3590                          * writes with gaps in the middle and the i_size hasn't
3591                          * caught up yet. Populate those with zeroed out pages
3592                          * to prevent the VFS from repeatedly attempting to
3593                          * fill them until the writes are flushed.
3594                          */
3595                         zero_user(page, 0, PAGE_SIZE);
3596                         lru_cache_add_file(page);
3597                         flush_dcache_page(page);
3598                         SetPageUptodate(page);
3599                         unlock_page(page);
3600                         put_page(page);
3601                         rdata->pages[i] = NULL;
3602                         rdata->nr_pages--;
3603                         continue;
3604                 } else {
3605                         /* no need to hold page hostage */
3606                         lru_cache_add_file(page);
3607                         unlock_page(page);
3608                         put_page(page);
3609                         rdata->pages[i] = NULL;
3610                         rdata->nr_pages--;
3611                         continue;
3612                 }
3613 
3614                 if (iter)
3615                         result = copy_page_from_iter(page, 0, n, iter);
3616                 else
3617                         result = cifs_read_page_from_socket(server, page, n);
3618                 if (result < 0)
3619                         break;
3620 
3621                 rdata->got_bytes += result;
3622         }
3623 
3624         return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3625                                                 rdata->got_bytes : result;
3626 }
3627 
3628 static int
3629 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3630                                struct cifs_readdata *rdata, unsigned int len)
3631 {
3632         return readpages_fill_pages(server, rdata, NULL, len);
3633 }
3634 
3635 static int
3636 cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
3637                                struct cifs_readdata *rdata,
3638                                struct iov_iter *iter)
3639 {
3640         return readpages_fill_pages(server, rdata, iter, iter->count);
3641 }
3642 
3643 static int
3644 readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
3645                     unsigned int rsize, struct list_head *tmplist,
3646                     unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
3647 {
3648         struct page *page, *tpage;
3649         unsigned int expected_index;
3650         int rc;
3651         gfp_t gfp = readahead_gfp_mask(mapping);
3652 
3653         INIT_LIST_HEAD(tmplist);
3654 
3655         page = list_entry(page_list->prev, struct page, lru);
3656 
3657         /*
3658          * Lock the page and put it in the cache. Since no one else
3659          * should have access to this page, we're safe to simply set
3660          * PG_locked without checking it first.
3661          */
3662         __SetPageLocked(page);
3663         rc = add_to_page_cache_locked(page, mapping,
3664                                       page->index, gfp);
3665 
3666         /* give up if we can't stick it in the cache */
3667         if (rc) {
3668                 __ClearPageLocked(page);
3669                 return rc;
3670         }
3671 
3672         /* move first page to the tmplist */
3673         *offset = (loff_t)page->index << PAGE_SHIFT;
3674         *bytes = PAGE_SIZE;
3675         *nr_pages = 1;
3676         list_move_tail(&page->lru, tmplist);
3677 
3678         /* now try and add more pages onto the request */
3679         expected_index = page->index + 1;
3680         list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3681                 /* discontinuity ? */
3682                 if (page->index != expected_index)
3683                         break;
3684 
3685                 /* would this page push the read over the rsize? */
3686                 if (*bytes + PAGE_SIZE > rsize)
3687                         break;
3688 
3689                 __SetPageLocked(page);
3690                 if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
3691                         __ClearPageLocked(page);
3692                         break;
3693                 }
3694                 list_move_tail(&page->lru, tmplist);
3695                 (*bytes) += PAGE_SIZE;
3696                 expected_index++;
3697                 (*nr_pages)++;
3698         }
3699         return rc;
3700 }
3701 
3702 static int cifs_readpages(struct file *file, struct address_space *mapping,
3703         struct list_head *page_list, unsigned num_pages)
3704 {
3705         int rc;
3706         struct list_head tmplist;
3707         struct cifsFileInfo *open_file = file->private_data;
3708         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
3709         struct TCP_Server_Info *server;
3710         pid_t pid;
3711 
3712         /*
3713          * Reads as many pages as possible from fscache. Returns -ENOBUFS
3714          * immediately if the cookie is negative
3715          *
3716          * After this point, every page in the list might have PG_fscache set,
3717          * so we will need to clean that up off of every page we don't use.
3718          */
3719         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3720                                          &num_pages);
3721         if (rc == 0)
3722                 return rc;
3723 
3724         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3725                 pid = open_file->pid;
3726         else
3727                 pid = current->tgid;
3728 
3729         rc = 0;
3730         server = tlink_tcon(open_file->tlink)->ses->server;
3731 
3732         cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3733                  __func__, file, mapping, num_pages);
3734 
3735         /*
3736          * Start with the page at end of list and move it to private
3737          * list. Do the same with any following pages until we hit
3738          * the rsize limit, hit an index discontinuity, or run out of
3739          * pages. Issue the async read and then start the loop again
3740          * until the list is empty.
3741          *
3742          * Note that list order is important. The page_list is in
3743          * the order of declining indexes. When we put the pages in
3744          * the rdata->pages, then we want them in increasing order.
3745          */
3746         while (!list_empty(page_list)) {
3747                 unsigned int i, nr_pages, bytes, rsize;
3748                 loff_t offset;
3749                 struct page *page, *tpage;
3750                 struct cifs_readdata *rdata;
3751                 unsigned credits;
3752 
3753                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3754                                                    &rsize, &credits);
3755                 if (rc)
3756                         break;
3757 
3758                 /*
3759                  * Give up immediately if rsize is too small to read an entire
3760                  * page. The VFS will fall back to readpage. We should never
3761                  * reach this point however since we set ra_pages to 0 when the
3762                  * rsize is smaller than a cache page.
3763                  */
3764                 if (unlikely(rsize < PAGE_SIZE)) {
3765                         add_credits_and_wake_if(server, credits, 0);
3766                         return 0;
3767                 }
3768 
3769                 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
3770                                          &nr_pages, &offset, &bytes);
3771                 if (rc) {
3772                         add_credits_and_wake_if(server, credits, 0);
3773                         break;
3774                 }
3775 
3776                 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3777                 if (!rdata) {
3778                         /* best to give up if we're out of mem */
3779                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3780                                 list_del(&page->lru);
3781                                 lru_cache_add_file(page);
3782                                 unlock_page(page);
3783                                 put_page(page);
3784                         }
3785                         rc = -ENOMEM;
3786                         add_credits_and_wake_if(server, credits, 0);
3787                         break;
3788                 }
3789 
3790                 rdata->cfile = cifsFileInfo_get(open_file);
3791                 rdata->mapping = mapping;
3792                 rdata->offset = offset;
3793                 rdata->bytes = bytes;
3794                 rdata->pid = pid;
3795                 rdata->pagesz = PAGE_SIZE;
3796                 rdata->read_into_pages = cifs_readpages_read_into_pages;
3797                 rdata->copy_into_pages = cifs_readpages_copy_into_pages;
3798                 rdata->credits = credits;
3799 
3800                 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3801                         list_del(&page->lru);
3802                         rdata->pages[rdata->nr_pages++] = page;
3803                 }
3804 
3805                 if (!rdata->cfile->invalidHandle ||
3806                     !(rc = cifs_reopen_file(rdata->cfile, true)))
3807                         rc = server->ops->async_readv(rdata);
3808                 if (rc) {
3809                         add_credits_and_wake_if(server, rdata->credits, 0);
3810                         for (i = 0; i < rdata->nr_pages; i++) {
3811                                 page = rdata->pages[i];
3812                                 lru_cache_add_file(page);
3813                                 unlock_page(page);
3814                                 put_page(page);
3815                         }
3816                         /* Fallback to the readpage in error/reconnect cases */
3817                         kref_put(&rdata->refcount, cifs_readdata_release);
3818                         break;
3819                 }
3820 
3821                 kref_put(&rdata->refcount, cifs_readdata_release);
3822         }
3823 
3824         /* Any pages that have been shown to fscache but didn't get added to
3825          * the pagecache must be uncached before they get returned to the
3826          * allocator.
3827          */
3828         cifs_fscache_readpages_cancel(mapping->host, page_list);
3829         return rc;
3830 }
3831 
3832 /*
3833  * cifs_readpage_worker must be called with the page pinned
3834  */
3835 static int cifs_readpage_worker(struct file *file, struct page *page,
3836         loff_t *poffset)
3837 {
3838         char *read_data;
3839         int rc;
3840 
3841         /* Is the page cached? */
3842         rc = cifs_readpage_from_fscache(file_inode(file), page);
3843         if (rc == 0)
3844                 goto read_complete;
3845 
3846         read_data = kmap(page);
3847         /* for reads over a certain size could initiate async read ahead */
3848 
3849         rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
3850 
3851         if (rc < 0)
3852                 goto io_error;
3853         else
3854                 cifs_dbg(FYI, "Bytes read %d\n", rc);
3855 
3856         file_inode(file)->i_atime =
3857                 current_time(file_inode(file));
3858 
3859         if (PAGE_SIZE > rc)
3860                 memset(read_data + rc, 0, PAGE_SIZE - rc);
3861 
3862         flush_dcache_page(page);
3863         SetPageUptodate(page);
3864 
3865         /* send this page to the cache */
3866         cifs_readpage_to_fscache(file_inode(file), page);
3867 
3868         rc = 0;
3869 
3870 io_error:
3871         kunmap(page);
3872         unlock_page(page);
3873 
3874 read_complete:
3875         return rc;
3876 }
3877 
3878 static int cifs_readpage(struct file *file, struct page *page)
3879 {
3880         loff_t offset = (loff_t)page->index << PAGE_SHIFT;
3881         int rc = -EACCES;
3882         unsigned int xid;
3883 
3884         xid = get_xid();
3885 
3886         if (file->private_data == NULL) {
3887                 rc = -EBADF;
3888                 free_xid(xid);
3889                 return rc;
3890         }
3891 
3892         cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
3893                  page, (int)offset, (int)offset);
3894 
3895         rc = cifs_readpage_worker(file, page, &offset);
3896 
3897         free_xid(xid);
3898         return rc;
3899 }
3900 
3901 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3902 {
3903         struct cifsFileInfo *open_file;
3904         struct cifs_tcon *tcon =
3905                 cifs_sb_master_tcon(CIFS_SB(cifs_inode->vfs_inode.i_sb));
3906 
3907         spin_lock(&tcon->open_file_lock);
3908         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3909                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3910                         spin_unlock(&tcon->open_file_lock);
3911                         return 1;
3912                 }
3913         }
3914         spin_unlock(&tcon->open_file_lock);
3915         return 0;
3916 }
3917 
3918 /* We do not want to update the file size from server for inodes
3919    open for write - to avoid races with writepage extending
3920    the file - in the future we could consider allowing
3921    refreshing the inode only on increases in the file size
3922    but this is tricky to do without racing with writebehind
3923    page caching in the current Linux kernel design */
3924 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3925 {
3926         if (!cifsInode)
3927                 return true;
3928 
3929         if (is_inode_writable(cifsInode)) {
3930                 /* This inode is open for write at least once */
3931                 struct cifs_sb_info *cifs_sb;
3932 
3933                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3934                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3935                         /* since no page cache to corrupt on directio
3936                         we can change size safely */
3937                         return true;
3938                 }
3939 
3940                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3941                         return true;
3942 
3943                 return false;
3944         } else
3945                 return true;
3946 }
3947 
3948 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3949                         loff_t pos, unsigned len, unsigned flags,
3950                         struct page **pagep, void **fsdata)
3951 {
3952         int oncethru = 0;
3953         pgoff_t index = pos >> PAGE_SHIFT;
3954         loff_t offset = pos & (PAGE_SIZE - 1);
3955         loff_t page_start = pos & PAGE_MASK;
3956         loff_t i_size;
3957         struct page *page;
3958         int rc = 0;
3959 
3960         cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
3961 
3962 start:
3963         page = grab_cache_page_write_begin(mapping, index, flags);
3964         if (!page) {
3965                 rc = -ENOMEM;
3966                 goto out;
3967         }
3968 
3969         if (PageUptodate(page))
3970                 goto out;
3971 
3972         /*
3973          * If we write a full page it will be up to date, no need to read from
3974          * the server. If the write is short, we'll end up doing a sync write
3975          * instead.
3976          */
3977         if (len == PAGE_SIZE)
3978                 goto out;
3979 
3980         /*
3981          * optimize away the read when we have an oplock, and we're not
3982          * expecting to use any of the data we'd be reading in. That
3983          * is, when the page lies beyond the EOF, or straddles the EOF
3984          * and the write will cover all of the existing data.
3985          */
3986         if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
3987                 i_size = i_size_read(mapping->host);
3988                 if (page_start >= i_size ||
3989                     (offset == 0 && (pos + len) >= i_size)) {
3990                         zero_user_segments(page, 0, offset,
3991                                            offset + len,
3992                                            PAGE_SIZE);
3993                         /*
3994                          * PageChecked means that the parts of the page
3995                          * to which we're not writing are considered up
3996                          * to date. Once the data is copied to the
3997                          * page, it can be set uptodate.
3998                          */
3999                         SetPageChecked(page);
4000                         goto out;
4001                 }
4002         }
4003 
4004         if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4005                 /*
4006                  * might as well read a page, it is fast enough. If we get
4007                  * an error, we don't need to return it. cifs_write_end will
4008                  * do a sync write instead since PG_uptodate isn't set.
4009                  */
4010                 cifs_readpage_worker(file, page, &page_start);
4011                 put_page(page);
4012                 oncethru = 1;
4013                 goto start;
4014         } else {
4015                 /* we could try using another file handle if there is one -
4016                    but how would we lock it to prevent close of that handle
4017                    racing with this read? In any case
4018                    this will be written out by write_end so is fine */
4019         }
4020 out:
4021         *pagep = page;
4022         return rc;
4023 }
4024 
4025 static int cifs_release_page(struct page *page, gfp_t gfp)
4026 {
4027         if (PagePrivate(page))
4028                 return 0;
4029 
4030         return cifs_fscache_release_page(page, gfp);
4031 }
4032 
4033 static void cifs_invalidate_page(struct page *page, unsigned int offset,
4034                                  unsigned int length)
4035 {
4036         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
4037 
4038         if (offset == 0 && length == PAGE_SIZE)
4039                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
4040 }
4041 
4042 static int cifs_launder_page(struct page *page)
4043 {
4044         int rc = 0;
4045         loff_t range_start = page_offset(page);
4046         loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4047         struct writeback_control wbc = {
4048                 .sync_mode = WB_SYNC_ALL,
4049                 .nr_to_write = 0,
4050                 .range_start = range_start,
4051                 .range_end = range_end,
4052         };
4053 
4054         cifs_dbg(FYI, "Launder page: %p\n", page);
4055 
4056         if (clear_page_dirty_for_io(page))
4057                 rc = cifs_writepage_locked(page, &wbc);
4058 
4059         cifs_fscache_invalidate_page(page, page->mapping->host);
4060         return rc;
4061 }
4062 
4063 void cifs_oplock_break(struct work_struct *work)
4064 {
4065         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
4066                                                   oplock_break);
4067         struct inode *inode = d_inode(cfile->dentry);
4068         struct cifsInodeInfo *cinode = CIFS_I(inode);
4069         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4070         struct TCP_Server_Info *server = tcon->ses->server;
4071         int rc = 0;
4072 
4073         wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4074                         TASK_UNINTERRUPTIBLE);
4075 
4076         server->ops->downgrade_oplock(server, cinode,
4077                 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
4078 
4079         if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4080                                                 cifs_has_mand_locks(cinode)) {
4081                 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
4082                          inode);
4083                 cinode->oplock = 0;
4084         }
4085 
4086         if (inode && S_ISREG(inode->i_mode)) {
4087                 if (CIFS_CACHE_READ(cinode))
4088                         break_lease(inode, O_RDONLY);
4089                 else
4090                         break_lease(inode, O_WRONLY);
4091                 rc = filemap_fdatawrite(inode->i_mapping);
4092                 if (!CIFS_CACHE_READ(cinode)) {
4093                         rc = filemap_fdatawait(inode->i_mapping);
4094                         mapping_set_error(inode->i_mapping, rc);
4095                         cifs_zap_mapping(inode);
4096                 }
4097                 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4098         }
4099 
4100         rc = cifs_push_locks(cfile);
4101         if (rc)
4102                 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4103 
4104         /*
4105          * releasing stale oplock after recent reconnect of smb session using
4106          * a now incorrect file handle is not a data integrity issue but do
4107          * not bother sending an oplock release if session to server still is
4108          * disconnected since oplock already released by the server
4109          */
4110         if (!cfile->oplock_break_cancelled) {
4111                 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
4112                                                              cinode);
4113                 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4114         }
4115         cifs_done_oplock_break(cinode);
4116 }
4117 
4118 /*
4119  * The presence of cifs_direct_io() in the address space ops vector
4120  * allowes open() O_DIRECT flags which would have failed otherwise.
4121  *
4122  * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
4123  * so this method should never be called.
4124  *
4125  * Direct IO is not yet supported in the cached mode. 
4126  */
4127 static ssize_t
4128 cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4129 {
4130         /*
4131          * FIXME
4132          * Eventually need to support direct IO for non forcedirectio mounts
4133          */
4134         return -EINVAL;
4135 }
4136 
4137 
4138 const struct address_space_operations cifs_addr_ops = {
4139         .readpage = cifs_readpage,
4140         .readpages = cifs_readpages,
4141         .writepage = cifs_writepage,
4142         .writepages = cifs_writepages,
4143         .write_begin = cifs_write_begin,
4144         .write_end = cifs_write_end,
4145         .set_page_dirty = __set_page_dirty_nobuffers,
4146         .releasepage = cifs_release_page,
4147         .direct_IO = cifs_direct_io,
4148         .invalidatepage = cifs_invalidate_page,
4149         .launder_page = cifs_launder_page,
4150 };
4151 
4152 /*
4153  * cifs_readpages requires the server to support a buffer large enough to
4154  * contain the header plus one complete page of data.  Otherwise, we need
4155  * to leave cifs_readpages out of the address space operations.
4156  */
4157 const struct address_space_operations cifs_addr_ops_smallbuf = {
4158         .readpage = cifs_readpage,
4159         .writepage = cifs_writepage,
4160         .writepages = cifs_writepages,
4161         .write_begin = cifs_write_begin,
4162         .write_end = cifs_write_end,
4163         .set_page_dirty = __set_page_dirty_nobuffers,
4164         .releasepage = cifs_release_page,
4165         .invalidatepage = cifs_invalidate_page,
4166         .launder_page = cifs_launder_page,
4167 };
4168 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp