1*38c8a9a5SSteve French // SPDX-License-Identifier: LGPL-2.1 2*38c8a9a5SSteve French /* 3*38c8a9a5SSteve French * 4*38c8a9a5SSteve French * vfs operations that deal with files 5*38c8a9a5SSteve French * 6*38c8a9a5SSteve French * Copyright (C) International Business Machines Corp., 2002,2010 7*38c8a9a5SSteve French * Author(s): Steve French (sfrench@us.ibm.com) 8*38c8a9a5SSteve French * Jeremy Allison (jra@samba.org) 9*38c8a9a5SSteve French * 10*38c8a9a5SSteve French */ 11*38c8a9a5SSteve French #include <linux/fs.h> 12*38c8a9a5SSteve French #include <linux/filelock.h> 13*38c8a9a5SSteve French #include <linux/backing-dev.h> 14*38c8a9a5SSteve French #include <linux/stat.h> 15*38c8a9a5SSteve French #include <linux/fcntl.h> 16*38c8a9a5SSteve French #include <linux/pagemap.h> 17*38c8a9a5SSteve French #include <linux/pagevec.h> 18*38c8a9a5SSteve French #include <linux/writeback.h> 19*38c8a9a5SSteve French #include <linux/task_io_accounting_ops.h> 20*38c8a9a5SSteve French #include <linux/delay.h> 21*38c8a9a5SSteve French #include <linux/mount.h> 22*38c8a9a5SSteve French #include <linux/slab.h> 23*38c8a9a5SSteve French #include <linux/swap.h> 24*38c8a9a5SSteve French #include <linux/mm.h> 25*38c8a9a5SSteve French #include <asm/div64.h> 26*38c8a9a5SSteve French #include "cifsfs.h" 27*38c8a9a5SSteve French #include "cifspdu.h" 28*38c8a9a5SSteve French #include "cifsglob.h" 29*38c8a9a5SSteve French #include "cifsproto.h" 30*38c8a9a5SSteve French #include "smb2proto.h" 31*38c8a9a5SSteve French #include "cifs_unicode.h" 32*38c8a9a5SSteve French #include "cifs_debug.h" 33*38c8a9a5SSteve French #include "cifs_fs_sb.h" 34*38c8a9a5SSteve French #include "fscache.h" 35*38c8a9a5SSteve French #include "smbdirect.h" 36*38c8a9a5SSteve French #include "fs_context.h" 37*38c8a9a5SSteve French #include "cifs_ioctl.h" 38*38c8a9a5SSteve French #include "cached_dir.h" 39*38c8a9a5SSteve French 40*38c8a9a5SSteve French /* 41*38c8a9a5SSteve French * Remove the dirty flags from a span of pages. 42*38c8a9a5SSteve French */ 43*38c8a9a5SSteve French static void cifs_undirty_folios(struct inode *inode, loff_t start, unsigned int len) 44*38c8a9a5SSteve French { 45*38c8a9a5SSteve French struct address_space *mapping = inode->i_mapping; 46*38c8a9a5SSteve French struct folio *folio; 47*38c8a9a5SSteve French pgoff_t end; 48*38c8a9a5SSteve French 49*38c8a9a5SSteve French XA_STATE(xas, &mapping->i_pages, start / PAGE_SIZE); 50*38c8a9a5SSteve French 51*38c8a9a5SSteve French rcu_read_lock(); 52*38c8a9a5SSteve French 53*38c8a9a5SSteve French end = (start + len - 1) / PAGE_SIZE; 54*38c8a9a5SSteve French xas_for_each_marked(&xas, folio, end, PAGECACHE_TAG_DIRTY) { 55*38c8a9a5SSteve French if (xas_retry(&xas, folio)) 56*38c8a9a5SSteve French continue; 57*38c8a9a5SSteve French xas_pause(&xas); 58*38c8a9a5SSteve French rcu_read_unlock(); 59*38c8a9a5SSteve French folio_lock(folio); 60*38c8a9a5SSteve French folio_clear_dirty_for_io(folio); 61*38c8a9a5SSteve French folio_unlock(folio); 62*38c8a9a5SSteve French rcu_read_lock(); 63*38c8a9a5SSteve French } 64*38c8a9a5SSteve French 65*38c8a9a5SSteve French rcu_read_unlock(); 66*38c8a9a5SSteve French } 67*38c8a9a5SSteve French 68*38c8a9a5SSteve French /* 69*38c8a9a5SSteve French * Completion of write to server. 70*38c8a9a5SSteve French */ 71*38c8a9a5SSteve French void cifs_pages_written_back(struct inode *inode, loff_t start, unsigned int len) 72*38c8a9a5SSteve French { 73*38c8a9a5SSteve French struct address_space *mapping = inode->i_mapping; 74*38c8a9a5SSteve French struct folio *folio; 75*38c8a9a5SSteve French pgoff_t end; 76*38c8a9a5SSteve French 77*38c8a9a5SSteve French XA_STATE(xas, &mapping->i_pages, start / PAGE_SIZE); 78*38c8a9a5SSteve French 79*38c8a9a5SSteve French if (!len) 80*38c8a9a5SSteve French return; 81*38c8a9a5SSteve French 82*38c8a9a5SSteve French rcu_read_lock(); 83*38c8a9a5SSteve French 84*38c8a9a5SSteve French end = (start + len - 1) / PAGE_SIZE; 85*38c8a9a5SSteve French xas_for_each(&xas, folio, end) { 86*38c8a9a5SSteve French if (xas_retry(&xas, folio)) 87*38c8a9a5SSteve French continue; 88*38c8a9a5SSteve French if (!folio_test_writeback(folio)) { 89*38c8a9a5SSteve French WARN_ONCE(1, "bad %x @%llx page %lx %lx\n", 90*38c8a9a5SSteve French len, start, folio_index(folio), end); 91*38c8a9a5SSteve French continue; 92*38c8a9a5SSteve French } 93*38c8a9a5SSteve French 94*38c8a9a5SSteve French folio_detach_private(folio); 95*38c8a9a5SSteve French folio_end_writeback(folio); 96*38c8a9a5SSteve French } 97*38c8a9a5SSteve French 98*38c8a9a5SSteve French rcu_read_unlock(); 99*38c8a9a5SSteve French } 100*38c8a9a5SSteve French 101*38c8a9a5SSteve French /* 102*38c8a9a5SSteve French * Failure of write to server. 103*38c8a9a5SSteve French */ 104*38c8a9a5SSteve French void cifs_pages_write_failed(struct inode *inode, loff_t start, unsigned int len) 105*38c8a9a5SSteve French { 106*38c8a9a5SSteve French struct address_space *mapping = inode->i_mapping; 107*38c8a9a5SSteve French struct folio *folio; 108*38c8a9a5SSteve French pgoff_t end; 109*38c8a9a5SSteve French 110*38c8a9a5SSteve French XA_STATE(xas, &mapping->i_pages, start / PAGE_SIZE); 111*38c8a9a5SSteve French 112*38c8a9a5SSteve French if (!len) 113*38c8a9a5SSteve French return; 114*38c8a9a5SSteve French 115*38c8a9a5SSteve French rcu_read_lock(); 116*38c8a9a5SSteve French 117*38c8a9a5SSteve French end = (start + len - 1) / PAGE_SIZE; 118*38c8a9a5SSteve French xas_for_each(&xas, folio, end) { 119*38c8a9a5SSteve French if (xas_retry(&xas, folio)) 120*38c8a9a5SSteve French continue; 121*38c8a9a5SSteve French if (!folio_test_writeback(folio)) { 122*38c8a9a5SSteve French WARN_ONCE(1, "bad %x @%llx page %lx %lx\n", 123*38c8a9a5SSteve French len, start, folio_index(folio), end); 124*38c8a9a5SSteve French continue; 125*38c8a9a5SSteve French } 126*38c8a9a5SSteve French 127*38c8a9a5SSteve French folio_set_error(folio); 128*38c8a9a5SSteve French folio_end_writeback(folio); 129*38c8a9a5SSteve French } 130*38c8a9a5SSteve French 131*38c8a9a5SSteve French rcu_read_unlock(); 132*38c8a9a5SSteve French } 133*38c8a9a5SSteve French 134*38c8a9a5SSteve French /* 135*38c8a9a5SSteve French * Redirty pages after a temporary failure. 136*38c8a9a5SSteve French */ 137*38c8a9a5SSteve French void cifs_pages_write_redirty(struct inode *inode, loff_t start, unsigned int len) 138*38c8a9a5SSteve French { 139*38c8a9a5SSteve French struct address_space *mapping = inode->i_mapping; 140*38c8a9a5SSteve French struct folio *folio; 141*38c8a9a5SSteve French pgoff_t end; 142*38c8a9a5SSteve French 143*38c8a9a5SSteve French XA_STATE(xas, &mapping->i_pages, start / PAGE_SIZE); 144*38c8a9a5SSteve French 145*38c8a9a5SSteve French if (!len) 146*38c8a9a5SSteve French return; 147*38c8a9a5SSteve French 148*38c8a9a5SSteve French rcu_read_lock(); 149*38c8a9a5SSteve French 150*38c8a9a5SSteve French end = (start + len - 1) / PAGE_SIZE; 151*38c8a9a5SSteve French xas_for_each(&xas, folio, end) { 152*38c8a9a5SSteve French if (!folio_test_writeback(folio)) { 153*38c8a9a5SSteve French WARN_ONCE(1, "bad %x @%llx page %lx %lx\n", 154*38c8a9a5SSteve French len, start, folio_index(folio), end); 155*38c8a9a5SSteve French continue; 156*38c8a9a5SSteve French } 157*38c8a9a5SSteve French 158*38c8a9a5SSteve French filemap_dirty_folio(folio->mapping, folio); 159*38c8a9a5SSteve French folio_end_writeback(folio); 160*38c8a9a5SSteve French } 161*38c8a9a5SSteve French 162*38c8a9a5SSteve French rcu_read_unlock(); 163*38c8a9a5SSteve French } 164*38c8a9a5SSteve French 165*38c8a9a5SSteve French /* 166*38c8a9a5SSteve French * Mark as invalid, all open files on tree connections since they 167*38c8a9a5SSteve French * were closed when session to server was lost. 168*38c8a9a5SSteve French */ 169*38c8a9a5SSteve French void 170*38c8a9a5SSteve French cifs_mark_open_files_invalid(struct cifs_tcon *tcon) 171*38c8a9a5SSteve French { 172*38c8a9a5SSteve French struct cifsFileInfo *open_file = NULL; 173*38c8a9a5SSteve French struct list_head *tmp; 174*38c8a9a5SSteve French struct list_head *tmp1; 175*38c8a9a5SSteve French 176*38c8a9a5SSteve French /* only send once per connect */ 177*38c8a9a5SSteve French spin_lock(&tcon->tc_lock); 178*38c8a9a5SSteve French if (tcon->status != TID_NEED_RECON) { 179*38c8a9a5SSteve French spin_unlock(&tcon->tc_lock); 180*38c8a9a5SSteve French return; 181*38c8a9a5SSteve French } 182*38c8a9a5SSteve French tcon->status = TID_IN_FILES_INVALIDATE; 183*38c8a9a5SSteve French spin_unlock(&tcon->tc_lock); 184*38c8a9a5SSteve French 185*38c8a9a5SSteve French /* list all files open on tree connection and mark them invalid */ 186*38c8a9a5SSteve French spin_lock(&tcon->open_file_lock); 187*38c8a9a5SSteve French list_for_each_safe(tmp, tmp1, &tcon->openFileList) { 188*38c8a9a5SSteve French open_file = list_entry(tmp, struct cifsFileInfo, tlist); 189*38c8a9a5SSteve French open_file->invalidHandle = true; 190*38c8a9a5SSteve French open_file->oplock_break_cancelled = true; 191*38c8a9a5SSteve French } 192*38c8a9a5SSteve French spin_unlock(&tcon->open_file_lock); 193*38c8a9a5SSteve French 194*38c8a9a5SSteve French invalidate_all_cached_dirs(tcon); 195*38c8a9a5SSteve French spin_lock(&tcon->tc_lock); 196*38c8a9a5SSteve French if (tcon->status == TID_IN_FILES_INVALIDATE) 197*38c8a9a5SSteve French tcon->status = TID_NEED_TCON; 198*38c8a9a5SSteve French spin_unlock(&tcon->tc_lock); 199*38c8a9a5SSteve French 200*38c8a9a5SSteve French /* 201*38c8a9a5SSteve French * BB Add call to invalidate_inodes(sb) for all superblocks mounted 202*38c8a9a5SSteve French * to this tcon. 203*38c8a9a5SSteve French */ 204*38c8a9a5SSteve French } 205*38c8a9a5SSteve French 206*38c8a9a5SSteve French static inline int cifs_convert_flags(unsigned int flags) 207*38c8a9a5SSteve French { 208*38c8a9a5SSteve French if ((flags & O_ACCMODE) == O_RDONLY) 209*38c8a9a5SSteve French return GENERIC_READ; 210*38c8a9a5SSteve French else if ((flags & O_ACCMODE) == O_WRONLY) 211*38c8a9a5SSteve French return GENERIC_WRITE; 212*38c8a9a5SSteve French else if ((flags & O_ACCMODE) == O_RDWR) { 213*38c8a9a5SSteve French /* GENERIC_ALL is too much permission to request 214*38c8a9a5SSteve French can cause unnecessary access denied on create */ 215*38c8a9a5SSteve French /* return GENERIC_ALL; */ 216*38c8a9a5SSteve French return (GENERIC_READ | GENERIC_WRITE); 217*38c8a9a5SSteve French } 218*38c8a9a5SSteve French 219*38c8a9a5SSteve French return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES | 220*38c8a9a5SSteve French FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA | 221*38c8a9a5SSteve French FILE_READ_DATA); 222*38c8a9a5SSteve French } 223*38c8a9a5SSteve French 224*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 225*38c8a9a5SSteve French static u32 cifs_posix_convert_flags(unsigned int flags) 226*38c8a9a5SSteve French { 227*38c8a9a5SSteve French u32 posix_flags = 0; 228*38c8a9a5SSteve French 229*38c8a9a5SSteve French if ((flags & O_ACCMODE) == O_RDONLY) 230*38c8a9a5SSteve French posix_flags = SMB_O_RDONLY; 231*38c8a9a5SSteve French else if ((flags & O_ACCMODE) == O_WRONLY) 232*38c8a9a5SSteve French posix_flags = SMB_O_WRONLY; 233*38c8a9a5SSteve French else if ((flags & O_ACCMODE) == O_RDWR) 234*38c8a9a5SSteve French posix_flags = SMB_O_RDWR; 235*38c8a9a5SSteve French 236*38c8a9a5SSteve French if (flags & O_CREAT) { 237*38c8a9a5SSteve French posix_flags |= SMB_O_CREAT; 238*38c8a9a5SSteve French if (flags & O_EXCL) 239*38c8a9a5SSteve French posix_flags |= SMB_O_EXCL; 240*38c8a9a5SSteve French } else if (flags & O_EXCL) 241*38c8a9a5SSteve French cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n", 242*38c8a9a5SSteve French current->comm, current->tgid); 243*38c8a9a5SSteve French 244*38c8a9a5SSteve French if (flags & O_TRUNC) 245*38c8a9a5SSteve French posix_flags |= SMB_O_TRUNC; 246*38c8a9a5SSteve French /* be safe and imply O_SYNC for O_DSYNC */ 247*38c8a9a5SSteve French if (flags & O_DSYNC) 248*38c8a9a5SSteve French posix_flags |= SMB_O_SYNC; 249*38c8a9a5SSteve French if (flags & O_DIRECTORY) 250*38c8a9a5SSteve French posix_flags |= SMB_O_DIRECTORY; 251*38c8a9a5SSteve French if (flags & O_NOFOLLOW) 252*38c8a9a5SSteve French posix_flags |= SMB_O_NOFOLLOW; 253*38c8a9a5SSteve French if (flags & O_DIRECT) 254*38c8a9a5SSteve French posix_flags |= SMB_O_DIRECT; 255*38c8a9a5SSteve French 256*38c8a9a5SSteve French return posix_flags; 257*38c8a9a5SSteve French } 258*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 259*38c8a9a5SSteve French 260*38c8a9a5SSteve French static inline int cifs_get_disposition(unsigned int flags) 261*38c8a9a5SSteve French { 262*38c8a9a5SSteve French if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL)) 263*38c8a9a5SSteve French return FILE_CREATE; 264*38c8a9a5SSteve French else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC)) 265*38c8a9a5SSteve French return FILE_OVERWRITE_IF; 266*38c8a9a5SSteve French else if ((flags & O_CREAT) == O_CREAT) 267*38c8a9a5SSteve French return FILE_OPEN_IF; 268*38c8a9a5SSteve French else if ((flags & O_TRUNC) == O_TRUNC) 269*38c8a9a5SSteve French return FILE_OVERWRITE; 270*38c8a9a5SSteve French else 271*38c8a9a5SSteve French return FILE_OPEN; 272*38c8a9a5SSteve French } 273*38c8a9a5SSteve French 274*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 275*38c8a9a5SSteve French int cifs_posix_open(const char *full_path, struct inode **pinode, 276*38c8a9a5SSteve French struct super_block *sb, int mode, unsigned int f_flags, 277*38c8a9a5SSteve French __u32 *poplock, __u16 *pnetfid, unsigned int xid) 278*38c8a9a5SSteve French { 279*38c8a9a5SSteve French int rc; 280*38c8a9a5SSteve French FILE_UNIX_BASIC_INFO *presp_data; 281*38c8a9a5SSteve French __u32 posix_flags = 0; 282*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 283*38c8a9a5SSteve French struct cifs_fattr fattr; 284*38c8a9a5SSteve French struct tcon_link *tlink; 285*38c8a9a5SSteve French struct cifs_tcon *tcon; 286*38c8a9a5SSteve French 287*38c8a9a5SSteve French cifs_dbg(FYI, "posix open %s\n", full_path); 288*38c8a9a5SSteve French 289*38c8a9a5SSteve French presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL); 290*38c8a9a5SSteve French if (presp_data == NULL) 291*38c8a9a5SSteve French return -ENOMEM; 292*38c8a9a5SSteve French 293*38c8a9a5SSteve French tlink = cifs_sb_tlink(cifs_sb); 294*38c8a9a5SSteve French if (IS_ERR(tlink)) { 295*38c8a9a5SSteve French rc = PTR_ERR(tlink); 296*38c8a9a5SSteve French goto posix_open_ret; 297*38c8a9a5SSteve French } 298*38c8a9a5SSteve French 299*38c8a9a5SSteve French tcon = tlink_tcon(tlink); 300*38c8a9a5SSteve French mode &= ~current_umask(); 301*38c8a9a5SSteve French 302*38c8a9a5SSteve French posix_flags = cifs_posix_convert_flags(f_flags); 303*38c8a9a5SSteve French rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data, 304*38c8a9a5SSteve French poplock, full_path, cifs_sb->local_nls, 305*38c8a9a5SSteve French cifs_remap(cifs_sb)); 306*38c8a9a5SSteve French cifs_put_tlink(tlink); 307*38c8a9a5SSteve French 308*38c8a9a5SSteve French if (rc) 309*38c8a9a5SSteve French goto posix_open_ret; 310*38c8a9a5SSteve French 311*38c8a9a5SSteve French if (presp_data->Type == cpu_to_le32(-1)) 312*38c8a9a5SSteve French goto posix_open_ret; /* open ok, caller does qpathinfo */ 313*38c8a9a5SSteve French 314*38c8a9a5SSteve French if (!pinode) 315*38c8a9a5SSteve French goto posix_open_ret; /* caller does not need info */ 316*38c8a9a5SSteve French 317*38c8a9a5SSteve French cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb); 318*38c8a9a5SSteve French 319*38c8a9a5SSteve French /* get new inode and set it up */ 320*38c8a9a5SSteve French if (*pinode == NULL) { 321*38c8a9a5SSteve French cifs_fill_uniqueid(sb, &fattr); 322*38c8a9a5SSteve French *pinode = cifs_iget(sb, &fattr); 323*38c8a9a5SSteve French if (!*pinode) { 324*38c8a9a5SSteve French rc = -ENOMEM; 325*38c8a9a5SSteve French goto posix_open_ret; 326*38c8a9a5SSteve French } 327*38c8a9a5SSteve French } else { 328*38c8a9a5SSteve French cifs_revalidate_mapping(*pinode); 329*38c8a9a5SSteve French rc = cifs_fattr_to_inode(*pinode, &fattr); 330*38c8a9a5SSteve French } 331*38c8a9a5SSteve French 332*38c8a9a5SSteve French posix_open_ret: 333*38c8a9a5SSteve French kfree(presp_data); 334*38c8a9a5SSteve French return rc; 335*38c8a9a5SSteve French } 336*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 337*38c8a9a5SSteve French 338*38c8a9a5SSteve French static int cifs_nt_open(const char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb, 339*38c8a9a5SSteve French struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock, 340*38c8a9a5SSteve French struct cifs_fid *fid, unsigned int xid, struct cifs_open_info_data *buf) 341*38c8a9a5SSteve French { 342*38c8a9a5SSteve French int rc; 343*38c8a9a5SSteve French int desired_access; 344*38c8a9a5SSteve French int disposition; 345*38c8a9a5SSteve French int create_options = CREATE_NOT_DIR; 346*38c8a9a5SSteve French struct TCP_Server_Info *server = tcon->ses->server; 347*38c8a9a5SSteve French struct cifs_open_parms oparms; 348*38c8a9a5SSteve French 349*38c8a9a5SSteve French if (!server->ops->open) 350*38c8a9a5SSteve French return -ENOSYS; 351*38c8a9a5SSteve French 352*38c8a9a5SSteve French desired_access = cifs_convert_flags(f_flags); 353*38c8a9a5SSteve French 354*38c8a9a5SSteve French /********************************************************************* 355*38c8a9a5SSteve French * open flag mapping table: 356*38c8a9a5SSteve French * 357*38c8a9a5SSteve French * POSIX Flag CIFS Disposition 358*38c8a9a5SSteve French * ---------- ---------------- 359*38c8a9a5SSteve French * O_CREAT FILE_OPEN_IF 360*38c8a9a5SSteve French * O_CREAT | O_EXCL FILE_CREATE 361*38c8a9a5SSteve French * O_CREAT | O_TRUNC FILE_OVERWRITE_IF 362*38c8a9a5SSteve French * O_TRUNC FILE_OVERWRITE 363*38c8a9a5SSteve French * none of the above FILE_OPEN 364*38c8a9a5SSteve French * 365*38c8a9a5SSteve French * Note that there is not a direct match between disposition 366*38c8a9a5SSteve French * FILE_SUPERSEDE (ie create whether or not file exists although 367*38c8a9a5SSteve French * O_CREAT | O_TRUNC is similar but truncates the existing 368*38c8a9a5SSteve French * file rather than creating a new file as FILE_SUPERSEDE does 369*38c8a9a5SSteve French * (which uses the attributes / metadata passed in on open call) 370*38c8a9a5SSteve French *? 371*38c8a9a5SSteve French *? O_SYNC is a reasonable match to CIFS writethrough flag 372*38c8a9a5SSteve French *? and the read write flags match reasonably. O_LARGEFILE 373*38c8a9a5SSteve French *? is irrelevant because largefile support is always used 374*38c8a9a5SSteve French *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY, 375*38c8a9a5SSteve French * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation 376*38c8a9a5SSteve French *********************************************************************/ 377*38c8a9a5SSteve French 378*38c8a9a5SSteve French disposition = cifs_get_disposition(f_flags); 379*38c8a9a5SSteve French 380*38c8a9a5SSteve French /* BB pass O_SYNC flag through on file attributes .. BB */ 381*38c8a9a5SSteve French 382*38c8a9a5SSteve French /* O_SYNC also has bit for O_DSYNC so following check picks up either */ 383*38c8a9a5SSteve French if (f_flags & O_SYNC) 384*38c8a9a5SSteve French create_options |= CREATE_WRITE_THROUGH; 385*38c8a9a5SSteve French 386*38c8a9a5SSteve French if (f_flags & O_DIRECT) 387*38c8a9a5SSteve French create_options |= CREATE_NO_BUFFER; 388*38c8a9a5SSteve French 389*38c8a9a5SSteve French oparms = (struct cifs_open_parms) { 390*38c8a9a5SSteve French .tcon = tcon, 391*38c8a9a5SSteve French .cifs_sb = cifs_sb, 392*38c8a9a5SSteve French .desired_access = desired_access, 393*38c8a9a5SSteve French .create_options = cifs_create_options(cifs_sb, create_options), 394*38c8a9a5SSteve French .disposition = disposition, 395*38c8a9a5SSteve French .path = full_path, 396*38c8a9a5SSteve French .fid = fid, 397*38c8a9a5SSteve French }; 398*38c8a9a5SSteve French 399*38c8a9a5SSteve French rc = server->ops->open(xid, &oparms, oplock, buf); 400*38c8a9a5SSteve French if (rc) 401*38c8a9a5SSteve French return rc; 402*38c8a9a5SSteve French 403*38c8a9a5SSteve French /* TODO: Add support for calling posix query info but with passing in fid */ 404*38c8a9a5SSteve French if (tcon->unix_ext) 405*38c8a9a5SSteve French rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb, 406*38c8a9a5SSteve French xid); 407*38c8a9a5SSteve French else 408*38c8a9a5SSteve French rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb, 409*38c8a9a5SSteve French xid, fid); 410*38c8a9a5SSteve French 411*38c8a9a5SSteve French if (rc) { 412*38c8a9a5SSteve French server->ops->close(xid, tcon, fid); 413*38c8a9a5SSteve French if (rc == -ESTALE) 414*38c8a9a5SSteve French rc = -EOPENSTALE; 415*38c8a9a5SSteve French } 416*38c8a9a5SSteve French 417*38c8a9a5SSteve French return rc; 418*38c8a9a5SSteve French } 419*38c8a9a5SSteve French 420*38c8a9a5SSteve French static bool 421*38c8a9a5SSteve French cifs_has_mand_locks(struct cifsInodeInfo *cinode) 422*38c8a9a5SSteve French { 423*38c8a9a5SSteve French struct cifs_fid_locks *cur; 424*38c8a9a5SSteve French bool has_locks = false; 425*38c8a9a5SSteve French 426*38c8a9a5SSteve French down_read(&cinode->lock_sem); 427*38c8a9a5SSteve French list_for_each_entry(cur, &cinode->llist, llist) { 428*38c8a9a5SSteve French if (!list_empty(&cur->locks)) { 429*38c8a9a5SSteve French has_locks = true; 430*38c8a9a5SSteve French break; 431*38c8a9a5SSteve French } 432*38c8a9a5SSteve French } 433*38c8a9a5SSteve French up_read(&cinode->lock_sem); 434*38c8a9a5SSteve French return has_locks; 435*38c8a9a5SSteve French } 436*38c8a9a5SSteve French 437*38c8a9a5SSteve French void 438*38c8a9a5SSteve French cifs_down_write(struct rw_semaphore *sem) 439*38c8a9a5SSteve French { 440*38c8a9a5SSteve French while (!down_write_trylock(sem)) 441*38c8a9a5SSteve French msleep(10); 442*38c8a9a5SSteve French } 443*38c8a9a5SSteve French 444*38c8a9a5SSteve French static void cifsFileInfo_put_work(struct work_struct *work); 445*38c8a9a5SSteve French 446*38c8a9a5SSteve French struct cifsFileInfo *cifs_new_fileinfo(struct cifs_fid *fid, struct file *file, 447*38c8a9a5SSteve French struct tcon_link *tlink, __u32 oplock, 448*38c8a9a5SSteve French const char *symlink_target) 449*38c8a9a5SSteve French { 450*38c8a9a5SSteve French struct dentry *dentry = file_dentry(file); 451*38c8a9a5SSteve French struct inode *inode = d_inode(dentry); 452*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(inode); 453*38c8a9a5SSteve French struct cifsFileInfo *cfile; 454*38c8a9a5SSteve French struct cifs_fid_locks *fdlocks; 455*38c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(tlink); 456*38c8a9a5SSteve French struct TCP_Server_Info *server = tcon->ses->server; 457*38c8a9a5SSteve French 458*38c8a9a5SSteve French cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL); 459*38c8a9a5SSteve French if (cfile == NULL) 460*38c8a9a5SSteve French return cfile; 461*38c8a9a5SSteve French 462*38c8a9a5SSteve French fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL); 463*38c8a9a5SSteve French if (!fdlocks) { 464*38c8a9a5SSteve French kfree(cfile); 465*38c8a9a5SSteve French return NULL; 466*38c8a9a5SSteve French } 467*38c8a9a5SSteve French 468*38c8a9a5SSteve French if (symlink_target) { 469*38c8a9a5SSteve French cfile->symlink_target = kstrdup(symlink_target, GFP_KERNEL); 470*38c8a9a5SSteve French if (!cfile->symlink_target) { 471*38c8a9a5SSteve French kfree(fdlocks); 472*38c8a9a5SSteve French kfree(cfile); 473*38c8a9a5SSteve French return NULL; 474*38c8a9a5SSteve French } 475*38c8a9a5SSteve French } 476*38c8a9a5SSteve French 477*38c8a9a5SSteve French INIT_LIST_HEAD(&fdlocks->locks); 478*38c8a9a5SSteve French fdlocks->cfile = cfile; 479*38c8a9a5SSteve French cfile->llist = fdlocks; 480*38c8a9a5SSteve French 481*38c8a9a5SSteve French cfile->count = 1; 482*38c8a9a5SSteve French cfile->pid = current->tgid; 483*38c8a9a5SSteve French cfile->uid = current_fsuid(); 484*38c8a9a5SSteve French cfile->dentry = dget(dentry); 485*38c8a9a5SSteve French cfile->f_flags = file->f_flags; 486*38c8a9a5SSteve French cfile->invalidHandle = false; 487*38c8a9a5SSteve French cfile->deferred_close_scheduled = false; 488*38c8a9a5SSteve French cfile->tlink = cifs_get_tlink(tlink); 489*38c8a9a5SSteve French INIT_WORK(&cfile->oplock_break, cifs_oplock_break); 490*38c8a9a5SSteve French INIT_WORK(&cfile->put, cifsFileInfo_put_work); 491*38c8a9a5SSteve French INIT_DELAYED_WORK(&cfile->deferred, smb2_deferred_work_close); 492*38c8a9a5SSteve French mutex_init(&cfile->fh_mutex); 493*38c8a9a5SSteve French spin_lock_init(&cfile->file_info_lock); 494*38c8a9a5SSteve French 495*38c8a9a5SSteve French cifs_sb_active(inode->i_sb); 496*38c8a9a5SSteve French 497*38c8a9a5SSteve French /* 498*38c8a9a5SSteve French * If the server returned a read oplock and we have mandatory brlocks, 499*38c8a9a5SSteve French * set oplock level to None. 500*38c8a9a5SSteve French */ 501*38c8a9a5SSteve French if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) { 502*38c8a9a5SSteve French cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n"); 503*38c8a9a5SSteve French oplock = 0; 504*38c8a9a5SSteve French } 505*38c8a9a5SSteve French 506*38c8a9a5SSteve French cifs_down_write(&cinode->lock_sem); 507*38c8a9a5SSteve French list_add(&fdlocks->llist, &cinode->llist); 508*38c8a9a5SSteve French up_write(&cinode->lock_sem); 509*38c8a9a5SSteve French 510*38c8a9a5SSteve French spin_lock(&tcon->open_file_lock); 511*38c8a9a5SSteve French if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock) 512*38c8a9a5SSteve French oplock = fid->pending_open->oplock; 513*38c8a9a5SSteve French list_del(&fid->pending_open->olist); 514*38c8a9a5SSteve French 515*38c8a9a5SSteve French fid->purge_cache = false; 516*38c8a9a5SSteve French server->ops->set_fid(cfile, fid, oplock); 517*38c8a9a5SSteve French 518*38c8a9a5SSteve French list_add(&cfile->tlist, &tcon->openFileList); 519*38c8a9a5SSteve French atomic_inc(&tcon->num_local_opens); 520*38c8a9a5SSteve French 521*38c8a9a5SSteve French /* if readable file instance put first in list*/ 522*38c8a9a5SSteve French spin_lock(&cinode->open_file_lock); 523*38c8a9a5SSteve French if (file->f_mode & FMODE_READ) 524*38c8a9a5SSteve French list_add(&cfile->flist, &cinode->openFileList); 525*38c8a9a5SSteve French else 526*38c8a9a5SSteve French list_add_tail(&cfile->flist, &cinode->openFileList); 527*38c8a9a5SSteve French spin_unlock(&cinode->open_file_lock); 528*38c8a9a5SSteve French spin_unlock(&tcon->open_file_lock); 529*38c8a9a5SSteve French 530*38c8a9a5SSteve French if (fid->purge_cache) 531*38c8a9a5SSteve French cifs_zap_mapping(inode); 532*38c8a9a5SSteve French 533*38c8a9a5SSteve French file->private_data = cfile; 534*38c8a9a5SSteve French return cfile; 535*38c8a9a5SSteve French } 536*38c8a9a5SSteve French 537*38c8a9a5SSteve French struct cifsFileInfo * 538*38c8a9a5SSteve French cifsFileInfo_get(struct cifsFileInfo *cifs_file) 539*38c8a9a5SSteve French { 540*38c8a9a5SSteve French spin_lock(&cifs_file->file_info_lock); 541*38c8a9a5SSteve French cifsFileInfo_get_locked(cifs_file); 542*38c8a9a5SSteve French spin_unlock(&cifs_file->file_info_lock); 543*38c8a9a5SSteve French return cifs_file; 544*38c8a9a5SSteve French } 545*38c8a9a5SSteve French 546*38c8a9a5SSteve French static void cifsFileInfo_put_final(struct cifsFileInfo *cifs_file) 547*38c8a9a5SSteve French { 548*38c8a9a5SSteve French struct inode *inode = d_inode(cifs_file->dentry); 549*38c8a9a5SSteve French struct cifsInodeInfo *cifsi = CIFS_I(inode); 550*38c8a9a5SSteve French struct cifsLockInfo *li, *tmp; 551*38c8a9a5SSteve French struct super_block *sb = inode->i_sb; 552*38c8a9a5SSteve French 553*38c8a9a5SSteve French /* 554*38c8a9a5SSteve French * Delete any outstanding lock records. We'll lose them when the file 555*38c8a9a5SSteve French * is closed anyway. 556*38c8a9a5SSteve French */ 557*38c8a9a5SSteve French cifs_down_write(&cifsi->lock_sem); 558*38c8a9a5SSteve French list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) { 559*38c8a9a5SSteve French list_del(&li->llist); 560*38c8a9a5SSteve French cifs_del_lock_waiters(li); 561*38c8a9a5SSteve French kfree(li); 562*38c8a9a5SSteve French } 563*38c8a9a5SSteve French list_del(&cifs_file->llist->llist); 564*38c8a9a5SSteve French kfree(cifs_file->llist); 565*38c8a9a5SSteve French up_write(&cifsi->lock_sem); 566*38c8a9a5SSteve French 567*38c8a9a5SSteve French cifs_put_tlink(cifs_file->tlink); 568*38c8a9a5SSteve French dput(cifs_file->dentry); 569*38c8a9a5SSteve French cifs_sb_deactive(sb); 570*38c8a9a5SSteve French kfree(cifs_file->symlink_target); 571*38c8a9a5SSteve French kfree(cifs_file); 572*38c8a9a5SSteve French } 573*38c8a9a5SSteve French 574*38c8a9a5SSteve French static void cifsFileInfo_put_work(struct work_struct *work) 575*38c8a9a5SSteve French { 576*38c8a9a5SSteve French struct cifsFileInfo *cifs_file = container_of(work, 577*38c8a9a5SSteve French struct cifsFileInfo, put); 578*38c8a9a5SSteve French 579*38c8a9a5SSteve French cifsFileInfo_put_final(cifs_file); 580*38c8a9a5SSteve French } 581*38c8a9a5SSteve French 582*38c8a9a5SSteve French /** 583*38c8a9a5SSteve French * cifsFileInfo_put - release a reference of file priv data 584*38c8a9a5SSteve French * 585*38c8a9a5SSteve French * Always potentially wait for oplock handler. See _cifsFileInfo_put(). 586*38c8a9a5SSteve French * 587*38c8a9a5SSteve French * @cifs_file: cifs/smb3 specific info (eg refcounts) for an open file 588*38c8a9a5SSteve French */ 589*38c8a9a5SSteve French void cifsFileInfo_put(struct cifsFileInfo *cifs_file) 590*38c8a9a5SSteve French { 591*38c8a9a5SSteve French _cifsFileInfo_put(cifs_file, true, true); 592*38c8a9a5SSteve French } 593*38c8a9a5SSteve French 594*38c8a9a5SSteve French /** 595*38c8a9a5SSteve French * _cifsFileInfo_put - release a reference of file priv data 596*38c8a9a5SSteve French * 597*38c8a9a5SSteve French * This may involve closing the filehandle @cifs_file out on the 598*38c8a9a5SSteve French * server. Must be called without holding tcon->open_file_lock, 599*38c8a9a5SSteve French * cinode->open_file_lock and cifs_file->file_info_lock. 600*38c8a9a5SSteve French * 601*38c8a9a5SSteve French * If @wait_for_oplock_handler is true and we are releasing the last 602*38c8a9a5SSteve French * reference, wait for any running oplock break handler of the file 603*38c8a9a5SSteve French * and cancel any pending one. 604*38c8a9a5SSteve French * 605*38c8a9a5SSteve French * @cifs_file: cifs/smb3 specific info (eg refcounts) for an open file 606*38c8a9a5SSteve French * @wait_oplock_handler: must be false if called from oplock_break_handler 607*38c8a9a5SSteve French * @offload: not offloaded on close and oplock breaks 608*38c8a9a5SSteve French * 609*38c8a9a5SSteve French */ 610*38c8a9a5SSteve French void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, 611*38c8a9a5SSteve French bool wait_oplock_handler, bool offload) 612*38c8a9a5SSteve French { 613*38c8a9a5SSteve French struct inode *inode = d_inode(cifs_file->dentry); 614*38c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink); 615*38c8a9a5SSteve French struct TCP_Server_Info *server = tcon->ses->server; 616*38c8a9a5SSteve French struct cifsInodeInfo *cifsi = CIFS_I(inode); 617*38c8a9a5SSteve French struct super_block *sb = inode->i_sb; 618*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 619*38c8a9a5SSteve French struct cifs_fid fid = {}; 620*38c8a9a5SSteve French struct cifs_pending_open open; 621*38c8a9a5SSteve French bool oplock_break_cancelled; 622*38c8a9a5SSteve French 623*38c8a9a5SSteve French spin_lock(&tcon->open_file_lock); 624*38c8a9a5SSteve French spin_lock(&cifsi->open_file_lock); 625*38c8a9a5SSteve French spin_lock(&cifs_file->file_info_lock); 626*38c8a9a5SSteve French if (--cifs_file->count > 0) { 627*38c8a9a5SSteve French spin_unlock(&cifs_file->file_info_lock); 628*38c8a9a5SSteve French spin_unlock(&cifsi->open_file_lock); 629*38c8a9a5SSteve French spin_unlock(&tcon->open_file_lock); 630*38c8a9a5SSteve French return; 631*38c8a9a5SSteve French } 632*38c8a9a5SSteve French spin_unlock(&cifs_file->file_info_lock); 633*38c8a9a5SSteve French 634*38c8a9a5SSteve French if (server->ops->get_lease_key) 635*38c8a9a5SSteve French server->ops->get_lease_key(inode, &fid); 636*38c8a9a5SSteve French 637*38c8a9a5SSteve French /* store open in pending opens to make sure we don't miss lease break */ 638*38c8a9a5SSteve French cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open); 639*38c8a9a5SSteve French 640*38c8a9a5SSteve French /* remove it from the lists */ 641*38c8a9a5SSteve French list_del(&cifs_file->flist); 642*38c8a9a5SSteve French list_del(&cifs_file->tlist); 643*38c8a9a5SSteve French atomic_dec(&tcon->num_local_opens); 644*38c8a9a5SSteve French 645*38c8a9a5SSteve French if (list_empty(&cifsi->openFileList)) { 646*38c8a9a5SSteve French cifs_dbg(FYI, "closing last open instance for inode %p\n", 647*38c8a9a5SSteve French d_inode(cifs_file->dentry)); 648*38c8a9a5SSteve French /* 649*38c8a9a5SSteve French * In strict cache mode we need invalidate mapping on the last 650*38c8a9a5SSteve French * close because it may cause a error when we open this file 651*38c8a9a5SSteve French * again and get at least level II oplock. 652*38c8a9a5SSteve French */ 653*38c8a9a5SSteve French if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) 654*38c8a9a5SSteve French set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags); 655*38c8a9a5SSteve French cifs_set_oplock_level(cifsi, 0); 656*38c8a9a5SSteve French } 657*38c8a9a5SSteve French 658*38c8a9a5SSteve French spin_unlock(&cifsi->open_file_lock); 659*38c8a9a5SSteve French spin_unlock(&tcon->open_file_lock); 660*38c8a9a5SSteve French 661*38c8a9a5SSteve French oplock_break_cancelled = wait_oplock_handler ? 662*38c8a9a5SSteve French cancel_work_sync(&cifs_file->oplock_break) : false; 663*38c8a9a5SSteve French 664*38c8a9a5SSteve French if (!tcon->need_reconnect && !cifs_file->invalidHandle) { 665*38c8a9a5SSteve French struct TCP_Server_Info *server = tcon->ses->server; 666*38c8a9a5SSteve French unsigned int xid; 667*38c8a9a5SSteve French 668*38c8a9a5SSteve French xid = get_xid(); 669*38c8a9a5SSteve French if (server->ops->close_getattr) 670*38c8a9a5SSteve French server->ops->close_getattr(xid, tcon, cifs_file); 671*38c8a9a5SSteve French else if (server->ops->close) 672*38c8a9a5SSteve French server->ops->close(xid, tcon, &cifs_file->fid); 673*38c8a9a5SSteve French _free_xid(xid); 674*38c8a9a5SSteve French } 675*38c8a9a5SSteve French 676*38c8a9a5SSteve French if (oplock_break_cancelled) 677*38c8a9a5SSteve French cifs_done_oplock_break(cifsi); 678*38c8a9a5SSteve French 679*38c8a9a5SSteve French cifs_del_pending_open(&open); 680*38c8a9a5SSteve French 681*38c8a9a5SSteve French if (offload) 682*38c8a9a5SSteve French queue_work(fileinfo_put_wq, &cifs_file->put); 683*38c8a9a5SSteve French else 684*38c8a9a5SSteve French cifsFileInfo_put_final(cifs_file); 685*38c8a9a5SSteve French } 686*38c8a9a5SSteve French 687*38c8a9a5SSteve French int cifs_open(struct inode *inode, struct file *file) 688*38c8a9a5SSteve French 689*38c8a9a5SSteve French { 690*38c8a9a5SSteve French int rc = -EACCES; 691*38c8a9a5SSteve French unsigned int xid; 692*38c8a9a5SSteve French __u32 oplock; 693*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb; 694*38c8a9a5SSteve French struct TCP_Server_Info *server; 695*38c8a9a5SSteve French struct cifs_tcon *tcon; 696*38c8a9a5SSteve French struct tcon_link *tlink; 697*38c8a9a5SSteve French struct cifsFileInfo *cfile = NULL; 698*38c8a9a5SSteve French void *page; 699*38c8a9a5SSteve French const char *full_path; 700*38c8a9a5SSteve French bool posix_open_ok = false; 701*38c8a9a5SSteve French struct cifs_fid fid = {}; 702*38c8a9a5SSteve French struct cifs_pending_open open; 703*38c8a9a5SSteve French struct cifs_open_info_data data = {}; 704*38c8a9a5SSteve French 705*38c8a9a5SSteve French xid = get_xid(); 706*38c8a9a5SSteve French 707*38c8a9a5SSteve French cifs_sb = CIFS_SB(inode->i_sb); 708*38c8a9a5SSteve French if (unlikely(cifs_forced_shutdown(cifs_sb))) { 709*38c8a9a5SSteve French free_xid(xid); 710*38c8a9a5SSteve French return -EIO; 711*38c8a9a5SSteve French } 712*38c8a9a5SSteve French 713*38c8a9a5SSteve French tlink = cifs_sb_tlink(cifs_sb); 714*38c8a9a5SSteve French if (IS_ERR(tlink)) { 715*38c8a9a5SSteve French free_xid(xid); 716*38c8a9a5SSteve French return PTR_ERR(tlink); 717*38c8a9a5SSteve French } 718*38c8a9a5SSteve French tcon = tlink_tcon(tlink); 719*38c8a9a5SSteve French server = tcon->ses->server; 720*38c8a9a5SSteve French 721*38c8a9a5SSteve French page = alloc_dentry_path(); 722*38c8a9a5SSteve French full_path = build_path_from_dentry(file_dentry(file), page); 723*38c8a9a5SSteve French if (IS_ERR(full_path)) { 724*38c8a9a5SSteve French rc = PTR_ERR(full_path); 725*38c8a9a5SSteve French goto out; 726*38c8a9a5SSteve French } 727*38c8a9a5SSteve French 728*38c8a9a5SSteve French cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n", 729*38c8a9a5SSteve French inode, file->f_flags, full_path); 730*38c8a9a5SSteve French 731*38c8a9a5SSteve French if (file->f_flags & O_DIRECT && 732*38c8a9a5SSteve French cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) { 733*38c8a9a5SSteve French if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL) 734*38c8a9a5SSteve French file->f_op = &cifs_file_direct_nobrl_ops; 735*38c8a9a5SSteve French else 736*38c8a9a5SSteve French file->f_op = &cifs_file_direct_ops; 737*38c8a9a5SSteve French } 738*38c8a9a5SSteve French 739*38c8a9a5SSteve French /* Get the cached handle as SMB2 close is deferred */ 740*38c8a9a5SSteve French rc = cifs_get_readable_path(tcon, full_path, &cfile); 741*38c8a9a5SSteve French if (rc == 0) { 742*38c8a9a5SSteve French if (file->f_flags == cfile->f_flags) { 743*38c8a9a5SSteve French file->private_data = cfile; 744*38c8a9a5SSteve French spin_lock(&CIFS_I(inode)->deferred_lock); 745*38c8a9a5SSteve French cifs_del_deferred_close(cfile); 746*38c8a9a5SSteve French spin_unlock(&CIFS_I(inode)->deferred_lock); 747*38c8a9a5SSteve French goto use_cache; 748*38c8a9a5SSteve French } else { 749*38c8a9a5SSteve French _cifsFileInfo_put(cfile, true, false); 750*38c8a9a5SSteve French } 751*38c8a9a5SSteve French } 752*38c8a9a5SSteve French 753*38c8a9a5SSteve French if (server->oplocks) 754*38c8a9a5SSteve French oplock = REQ_OPLOCK; 755*38c8a9a5SSteve French else 756*38c8a9a5SSteve French oplock = 0; 757*38c8a9a5SSteve French 758*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 759*38c8a9a5SSteve French if (!tcon->broken_posix_open && tcon->unix_ext && 760*38c8a9a5SSteve French cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP & 761*38c8a9a5SSteve French le64_to_cpu(tcon->fsUnixInfo.Capability))) { 762*38c8a9a5SSteve French /* can not refresh inode info since size could be stale */ 763*38c8a9a5SSteve French rc = cifs_posix_open(full_path, &inode, inode->i_sb, 764*38c8a9a5SSteve French cifs_sb->ctx->file_mode /* ignored */, 765*38c8a9a5SSteve French file->f_flags, &oplock, &fid.netfid, xid); 766*38c8a9a5SSteve French if (rc == 0) { 767*38c8a9a5SSteve French cifs_dbg(FYI, "posix open succeeded\n"); 768*38c8a9a5SSteve French posix_open_ok = true; 769*38c8a9a5SSteve French } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) { 770*38c8a9a5SSteve French if (tcon->ses->serverNOS) 771*38c8a9a5SSteve French 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", 772*38c8a9a5SSteve French tcon->ses->ip_addr, 773*38c8a9a5SSteve French tcon->ses->serverNOS); 774*38c8a9a5SSteve French tcon->broken_posix_open = true; 775*38c8a9a5SSteve French } else if ((rc != -EIO) && (rc != -EREMOTE) && 776*38c8a9a5SSteve French (rc != -EOPNOTSUPP)) /* path not found or net err */ 777*38c8a9a5SSteve French goto out; 778*38c8a9a5SSteve French /* 779*38c8a9a5SSteve French * Else fallthrough to retry open the old way on network i/o 780*38c8a9a5SSteve French * or DFS errors. 781*38c8a9a5SSteve French */ 782*38c8a9a5SSteve French } 783*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 784*38c8a9a5SSteve French 785*38c8a9a5SSteve French if (server->ops->get_lease_key) 786*38c8a9a5SSteve French server->ops->get_lease_key(inode, &fid); 787*38c8a9a5SSteve French 788*38c8a9a5SSteve French cifs_add_pending_open(&fid, tlink, &open); 789*38c8a9a5SSteve French 790*38c8a9a5SSteve French if (!posix_open_ok) { 791*38c8a9a5SSteve French if (server->ops->get_lease_key) 792*38c8a9a5SSteve French server->ops->get_lease_key(inode, &fid); 793*38c8a9a5SSteve French 794*38c8a9a5SSteve French rc = cifs_nt_open(full_path, inode, cifs_sb, tcon, file->f_flags, &oplock, &fid, 795*38c8a9a5SSteve French xid, &data); 796*38c8a9a5SSteve French if (rc) { 797*38c8a9a5SSteve French cifs_del_pending_open(&open); 798*38c8a9a5SSteve French goto out; 799*38c8a9a5SSteve French } 800*38c8a9a5SSteve French } 801*38c8a9a5SSteve French 802*38c8a9a5SSteve French cfile = cifs_new_fileinfo(&fid, file, tlink, oplock, data.symlink_target); 803*38c8a9a5SSteve French if (cfile == NULL) { 804*38c8a9a5SSteve French if (server->ops->close) 805*38c8a9a5SSteve French server->ops->close(xid, tcon, &fid); 806*38c8a9a5SSteve French cifs_del_pending_open(&open); 807*38c8a9a5SSteve French rc = -ENOMEM; 808*38c8a9a5SSteve French goto out; 809*38c8a9a5SSteve French } 810*38c8a9a5SSteve French 811*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 812*38c8a9a5SSteve French if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) { 813*38c8a9a5SSteve French /* 814*38c8a9a5SSteve French * Time to set mode which we can not set earlier due to 815*38c8a9a5SSteve French * problems creating new read-only files. 816*38c8a9a5SSteve French */ 817*38c8a9a5SSteve French struct cifs_unix_set_info_args args = { 818*38c8a9a5SSteve French .mode = inode->i_mode, 819*38c8a9a5SSteve French .uid = INVALID_UID, /* no change */ 820*38c8a9a5SSteve French .gid = INVALID_GID, /* no change */ 821*38c8a9a5SSteve French .ctime = NO_CHANGE_64, 822*38c8a9a5SSteve French .atime = NO_CHANGE_64, 823*38c8a9a5SSteve French .mtime = NO_CHANGE_64, 824*38c8a9a5SSteve French .device = 0, 825*38c8a9a5SSteve French }; 826*38c8a9a5SSteve French CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid, 827*38c8a9a5SSteve French cfile->pid); 828*38c8a9a5SSteve French } 829*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 830*38c8a9a5SSteve French 831*38c8a9a5SSteve French use_cache: 832*38c8a9a5SSteve French fscache_use_cookie(cifs_inode_cookie(file_inode(file)), 833*38c8a9a5SSteve French file->f_mode & FMODE_WRITE); 834*38c8a9a5SSteve French if (file->f_flags & O_DIRECT && 835*38c8a9a5SSteve French (!((file->f_flags & O_ACCMODE) != O_RDONLY) || 836*38c8a9a5SSteve French file->f_flags & O_APPEND)) 837*38c8a9a5SSteve French cifs_invalidate_cache(file_inode(file), 838*38c8a9a5SSteve French FSCACHE_INVAL_DIO_WRITE); 839*38c8a9a5SSteve French 840*38c8a9a5SSteve French out: 841*38c8a9a5SSteve French free_dentry_path(page); 842*38c8a9a5SSteve French free_xid(xid); 843*38c8a9a5SSteve French cifs_put_tlink(tlink); 844*38c8a9a5SSteve French cifs_free_open_info(&data); 845*38c8a9a5SSteve French return rc; 846*38c8a9a5SSteve French } 847*38c8a9a5SSteve French 848*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 849*38c8a9a5SSteve French static int cifs_push_posix_locks(struct cifsFileInfo *cfile); 850*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 851*38c8a9a5SSteve French 852*38c8a9a5SSteve French /* 853*38c8a9a5SSteve French * Try to reacquire byte range locks that were released when session 854*38c8a9a5SSteve French * to server was lost. 855*38c8a9a5SSteve French */ 856*38c8a9a5SSteve French static int 857*38c8a9a5SSteve French cifs_relock_file(struct cifsFileInfo *cfile) 858*38c8a9a5SSteve French { 859*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 860*38c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 861*38c8a9a5SSteve French int rc = 0; 862*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 863*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb); 864*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 865*38c8a9a5SSteve French 866*38c8a9a5SSteve French down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING); 867*38c8a9a5SSteve French if (cinode->can_cache_brlcks) { 868*38c8a9a5SSteve French /* can cache locks - no need to relock */ 869*38c8a9a5SSteve French up_read(&cinode->lock_sem); 870*38c8a9a5SSteve French return rc; 871*38c8a9a5SSteve French } 872*38c8a9a5SSteve French 873*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 874*38c8a9a5SSteve French if (cap_unix(tcon->ses) && 875*38c8a9a5SSteve French (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) && 876*38c8a9a5SSteve French ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) 877*38c8a9a5SSteve French rc = cifs_push_posix_locks(cfile); 878*38c8a9a5SSteve French else 879*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 880*38c8a9a5SSteve French rc = tcon->ses->server->ops->push_mand_locks(cfile); 881*38c8a9a5SSteve French 882*38c8a9a5SSteve French up_read(&cinode->lock_sem); 883*38c8a9a5SSteve French return rc; 884*38c8a9a5SSteve French } 885*38c8a9a5SSteve French 886*38c8a9a5SSteve French static int 887*38c8a9a5SSteve French cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush) 888*38c8a9a5SSteve French { 889*38c8a9a5SSteve French int rc = -EACCES; 890*38c8a9a5SSteve French unsigned int xid; 891*38c8a9a5SSteve French __u32 oplock; 892*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb; 893*38c8a9a5SSteve French struct cifs_tcon *tcon; 894*38c8a9a5SSteve French struct TCP_Server_Info *server; 895*38c8a9a5SSteve French struct cifsInodeInfo *cinode; 896*38c8a9a5SSteve French struct inode *inode; 897*38c8a9a5SSteve French void *page; 898*38c8a9a5SSteve French const char *full_path; 899*38c8a9a5SSteve French int desired_access; 900*38c8a9a5SSteve French int disposition = FILE_OPEN; 901*38c8a9a5SSteve French int create_options = CREATE_NOT_DIR; 902*38c8a9a5SSteve French struct cifs_open_parms oparms; 903*38c8a9a5SSteve French 904*38c8a9a5SSteve French xid = get_xid(); 905*38c8a9a5SSteve French mutex_lock(&cfile->fh_mutex); 906*38c8a9a5SSteve French if (!cfile->invalidHandle) { 907*38c8a9a5SSteve French mutex_unlock(&cfile->fh_mutex); 908*38c8a9a5SSteve French free_xid(xid); 909*38c8a9a5SSteve French return 0; 910*38c8a9a5SSteve French } 911*38c8a9a5SSteve French 912*38c8a9a5SSteve French inode = d_inode(cfile->dentry); 913*38c8a9a5SSteve French cifs_sb = CIFS_SB(inode->i_sb); 914*38c8a9a5SSteve French tcon = tlink_tcon(cfile->tlink); 915*38c8a9a5SSteve French server = tcon->ses->server; 916*38c8a9a5SSteve French 917*38c8a9a5SSteve French /* 918*38c8a9a5SSteve French * Can not grab rename sem here because various ops, including those 919*38c8a9a5SSteve French * that already have the rename sem can end up causing writepage to get 920*38c8a9a5SSteve French * called and if the server was down that means we end up here, and we 921*38c8a9a5SSteve French * can never tell if the caller already has the rename_sem. 922*38c8a9a5SSteve French */ 923*38c8a9a5SSteve French page = alloc_dentry_path(); 924*38c8a9a5SSteve French full_path = build_path_from_dentry(cfile->dentry, page); 925*38c8a9a5SSteve French if (IS_ERR(full_path)) { 926*38c8a9a5SSteve French mutex_unlock(&cfile->fh_mutex); 927*38c8a9a5SSteve French free_dentry_path(page); 928*38c8a9a5SSteve French free_xid(xid); 929*38c8a9a5SSteve French return PTR_ERR(full_path); 930*38c8a9a5SSteve French } 931*38c8a9a5SSteve French 932*38c8a9a5SSteve French cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n", 933*38c8a9a5SSteve French inode, cfile->f_flags, full_path); 934*38c8a9a5SSteve French 935*38c8a9a5SSteve French if (tcon->ses->server->oplocks) 936*38c8a9a5SSteve French oplock = REQ_OPLOCK; 937*38c8a9a5SSteve French else 938*38c8a9a5SSteve French oplock = 0; 939*38c8a9a5SSteve French 940*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 941*38c8a9a5SSteve French if (tcon->unix_ext && cap_unix(tcon->ses) && 942*38c8a9a5SSteve French (CIFS_UNIX_POSIX_PATH_OPS_CAP & 943*38c8a9a5SSteve French le64_to_cpu(tcon->fsUnixInfo.Capability))) { 944*38c8a9a5SSteve French /* 945*38c8a9a5SSteve French * O_CREAT, O_EXCL and O_TRUNC already had their effect on the 946*38c8a9a5SSteve French * original open. Must mask them off for a reopen. 947*38c8a9a5SSteve French */ 948*38c8a9a5SSteve French unsigned int oflags = cfile->f_flags & 949*38c8a9a5SSteve French ~(O_CREAT | O_EXCL | O_TRUNC); 950*38c8a9a5SSteve French 951*38c8a9a5SSteve French rc = cifs_posix_open(full_path, NULL, inode->i_sb, 952*38c8a9a5SSteve French cifs_sb->ctx->file_mode /* ignored */, 953*38c8a9a5SSteve French oflags, &oplock, &cfile->fid.netfid, xid); 954*38c8a9a5SSteve French if (rc == 0) { 955*38c8a9a5SSteve French cifs_dbg(FYI, "posix reopen succeeded\n"); 956*38c8a9a5SSteve French oparms.reconnect = true; 957*38c8a9a5SSteve French goto reopen_success; 958*38c8a9a5SSteve French } 959*38c8a9a5SSteve French /* 960*38c8a9a5SSteve French * fallthrough to retry open the old way on errors, especially 961*38c8a9a5SSteve French * in the reconnect path it is important to retry hard 962*38c8a9a5SSteve French */ 963*38c8a9a5SSteve French } 964*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 965*38c8a9a5SSteve French 966*38c8a9a5SSteve French desired_access = cifs_convert_flags(cfile->f_flags); 967*38c8a9a5SSteve French 968*38c8a9a5SSteve French /* O_SYNC also has bit for O_DSYNC so following check picks up either */ 969*38c8a9a5SSteve French if (cfile->f_flags & O_SYNC) 970*38c8a9a5SSteve French create_options |= CREATE_WRITE_THROUGH; 971*38c8a9a5SSteve French 972*38c8a9a5SSteve French if (cfile->f_flags & O_DIRECT) 973*38c8a9a5SSteve French create_options |= CREATE_NO_BUFFER; 974*38c8a9a5SSteve French 975*38c8a9a5SSteve French if (server->ops->get_lease_key) 976*38c8a9a5SSteve French server->ops->get_lease_key(inode, &cfile->fid); 977*38c8a9a5SSteve French 978*38c8a9a5SSteve French oparms = (struct cifs_open_parms) { 979*38c8a9a5SSteve French .tcon = tcon, 980*38c8a9a5SSteve French .cifs_sb = cifs_sb, 981*38c8a9a5SSteve French .desired_access = desired_access, 982*38c8a9a5SSteve French .create_options = cifs_create_options(cifs_sb, create_options), 983*38c8a9a5SSteve French .disposition = disposition, 984*38c8a9a5SSteve French .path = full_path, 985*38c8a9a5SSteve French .fid = &cfile->fid, 986*38c8a9a5SSteve French .reconnect = true, 987*38c8a9a5SSteve French }; 988*38c8a9a5SSteve French 989*38c8a9a5SSteve French /* 990*38c8a9a5SSteve French * Can not refresh inode by passing in file_info buf to be returned by 991*38c8a9a5SSteve French * ops->open and then calling get_inode_info with returned buf since 992*38c8a9a5SSteve French * file might have write behind data that needs to be flushed and server 993*38c8a9a5SSteve French * version of file size can be stale. If we knew for sure that inode was 994*38c8a9a5SSteve French * not dirty locally we could do this. 995*38c8a9a5SSteve French */ 996*38c8a9a5SSteve French rc = server->ops->open(xid, &oparms, &oplock, NULL); 997*38c8a9a5SSteve French if (rc == -ENOENT && oparms.reconnect == false) { 998*38c8a9a5SSteve French /* durable handle timeout is expired - open the file again */ 999*38c8a9a5SSteve French rc = server->ops->open(xid, &oparms, &oplock, NULL); 1000*38c8a9a5SSteve French /* indicate that we need to relock the file */ 1001*38c8a9a5SSteve French oparms.reconnect = true; 1002*38c8a9a5SSteve French } 1003*38c8a9a5SSteve French 1004*38c8a9a5SSteve French if (rc) { 1005*38c8a9a5SSteve French mutex_unlock(&cfile->fh_mutex); 1006*38c8a9a5SSteve French cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc); 1007*38c8a9a5SSteve French cifs_dbg(FYI, "oplock: %d\n", oplock); 1008*38c8a9a5SSteve French goto reopen_error_exit; 1009*38c8a9a5SSteve French } 1010*38c8a9a5SSteve French 1011*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1012*38c8a9a5SSteve French reopen_success: 1013*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1014*38c8a9a5SSteve French cfile->invalidHandle = false; 1015*38c8a9a5SSteve French mutex_unlock(&cfile->fh_mutex); 1016*38c8a9a5SSteve French cinode = CIFS_I(inode); 1017*38c8a9a5SSteve French 1018*38c8a9a5SSteve French if (can_flush) { 1019*38c8a9a5SSteve French rc = filemap_write_and_wait(inode->i_mapping); 1020*38c8a9a5SSteve French if (!is_interrupt_error(rc)) 1021*38c8a9a5SSteve French mapping_set_error(inode->i_mapping, rc); 1022*38c8a9a5SSteve French 1023*38c8a9a5SSteve French if (tcon->posix_extensions) 1024*38c8a9a5SSteve French rc = smb311_posix_get_inode_info(&inode, full_path, inode->i_sb, xid); 1025*38c8a9a5SSteve French else if (tcon->unix_ext) 1026*38c8a9a5SSteve French rc = cifs_get_inode_info_unix(&inode, full_path, 1027*38c8a9a5SSteve French inode->i_sb, xid); 1028*38c8a9a5SSteve French else 1029*38c8a9a5SSteve French rc = cifs_get_inode_info(&inode, full_path, NULL, 1030*38c8a9a5SSteve French inode->i_sb, xid, NULL); 1031*38c8a9a5SSteve French } 1032*38c8a9a5SSteve French /* 1033*38c8a9a5SSteve French * Else we are writing out data to server already and could deadlock if 1034*38c8a9a5SSteve French * we tried to flush data, and since we do not know if we have data that 1035*38c8a9a5SSteve French * would invalidate the current end of file on the server we can not go 1036*38c8a9a5SSteve French * to the server to get the new inode info. 1037*38c8a9a5SSteve French */ 1038*38c8a9a5SSteve French 1039*38c8a9a5SSteve French /* 1040*38c8a9a5SSteve French * If the server returned a read oplock and we have mandatory brlocks, 1041*38c8a9a5SSteve French * set oplock level to None. 1042*38c8a9a5SSteve French */ 1043*38c8a9a5SSteve French if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) { 1044*38c8a9a5SSteve French cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n"); 1045*38c8a9a5SSteve French oplock = 0; 1046*38c8a9a5SSteve French } 1047*38c8a9a5SSteve French 1048*38c8a9a5SSteve French server->ops->set_fid(cfile, &cfile->fid, oplock); 1049*38c8a9a5SSteve French if (oparms.reconnect) 1050*38c8a9a5SSteve French cifs_relock_file(cfile); 1051*38c8a9a5SSteve French 1052*38c8a9a5SSteve French reopen_error_exit: 1053*38c8a9a5SSteve French free_dentry_path(page); 1054*38c8a9a5SSteve French free_xid(xid); 1055*38c8a9a5SSteve French return rc; 1056*38c8a9a5SSteve French } 1057*38c8a9a5SSteve French 1058*38c8a9a5SSteve French void smb2_deferred_work_close(struct work_struct *work) 1059*38c8a9a5SSteve French { 1060*38c8a9a5SSteve French struct cifsFileInfo *cfile = container_of(work, 1061*38c8a9a5SSteve French struct cifsFileInfo, deferred.work); 1062*38c8a9a5SSteve French 1063*38c8a9a5SSteve French spin_lock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock); 1064*38c8a9a5SSteve French cifs_del_deferred_close(cfile); 1065*38c8a9a5SSteve French cfile->deferred_close_scheduled = false; 1066*38c8a9a5SSteve French spin_unlock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock); 1067*38c8a9a5SSteve French _cifsFileInfo_put(cfile, true, false); 1068*38c8a9a5SSteve French } 1069*38c8a9a5SSteve French 1070*38c8a9a5SSteve French int cifs_close(struct inode *inode, struct file *file) 1071*38c8a9a5SSteve French { 1072*38c8a9a5SSteve French struct cifsFileInfo *cfile; 1073*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(inode); 1074*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 1075*38c8a9a5SSteve French struct cifs_deferred_close *dclose; 1076*38c8a9a5SSteve French 1077*38c8a9a5SSteve French cifs_fscache_unuse_inode_cookie(inode, file->f_mode & FMODE_WRITE); 1078*38c8a9a5SSteve French 1079*38c8a9a5SSteve French if (file->private_data != NULL) { 1080*38c8a9a5SSteve French cfile = file->private_data; 1081*38c8a9a5SSteve French file->private_data = NULL; 1082*38c8a9a5SSteve French dclose = kmalloc(sizeof(struct cifs_deferred_close), GFP_KERNEL); 1083*38c8a9a5SSteve French if ((cinode->oplock == CIFS_CACHE_RHW_FLG) && 1084*38c8a9a5SSteve French cinode->lease_granted && 1085*38c8a9a5SSteve French !test_bit(CIFS_INO_CLOSE_ON_LOCK, &cinode->flags) && 1086*38c8a9a5SSteve French dclose) { 1087*38c8a9a5SSteve French if (test_and_clear_bit(CIFS_INO_MODIFIED_ATTR, &cinode->flags)) { 1088*38c8a9a5SSteve French inode->i_ctime = inode->i_mtime = current_time(inode); 1089*38c8a9a5SSteve French } 1090*38c8a9a5SSteve French spin_lock(&cinode->deferred_lock); 1091*38c8a9a5SSteve French cifs_add_deferred_close(cfile, dclose); 1092*38c8a9a5SSteve French if (cfile->deferred_close_scheduled && 1093*38c8a9a5SSteve French delayed_work_pending(&cfile->deferred)) { 1094*38c8a9a5SSteve French /* 1095*38c8a9a5SSteve French * If there is no pending work, mod_delayed_work queues new work. 1096*38c8a9a5SSteve French * So, Increase the ref count to avoid use-after-free. 1097*38c8a9a5SSteve French */ 1098*38c8a9a5SSteve French if (!mod_delayed_work(deferredclose_wq, 1099*38c8a9a5SSteve French &cfile->deferred, cifs_sb->ctx->closetimeo)) 1100*38c8a9a5SSteve French cifsFileInfo_get(cfile); 1101*38c8a9a5SSteve French } else { 1102*38c8a9a5SSteve French /* Deferred close for files */ 1103*38c8a9a5SSteve French queue_delayed_work(deferredclose_wq, 1104*38c8a9a5SSteve French &cfile->deferred, cifs_sb->ctx->closetimeo); 1105*38c8a9a5SSteve French cfile->deferred_close_scheduled = true; 1106*38c8a9a5SSteve French spin_unlock(&cinode->deferred_lock); 1107*38c8a9a5SSteve French return 0; 1108*38c8a9a5SSteve French } 1109*38c8a9a5SSteve French spin_unlock(&cinode->deferred_lock); 1110*38c8a9a5SSteve French _cifsFileInfo_put(cfile, true, false); 1111*38c8a9a5SSteve French } else { 1112*38c8a9a5SSteve French _cifsFileInfo_put(cfile, true, false); 1113*38c8a9a5SSteve French kfree(dclose); 1114*38c8a9a5SSteve French } 1115*38c8a9a5SSteve French } 1116*38c8a9a5SSteve French 1117*38c8a9a5SSteve French /* return code from the ->release op is always ignored */ 1118*38c8a9a5SSteve French return 0; 1119*38c8a9a5SSteve French } 1120*38c8a9a5SSteve French 1121*38c8a9a5SSteve French void 1122*38c8a9a5SSteve French cifs_reopen_persistent_handles(struct cifs_tcon *tcon) 1123*38c8a9a5SSteve French { 1124*38c8a9a5SSteve French struct cifsFileInfo *open_file, *tmp; 1125*38c8a9a5SSteve French struct list_head tmp_list; 1126*38c8a9a5SSteve French 1127*38c8a9a5SSteve French if (!tcon->use_persistent || !tcon->need_reopen_files) 1128*38c8a9a5SSteve French return; 1129*38c8a9a5SSteve French 1130*38c8a9a5SSteve French tcon->need_reopen_files = false; 1131*38c8a9a5SSteve French 1132*38c8a9a5SSteve French cifs_dbg(FYI, "Reopen persistent handles\n"); 1133*38c8a9a5SSteve French INIT_LIST_HEAD(&tmp_list); 1134*38c8a9a5SSteve French 1135*38c8a9a5SSteve French /* list all files open on tree connection, reopen resilient handles */ 1136*38c8a9a5SSteve French spin_lock(&tcon->open_file_lock); 1137*38c8a9a5SSteve French list_for_each_entry(open_file, &tcon->openFileList, tlist) { 1138*38c8a9a5SSteve French if (!open_file->invalidHandle) 1139*38c8a9a5SSteve French continue; 1140*38c8a9a5SSteve French cifsFileInfo_get(open_file); 1141*38c8a9a5SSteve French list_add_tail(&open_file->rlist, &tmp_list); 1142*38c8a9a5SSteve French } 1143*38c8a9a5SSteve French spin_unlock(&tcon->open_file_lock); 1144*38c8a9a5SSteve French 1145*38c8a9a5SSteve French list_for_each_entry_safe(open_file, tmp, &tmp_list, rlist) { 1146*38c8a9a5SSteve French if (cifs_reopen_file(open_file, false /* do not flush */)) 1147*38c8a9a5SSteve French tcon->need_reopen_files = true; 1148*38c8a9a5SSteve French list_del_init(&open_file->rlist); 1149*38c8a9a5SSteve French cifsFileInfo_put(open_file); 1150*38c8a9a5SSteve French } 1151*38c8a9a5SSteve French } 1152*38c8a9a5SSteve French 1153*38c8a9a5SSteve French int cifs_closedir(struct inode *inode, struct file *file) 1154*38c8a9a5SSteve French { 1155*38c8a9a5SSteve French int rc = 0; 1156*38c8a9a5SSteve French unsigned int xid; 1157*38c8a9a5SSteve French struct cifsFileInfo *cfile = file->private_data; 1158*38c8a9a5SSteve French struct cifs_tcon *tcon; 1159*38c8a9a5SSteve French struct TCP_Server_Info *server; 1160*38c8a9a5SSteve French char *buf; 1161*38c8a9a5SSteve French 1162*38c8a9a5SSteve French cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode); 1163*38c8a9a5SSteve French 1164*38c8a9a5SSteve French if (cfile == NULL) 1165*38c8a9a5SSteve French return rc; 1166*38c8a9a5SSteve French 1167*38c8a9a5SSteve French xid = get_xid(); 1168*38c8a9a5SSteve French tcon = tlink_tcon(cfile->tlink); 1169*38c8a9a5SSteve French server = tcon->ses->server; 1170*38c8a9a5SSteve French 1171*38c8a9a5SSteve French cifs_dbg(FYI, "Freeing private data in close dir\n"); 1172*38c8a9a5SSteve French spin_lock(&cfile->file_info_lock); 1173*38c8a9a5SSteve French if (server->ops->dir_needs_close(cfile)) { 1174*38c8a9a5SSteve French cfile->invalidHandle = true; 1175*38c8a9a5SSteve French spin_unlock(&cfile->file_info_lock); 1176*38c8a9a5SSteve French if (server->ops->close_dir) 1177*38c8a9a5SSteve French rc = server->ops->close_dir(xid, tcon, &cfile->fid); 1178*38c8a9a5SSteve French else 1179*38c8a9a5SSteve French rc = -ENOSYS; 1180*38c8a9a5SSteve French cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc); 1181*38c8a9a5SSteve French /* not much we can do if it fails anyway, ignore rc */ 1182*38c8a9a5SSteve French rc = 0; 1183*38c8a9a5SSteve French } else 1184*38c8a9a5SSteve French spin_unlock(&cfile->file_info_lock); 1185*38c8a9a5SSteve French 1186*38c8a9a5SSteve French buf = cfile->srch_inf.ntwrk_buf_start; 1187*38c8a9a5SSteve French if (buf) { 1188*38c8a9a5SSteve French cifs_dbg(FYI, "closedir free smb buf in srch struct\n"); 1189*38c8a9a5SSteve French cfile->srch_inf.ntwrk_buf_start = NULL; 1190*38c8a9a5SSteve French if (cfile->srch_inf.smallBuf) 1191*38c8a9a5SSteve French cifs_small_buf_release(buf); 1192*38c8a9a5SSteve French else 1193*38c8a9a5SSteve French cifs_buf_release(buf); 1194*38c8a9a5SSteve French } 1195*38c8a9a5SSteve French 1196*38c8a9a5SSteve French cifs_put_tlink(cfile->tlink); 1197*38c8a9a5SSteve French kfree(file->private_data); 1198*38c8a9a5SSteve French file->private_data = NULL; 1199*38c8a9a5SSteve French /* BB can we lock the filestruct while this is going on? */ 1200*38c8a9a5SSteve French free_xid(xid); 1201*38c8a9a5SSteve French return rc; 1202*38c8a9a5SSteve French } 1203*38c8a9a5SSteve French 1204*38c8a9a5SSteve French static struct cifsLockInfo * 1205*38c8a9a5SSteve French cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 flags) 1206*38c8a9a5SSteve French { 1207*38c8a9a5SSteve French struct cifsLockInfo *lock = 1208*38c8a9a5SSteve French kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL); 1209*38c8a9a5SSteve French if (!lock) 1210*38c8a9a5SSteve French return lock; 1211*38c8a9a5SSteve French lock->offset = offset; 1212*38c8a9a5SSteve French lock->length = length; 1213*38c8a9a5SSteve French lock->type = type; 1214*38c8a9a5SSteve French lock->pid = current->tgid; 1215*38c8a9a5SSteve French lock->flags = flags; 1216*38c8a9a5SSteve French INIT_LIST_HEAD(&lock->blist); 1217*38c8a9a5SSteve French init_waitqueue_head(&lock->block_q); 1218*38c8a9a5SSteve French return lock; 1219*38c8a9a5SSteve French } 1220*38c8a9a5SSteve French 1221*38c8a9a5SSteve French void 1222*38c8a9a5SSteve French cifs_del_lock_waiters(struct cifsLockInfo *lock) 1223*38c8a9a5SSteve French { 1224*38c8a9a5SSteve French struct cifsLockInfo *li, *tmp; 1225*38c8a9a5SSteve French list_for_each_entry_safe(li, tmp, &lock->blist, blist) { 1226*38c8a9a5SSteve French list_del_init(&li->blist); 1227*38c8a9a5SSteve French wake_up(&li->block_q); 1228*38c8a9a5SSteve French } 1229*38c8a9a5SSteve French } 1230*38c8a9a5SSteve French 1231*38c8a9a5SSteve French #define CIFS_LOCK_OP 0 1232*38c8a9a5SSteve French #define CIFS_READ_OP 1 1233*38c8a9a5SSteve French #define CIFS_WRITE_OP 2 1234*38c8a9a5SSteve French 1235*38c8a9a5SSteve French /* @rw_check : 0 - no op, 1 - read, 2 - write */ 1236*38c8a9a5SSteve French static bool 1237*38c8a9a5SSteve French cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset, 1238*38c8a9a5SSteve French __u64 length, __u8 type, __u16 flags, 1239*38c8a9a5SSteve French struct cifsFileInfo *cfile, 1240*38c8a9a5SSteve French struct cifsLockInfo **conf_lock, int rw_check) 1241*38c8a9a5SSteve French { 1242*38c8a9a5SSteve French struct cifsLockInfo *li; 1243*38c8a9a5SSteve French struct cifsFileInfo *cur_cfile = fdlocks->cfile; 1244*38c8a9a5SSteve French struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server; 1245*38c8a9a5SSteve French 1246*38c8a9a5SSteve French list_for_each_entry(li, &fdlocks->locks, llist) { 1247*38c8a9a5SSteve French if (offset + length <= li->offset || 1248*38c8a9a5SSteve French offset >= li->offset + li->length) 1249*38c8a9a5SSteve French continue; 1250*38c8a9a5SSteve French if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid && 1251*38c8a9a5SSteve French server->ops->compare_fids(cfile, cur_cfile)) { 1252*38c8a9a5SSteve French /* shared lock prevents write op through the same fid */ 1253*38c8a9a5SSteve French if (!(li->type & server->vals->shared_lock_type) || 1254*38c8a9a5SSteve French rw_check != CIFS_WRITE_OP) 1255*38c8a9a5SSteve French continue; 1256*38c8a9a5SSteve French } 1257*38c8a9a5SSteve French if ((type & server->vals->shared_lock_type) && 1258*38c8a9a5SSteve French ((server->ops->compare_fids(cfile, cur_cfile) && 1259*38c8a9a5SSteve French current->tgid == li->pid) || type == li->type)) 1260*38c8a9a5SSteve French continue; 1261*38c8a9a5SSteve French if (rw_check == CIFS_LOCK_OP && 1262*38c8a9a5SSteve French (flags & FL_OFDLCK) && (li->flags & FL_OFDLCK) && 1263*38c8a9a5SSteve French server->ops->compare_fids(cfile, cur_cfile)) 1264*38c8a9a5SSteve French continue; 1265*38c8a9a5SSteve French if (conf_lock) 1266*38c8a9a5SSteve French *conf_lock = li; 1267*38c8a9a5SSteve French return true; 1268*38c8a9a5SSteve French } 1269*38c8a9a5SSteve French return false; 1270*38c8a9a5SSteve French } 1271*38c8a9a5SSteve French 1272*38c8a9a5SSteve French bool 1273*38c8a9a5SSteve French cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length, 1274*38c8a9a5SSteve French __u8 type, __u16 flags, 1275*38c8a9a5SSteve French struct cifsLockInfo **conf_lock, int rw_check) 1276*38c8a9a5SSteve French { 1277*38c8a9a5SSteve French bool rc = false; 1278*38c8a9a5SSteve French struct cifs_fid_locks *cur; 1279*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1280*38c8a9a5SSteve French 1281*38c8a9a5SSteve French list_for_each_entry(cur, &cinode->llist, llist) { 1282*38c8a9a5SSteve French rc = cifs_find_fid_lock_conflict(cur, offset, length, type, 1283*38c8a9a5SSteve French flags, cfile, conf_lock, 1284*38c8a9a5SSteve French rw_check); 1285*38c8a9a5SSteve French if (rc) 1286*38c8a9a5SSteve French break; 1287*38c8a9a5SSteve French } 1288*38c8a9a5SSteve French 1289*38c8a9a5SSteve French return rc; 1290*38c8a9a5SSteve French } 1291*38c8a9a5SSteve French 1292*38c8a9a5SSteve French /* 1293*38c8a9a5SSteve French * Check if there is another lock that prevents us to set the lock (mandatory 1294*38c8a9a5SSteve French * style). If such a lock exists, update the flock structure with its 1295*38c8a9a5SSteve French * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks 1296*38c8a9a5SSteve French * or leave it the same if we can't. Returns 0 if we don't need to request to 1297*38c8a9a5SSteve French * the server or 1 otherwise. 1298*38c8a9a5SSteve French */ 1299*38c8a9a5SSteve French static int 1300*38c8a9a5SSteve French cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length, 1301*38c8a9a5SSteve French __u8 type, struct file_lock *flock) 1302*38c8a9a5SSteve French { 1303*38c8a9a5SSteve French int rc = 0; 1304*38c8a9a5SSteve French struct cifsLockInfo *conf_lock; 1305*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1306*38c8a9a5SSteve French struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server; 1307*38c8a9a5SSteve French bool exist; 1308*38c8a9a5SSteve French 1309*38c8a9a5SSteve French down_read(&cinode->lock_sem); 1310*38c8a9a5SSteve French 1311*38c8a9a5SSteve French exist = cifs_find_lock_conflict(cfile, offset, length, type, 1312*38c8a9a5SSteve French flock->fl_flags, &conf_lock, 1313*38c8a9a5SSteve French CIFS_LOCK_OP); 1314*38c8a9a5SSteve French if (exist) { 1315*38c8a9a5SSteve French flock->fl_start = conf_lock->offset; 1316*38c8a9a5SSteve French flock->fl_end = conf_lock->offset + conf_lock->length - 1; 1317*38c8a9a5SSteve French flock->fl_pid = conf_lock->pid; 1318*38c8a9a5SSteve French if (conf_lock->type & server->vals->shared_lock_type) 1319*38c8a9a5SSteve French flock->fl_type = F_RDLCK; 1320*38c8a9a5SSteve French else 1321*38c8a9a5SSteve French flock->fl_type = F_WRLCK; 1322*38c8a9a5SSteve French } else if (!cinode->can_cache_brlcks) 1323*38c8a9a5SSteve French rc = 1; 1324*38c8a9a5SSteve French else 1325*38c8a9a5SSteve French flock->fl_type = F_UNLCK; 1326*38c8a9a5SSteve French 1327*38c8a9a5SSteve French up_read(&cinode->lock_sem); 1328*38c8a9a5SSteve French return rc; 1329*38c8a9a5SSteve French } 1330*38c8a9a5SSteve French 1331*38c8a9a5SSteve French static void 1332*38c8a9a5SSteve French cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock) 1333*38c8a9a5SSteve French { 1334*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1335*38c8a9a5SSteve French cifs_down_write(&cinode->lock_sem); 1336*38c8a9a5SSteve French list_add_tail(&lock->llist, &cfile->llist->locks); 1337*38c8a9a5SSteve French up_write(&cinode->lock_sem); 1338*38c8a9a5SSteve French } 1339*38c8a9a5SSteve French 1340*38c8a9a5SSteve French /* 1341*38c8a9a5SSteve French * Set the byte-range lock (mandatory style). Returns: 1342*38c8a9a5SSteve French * 1) 0, if we set the lock and don't need to request to the server; 1343*38c8a9a5SSteve French * 2) 1, if no locks prevent us but we need to request to the server; 1344*38c8a9a5SSteve French * 3) -EACCES, if there is a lock that prevents us and wait is false. 1345*38c8a9a5SSteve French */ 1346*38c8a9a5SSteve French static int 1347*38c8a9a5SSteve French cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock, 1348*38c8a9a5SSteve French bool wait) 1349*38c8a9a5SSteve French { 1350*38c8a9a5SSteve French struct cifsLockInfo *conf_lock; 1351*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1352*38c8a9a5SSteve French bool exist; 1353*38c8a9a5SSteve French int rc = 0; 1354*38c8a9a5SSteve French 1355*38c8a9a5SSteve French try_again: 1356*38c8a9a5SSteve French exist = false; 1357*38c8a9a5SSteve French cifs_down_write(&cinode->lock_sem); 1358*38c8a9a5SSteve French 1359*38c8a9a5SSteve French exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length, 1360*38c8a9a5SSteve French lock->type, lock->flags, &conf_lock, 1361*38c8a9a5SSteve French CIFS_LOCK_OP); 1362*38c8a9a5SSteve French if (!exist && cinode->can_cache_brlcks) { 1363*38c8a9a5SSteve French list_add_tail(&lock->llist, &cfile->llist->locks); 1364*38c8a9a5SSteve French up_write(&cinode->lock_sem); 1365*38c8a9a5SSteve French return rc; 1366*38c8a9a5SSteve French } 1367*38c8a9a5SSteve French 1368*38c8a9a5SSteve French if (!exist) 1369*38c8a9a5SSteve French rc = 1; 1370*38c8a9a5SSteve French else if (!wait) 1371*38c8a9a5SSteve French rc = -EACCES; 1372*38c8a9a5SSteve French else { 1373*38c8a9a5SSteve French list_add_tail(&lock->blist, &conf_lock->blist); 1374*38c8a9a5SSteve French up_write(&cinode->lock_sem); 1375*38c8a9a5SSteve French rc = wait_event_interruptible(lock->block_q, 1376*38c8a9a5SSteve French (lock->blist.prev == &lock->blist) && 1377*38c8a9a5SSteve French (lock->blist.next == &lock->blist)); 1378*38c8a9a5SSteve French if (!rc) 1379*38c8a9a5SSteve French goto try_again; 1380*38c8a9a5SSteve French cifs_down_write(&cinode->lock_sem); 1381*38c8a9a5SSteve French list_del_init(&lock->blist); 1382*38c8a9a5SSteve French } 1383*38c8a9a5SSteve French 1384*38c8a9a5SSteve French up_write(&cinode->lock_sem); 1385*38c8a9a5SSteve French return rc; 1386*38c8a9a5SSteve French } 1387*38c8a9a5SSteve French 1388*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1389*38c8a9a5SSteve French /* 1390*38c8a9a5SSteve French * Check if there is another lock that prevents us to set the lock (posix 1391*38c8a9a5SSteve French * style). If such a lock exists, update the flock structure with its 1392*38c8a9a5SSteve French * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks 1393*38c8a9a5SSteve French * or leave it the same if we can't. Returns 0 if we don't need to request to 1394*38c8a9a5SSteve French * the server or 1 otherwise. 1395*38c8a9a5SSteve French */ 1396*38c8a9a5SSteve French static int 1397*38c8a9a5SSteve French cifs_posix_lock_test(struct file *file, struct file_lock *flock) 1398*38c8a9a5SSteve French { 1399*38c8a9a5SSteve French int rc = 0; 1400*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(file_inode(file)); 1401*38c8a9a5SSteve French unsigned char saved_type = flock->fl_type; 1402*38c8a9a5SSteve French 1403*38c8a9a5SSteve French if ((flock->fl_flags & FL_POSIX) == 0) 1404*38c8a9a5SSteve French return 1; 1405*38c8a9a5SSteve French 1406*38c8a9a5SSteve French down_read(&cinode->lock_sem); 1407*38c8a9a5SSteve French posix_test_lock(file, flock); 1408*38c8a9a5SSteve French 1409*38c8a9a5SSteve French if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) { 1410*38c8a9a5SSteve French flock->fl_type = saved_type; 1411*38c8a9a5SSteve French rc = 1; 1412*38c8a9a5SSteve French } 1413*38c8a9a5SSteve French 1414*38c8a9a5SSteve French up_read(&cinode->lock_sem); 1415*38c8a9a5SSteve French return rc; 1416*38c8a9a5SSteve French } 1417*38c8a9a5SSteve French 1418*38c8a9a5SSteve French /* 1419*38c8a9a5SSteve French * Set the byte-range lock (posix style). Returns: 1420*38c8a9a5SSteve French * 1) <0, if the error occurs while setting the lock; 1421*38c8a9a5SSteve French * 2) 0, if we set the lock and don't need to request to the server; 1422*38c8a9a5SSteve French * 3) FILE_LOCK_DEFERRED, if we will wait for some other file_lock; 1423*38c8a9a5SSteve French * 4) FILE_LOCK_DEFERRED + 1, if we need to request to the server. 1424*38c8a9a5SSteve French */ 1425*38c8a9a5SSteve French static int 1426*38c8a9a5SSteve French cifs_posix_lock_set(struct file *file, struct file_lock *flock) 1427*38c8a9a5SSteve French { 1428*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(file_inode(file)); 1429*38c8a9a5SSteve French int rc = FILE_LOCK_DEFERRED + 1; 1430*38c8a9a5SSteve French 1431*38c8a9a5SSteve French if ((flock->fl_flags & FL_POSIX) == 0) 1432*38c8a9a5SSteve French return rc; 1433*38c8a9a5SSteve French 1434*38c8a9a5SSteve French cifs_down_write(&cinode->lock_sem); 1435*38c8a9a5SSteve French if (!cinode->can_cache_brlcks) { 1436*38c8a9a5SSteve French up_write(&cinode->lock_sem); 1437*38c8a9a5SSteve French return rc; 1438*38c8a9a5SSteve French } 1439*38c8a9a5SSteve French 1440*38c8a9a5SSteve French rc = posix_lock_file(file, flock, NULL); 1441*38c8a9a5SSteve French up_write(&cinode->lock_sem); 1442*38c8a9a5SSteve French return rc; 1443*38c8a9a5SSteve French } 1444*38c8a9a5SSteve French 1445*38c8a9a5SSteve French int 1446*38c8a9a5SSteve French cifs_push_mandatory_locks(struct cifsFileInfo *cfile) 1447*38c8a9a5SSteve French { 1448*38c8a9a5SSteve French unsigned int xid; 1449*38c8a9a5SSteve French int rc = 0, stored_rc; 1450*38c8a9a5SSteve French struct cifsLockInfo *li, *tmp; 1451*38c8a9a5SSteve French struct cifs_tcon *tcon; 1452*38c8a9a5SSteve French unsigned int num, max_num, max_buf; 1453*38c8a9a5SSteve French LOCKING_ANDX_RANGE *buf, *cur; 1454*38c8a9a5SSteve French static const int types[] = { 1455*38c8a9a5SSteve French LOCKING_ANDX_LARGE_FILES, 1456*38c8a9a5SSteve French LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES 1457*38c8a9a5SSteve French }; 1458*38c8a9a5SSteve French int i; 1459*38c8a9a5SSteve French 1460*38c8a9a5SSteve French xid = get_xid(); 1461*38c8a9a5SSteve French tcon = tlink_tcon(cfile->tlink); 1462*38c8a9a5SSteve French 1463*38c8a9a5SSteve French /* 1464*38c8a9a5SSteve French * Accessing maxBuf is racy with cifs_reconnect - need to store value 1465*38c8a9a5SSteve French * and check it before using. 1466*38c8a9a5SSteve French */ 1467*38c8a9a5SSteve French max_buf = tcon->ses->server->maxBuf; 1468*38c8a9a5SSteve French if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) { 1469*38c8a9a5SSteve French free_xid(xid); 1470*38c8a9a5SSteve French return -EINVAL; 1471*38c8a9a5SSteve French } 1472*38c8a9a5SSteve French 1473*38c8a9a5SSteve French BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) > 1474*38c8a9a5SSteve French PAGE_SIZE); 1475*38c8a9a5SSteve French max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr), 1476*38c8a9a5SSteve French PAGE_SIZE); 1477*38c8a9a5SSteve French max_num = (max_buf - sizeof(struct smb_hdr)) / 1478*38c8a9a5SSteve French sizeof(LOCKING_ANDX_RANGE); 1479*38c8a9a5SSteve French buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL); 1480*38c8a9a5SSteve French if (!buf) { 1481*38c8a9a5SSteve French free_xid(xid); 1482*38c8a9a5SSteve French return -ENOMEM; 1483*38c8a9a5SSteve French } 1484*38c8a9a5SSteve French 1485*38c8a9a5SSteve French for (i = 0; i < 2; i++) { 1486*38c8a9a5SSteve French cur = buf; 1487*38c8a9a5SSteve French num = 0; 1488*38c8a9a5SSteve French list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) { 1489*38c8a9a5SSteve French if (li->type != types[i]) 1490*38c8a9a5SSteve French continue; 1491*38c8a9a5SSteve French cur->Pid = cpu_to_le16(li->pid); 1492*38c8a9a5SSteve French cur->LengthLow = cpu_to_le32((u32)li->length); 1493*38c8a9a5SSteve French cur->LengthHigh = cpu_to_le32((u32)(li->length>>32)); 1494*38c8a9a5SSteve French cur->OffsetLow = cpu_to_le32((u32)li->offset); 1495*38c8a9a5SSteve French cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32)); 1496*38c8a9a5SSteve French if (++num == max_num) { 1497*38c8a9a5SSteve French stored_rc = cifs_lockv(xid, tcon, 1498*38c8a9a5SSteve French cfile->fid.netfid, 1499*38c8a9a5SSteve French (__u8)li->type, 0, num, 1500*38c8a9a5SSteve French buf); 1501*38c8a9a5SSteve French if (stored_rc) 1502*38c8a9a5SSteve French rc = stored_rc; 1503*38c8a9a5SSteve French cur = buf; 1504*38c8a9a5SSteve French num = 0; 1505*38c8a9a5SSteve French } else 1506*38c8a9a5SSteve French cur++; 1507*38c8a9a5SSteve French } 1508*38c8a9a5SSteve French 1509*38c8a9a5SSteve French if (num) { 1510*38c8a9a5SSteve French stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid, 1511*38c8a9a5SSteve French (__u8)types[i], 0, num, buf); 1512*38c8a9a5SSteve French if (stored_rc) 1513*38c8a9a5SSteve French rc = stored_rc; 1514*38c8a9a5SSteve French } 1515*38c8a9a5SSteve French } 1516*38c8a9a5SSteve French 1517*38c8a9a5SSteve French kfree(buf); 1518*38c8a9a5SSteve French free_xid(xid); 1519*38c8a9a5SSteve French return rc; 1520*38c8a9a5SSteve French } 1521*38c8a9a5SSteve French 1522*38c8a9a5SSteve French static __u32 1523*38c8a9a5SSteve French hash_lockowner(fl_owner_t owner) 1524*38c8a9a5SSteve French { 1525*38c8a9a5SSteve French return cifs_lock_secret ^ hash32_ptr((const void *)owner); 1526*38c8a9a5SSteve French } 1527*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1528*38c8a9a5SSteve French 1529*38c8a9a5SSteve French struct lock_to_push { 1530*38c8a9a5SSteve French struct list_head llist; 1531*38c8a9a5SSteve French __u64 offset; 1532*38c8a9a5SSteve French __u64 length; 1533*38c8a9a5SSteve French __u32 pid; 1534*38c8a9a5SSteve French __u16 netfid; 1535*38c8a9a5SSteve French __u8 type; 1536*38c8a9a5SSteve French }; 1537*38c8a9a5SSteve French 1538*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1539*38c8a9a5SSteve French static int 1540*38c8a9a5SSteve French cifs_push_posix_locks(struct cifsFileInfo *cfile) 1541*38c8a9a5SSteve French { 1542*38c8a9a5SSteve French struct inode *inode = d_inode(cfile->dentry); 1543*38c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1544*38c8a9a5SSteve French struct file_lock *flock; 1545*38c8a9a5SSteve French struct file_lock_context *flctx = locks_inode_context(inode); 1546*38c8a9a5SSteve French unsigned int count = 0, i; 1547*38c8a9a5SSteve French int rc = 0, xid, type; 1548*38c8a9a5SSteve French struct list_head locks_to_send, *el; 1549*38c8a9a5SSteve French struct lock_to_push *lck, *tmp; 1550*38c8a9a5SSteve French __u64 length; 1551*38c8a9a5SSteve French 1552*38c8a9a5SSteve French xid = get_xid(); 1553*38c8a9a5SSteve French 1554*38c8a9a5SSteve French if (!flctx) 1555*38c8a9a5SSteve French goto out; 1556*38c8a9a5SSteve French 1557*38c8a9a5SSteve French spin_lock(&flctx->flc_lock); 1558*38c8a9a5SSteve French list_for_each(el, &flctx->flc_posix) { 1559*38c8a9a5SSteve French count++; 1560*38c8a9a5SSteve French } 1561*38c8a9a5SSteve French spin_unlock(&flctx->flc_lock); 1562*38c8a9a5SSteve French 1563*38c8a9a5SSteve French INIT_LIST_HEAD(&locks_to_send); 1564*38c8a9a5SSteve French 1565*38c8a9a5SSteve French /* 1566*38c8a9a5SSteve French * Allocating count locks is enough because no FL_POSIX locks can be 1567*38c8a9a5SSteve French * added to the list while we are holding cinode->lock_sem that 1568*38c8a9a5SSteve French * protects locking operations of this inode. 1569*38c8a9a5SSteve French */ 1570*38c8a9a5SSteve French for (i = 0; i < count; i++) { 1571*38c8a9a5SSteve French lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL); 1572*38c8a9a5SSteve French if (!lck) { 1573*38c8a9a5SSteve French rc = -ENOMEM; 1574*38c8a9a5SSteve French goto err_out; 1575*38c8a9a5SSteve French } 1576*38c8a9a5SSteve French list_add_tail(&lck->llist, &locks_to_send); 1577*38c8a9a5SSteve French } 1578*38c8a9a5SSteve French 1579*38c8a9a5SSteve French el = locks_to_send.next; 1580*38c8a9a5SSteve French spin_lock(&flctx->flc_lock); 1581*38c8a9a5SSteve French list_for_each_entry(flock, &flctx->flc_posix, fl_list) { 1582*38c8a9a5SSteve French if (el == &locks_to_send) { 1583*38c8a9a5SSteve French /* 1584*38c8a9a5SSteve French * The list ended. We don't have enough allocated 1585*38c8a9a5SSteve French * structures - something is really wrong. 1586*38c8a9a5SSteve French */ 1587*38c8a9a5SSteve French cifs_dbg(VFS, "Can't push all brlocks!\n"); 1588*38c8a9a5SSteve French break; 1589*38c8a9a5SSteve French } 1590*38c8a9a5SSteve French length = cifs_flock_len(flock); 1591*38c8a9a5SSteve French if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK) 1592*38c8a9a5SSteve French type = CIFS_RDLCK; 1593*38c8a9a5SSteve French else 1594*38c8a9a5SSteve French type = CIFS_WRLCK; 1595*38c8a9a5SSteve French lck = list_entry(el, struct lock_to_push, llist); 1596*38c8a9a5SSteve French lck->pid = hash_lockowner(flock->fl_owner); 1597*38c8a9a5SSteve French lck->netfid = cfile->fid.netfid; 1598*38c8a9a5SSteve French lck->length = length; 1599*38c8a9a5SSteve French lck->type = type; 1600*38c8a9a5SSteve French lck->offset = flock->fl_start; 1601*38c8a9a5SSteve French } 1602*38c8a9a5SSteve French spin_unlock(&flctx->flc_lock); 1603*38c8a9a5SSteve French 1604*38c8a9a5SSteve French list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) { 1605*38c8a9a5SSteve French int stored_rc; 1606*38c8a9a5SSteve French 1607*38c8a9a5SSteve French stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid, 1608*38c8a9a5SSteve French lck->offset, lck->length, NULL, 1609*38c8a9a5SSteve French lck->type, 0); 1610*38c8a9a5SSteve French if (stored_rc) 1611*38c8a9a5SSteve French rc = stored_rc; 1612*38c8a9a5SSteve French list_del(&lck->llist); 1613*38c8a9a5SSteve French kfree(lck); 1614*38c8a9a5SSteve French } 1615*38c8a9a5SSteve French 1616*38c8a9a5SSteve French out: 1617*38c8a9a5SSteve French free_xid(xid); 1618*38c8a9a5SSteve French return rc; 1619*38c8a9a5SSteve French err_out: 1620*38c8a9a5SSteve French list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) { 1621*38c8a9a5SSteve French list_del(&lck->llist); 1622*38c8a9a5SSteve French kfree(lck); 1623*38c8a9a5SSteve French } 1624*38c8a9a5SSteve French goto out; 1625*38c8a9a5SSteve French } 1626*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1627*38c8a9a5SSteve French 1628*38c8a9a5SSteve French static int 1629*38c8a9a5SSteve French cifs_push_locks(struct cifsFileInfo *cfile) 1630*38c8a9a5SSteve French { 1631*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1632*38c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1633*38c8a9a5SSteve French int rc = 0; 1634*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1635*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb); 1636*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1637*38c8a9a5SSteve French 1638*38c8a9a5SSteve French /* we are going to update can_cache_brlcks here - need a write access */ 1639*38c8a9a5SSteve French cifs_down_write(&cinode->lock_sem); 1640*38c8a9a5SSteve French if (!cinode->can_cache_brlcks) { 1641*38c8a9a5SSteve French up_write(&cinode->lock_sem); 1642*38c8a9a5SSteve French return rc; 1643*38c8a9a5SSteve French } 1644*38c8a9a5SSteve French 1645*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1646*38c8a9a5SSteve French if (cap_unix(tcon->ses) && 1647*38c8a9a5SSteve French (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) && 1648*38c8a9a5SSteve French ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) 1649*38c8a9a5SSteve French rc = cifs_push_posix_locks(cfile); 1650*38c8a9a5SSteve French else 1651*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1652*38c8a9a5SSteve French rc = tcon->ses->server->ops->push_mand_locks(cfile); 1653*38c8a9a5SSteve French 1654*38c8a9a5SSteve French cinode->can_cache_brlcks = false; 1655*38c8a9a5SSteve French up_write(&cinode->lock_sem); 1656*38c8a9a5SSteve French return rc; 1657*38c8a9a5SSteve French } 1658*38c8a9a5SSteve French 1659*38c8a9a5SSteve French static void 1660*38c8a9a5SSteve French cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock, 1661*38c8a9a5SSteve French bool *wait_flag, struct TCP_Server_Info *server) 1662*38c8a9a5SSteve French { 1663*38c8a9a5SSteve French if (flock->fl_flags & FL_POSIX) 1664*38c8a9a5SSteve French cifs_dbg(FYI, "Posix\n"); 1665*38c8a9a5SSteve French if (flock->fl_flags & FL_FLOCK) 1666*38c8a9a5SSteve French cifs_dbg(FYI, "Flock\n"); 1667*38c8a9a5SSteve French if (flock->fl_flags & FL_SLEEP) { 1668*38c8a9a5SSteve French cifs_dbg(FYI, "Blocking lock\n"); 1669*38c8a9a5SSteve French *wait_flag = true; 1670*38c8a9a5SSteve French } 1671*38c8a9a5SSteve French if (flock->fl_flags & FL_ACCESS) 1672*38c8a9a5SSteve French cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n"); 1673*38c8a9a5SSteve French if (flock->fl_flags & FL_LEASE) 1674*38c8a9a5SSteve French cifs_dbg(FYI, "Lease on file - not implemented yet\n"); 1675*38c8a9a5SSteve French if (flock->fl_flags & 1676*38c8a9a5SSteve French (~(FL_POSIX | FL_FLOCK | FL_SLEEP | 1677*38c8a9a5SSteve French FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK))) 1678*38c8a9a5SSteve French cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags); 1679*38c8a9a5SSteve French 1680*38c8a9a5SSteve French *type = server->vals->large_lock_type; 1681*38c8a9a5SSteve French if (flock->fl_type == F_WRLCK) { 1682*38c8a9a5SSteve French cifs_dbg(FYI, "F_WRLCK\n"); 1683*38c8a9a5SSteve French *type |= server->vals->exclusive_lock_type; 1684*38c8a9a5SSteve French *lock = 1; 1685*38c8a9a5SSteve French } else if (flock->fl_type == F_UNLCK) { 1686*38c8a9a5SSteve French cifs_dbg(FYI, "F_UNLCK\n"); 1687*38c8a9a5SSteve French *type |= server->vals->unlock_lock_type; 1688*38c8a9a5SSteve French *unlock = 1; 1689*38c8a9a5SSteve French /* Check if unlock includes more than one lock range */ 1690*38c8a9a5SSteve French } else if (flock->fl_type == F_RDLCK) { 1691*38c8a9a5SSteve French cifs_dbg(FYI, "F_RDLCK\n"); 1692*38c8a9a5SSteve French *type |= server->vals->shared_lock_type; 1693*38c8a9a5SSteve French *lock = 1; 1694*38c8a9a5SSteve French } else if (flock->fl_type == F_EXLCK) { 1695*38c8a9a5SSteve French cifs_dbg(FYI, "F_EXLCK\n"); 1696*38c8a9a5SSteve French *type |= server->vals->exclusive_lock_type; 1697*38c8a9a5SSteve French *lock = 1; 1698*38c8a9a5SSteve French } else if (flock->fl_type == F_SHLCK) { 1699*38c8a9a5SSteve French cifs_dbg(FYI, "F_SHLCK\n"); 1700*38c8a9a5SSteve French *type |= server->vals->shared_lock_type; 1701*38c8a9a5SSteve French *lock = 1; 1702*38c8a9a5SSteve French } else 1703*38c8a9a5SSteve French cifs_dbg(FYI, "Unknown type of lock\n"); 1704*38c8a9a5SSteve French } 1705*38c8a9a5SSteve French 1706*38c8a9a5SSteve French static int 1707*38c8a9a5SSteve French cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, 1708*38c8a9a5SSteve French bool wait_flag, bool posix_lck, unsigned int xid) 1709*38c8a9a5SSteve French { 1710*38c8a9a5SSteve French int rc = 0; 1711*38c8a9a5SSteve French __u64 length = cifs_flock_len(flock); 1712*38c8a9a5SSteve French struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data; 1713*38c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1714*38c8a9a5SSteve French struct TCP_Server_Info *server = tcon->ses->server; 1715*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1716*38c8a9a5SSteve French __u16 netfid = cfile->fid.netfid; 1717*38c8a9a5SSteve French 1718*38c8a9a5SSteve French if (posix_lck) { 1719*38c8a9a5SSteve French int posix_lock_type; 1720*38c8a9a5SSteve French 1721*38c8a9a5SSteve French rc = cifs_posix_lock_test(file, flock); 1722*38c8a9a5SSteve French if (!rc) 1723*38c8a9a5SSteve French return rc; 1724*38c8a9a5SSteve French 1725*38c8a9a5SSteve French if (type & server->vals->shared_lock_type) 1726*38c8a9a5SSteve French posix_lock_type = CIFS_RDLCK; 1727*38c8a9a5SSteve French else 1728*38c8a9a5SSteve French posix_lock_type = CIFS_WRLCK; 1729*38c8a9a5SSteve French rc = CIFSSMBPosixLock(xid, tcon, netfid, 1730*38c8a9a5SSteve French hash_lockowner(flock->fl_owner), 1731*38c8a9a5SSteve French flock->fl_start, length, flock, 1732*38c8a9a5SSteve French posix_lock_type, wait_flag); 1733*38c8a9a5SSteve French return rc; 1734*38c8a9a5SSteve French } 1735*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1736*38c8a9a5SSteve French 1737*38c8a9a5SSteve French rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock); 1738*38c8a9a5SSteve French if (!rc) 1739*38c8a9a5SSteve French return rc; 1740*38c8a9a5SSteve French 1741*38c8a9a5SSteve French /* BB we could chain these into one lock request BB */ 1742*38c8a9a5SSteve French rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type, 1743*38c8a9a5SSteve French 1, 0, false); 1744*38c8a9a5SSteve French if (rc == 0) { 1745*38c8a9a5SSteve French rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, 1746*38c8a9a5SSteve French type, 0, 1, false); 1747*38c8a9a5SSteve French flock->fl_type = F_UNLCK; 1748*38c8a9a5SSteve French if (rc != 0) 1749*38c8a9a5SSteve French cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n", 1750*38c8a9a5SSteve French rc); 1751*38c8a9a5SSteve French return 0; 1752*38c8a9a5SSteve French } 1753*38c8a9a5SSteve French 1754*38c8a9a5SSteve French if (type & server->vals->shared_lock_type) { 1755*38c8a9a5SSteve French flock->fl_type = F_WRLCK; 1756*38c8a9a5SSteve French return 0; 1757*38c8a9a5SSteve French } 1758*38c8a9a5SSteve French 1759*38c8a9a5SSteve French type &= ~server->vals->exclusive_lock_type; 1760*38c8a9a5SSteve French 1761*38c8a9a5SSteve French rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, 1762*38c8a9a5SSteve French type | server->vals->shared_lock_type, 1763*38c8a9a5SSteve French 1, 0, false); 1764*38c8a9a5SSteve French if (rc == 0) { 1765*38c8a9a5SSteve French rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, 1766*38c8a9a5SSteve French type | server->vals->shared_lock_type, 0, 1, false); 1767*38c8a9a5SSteve French flock->fl_type = F_RDLCK; 1768*38c8a9a5SSteve French if (rc != 0) 1769*38c8a9a5SSteve French cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n", 1770*38c8a9a5SSteve French rc); 1771*38c8a9a5SSteve French } else 1772*38c8a9a5SSteve French flock->fl_type = F_WRLCK; 1773*38c8a9a5SSteve French 1774*38c8a9a5SSteve French return 0; 1775*38c8a9a5SSteve French } 1776*38c8a9a5SSteve French 1777*38c8a9a5SSteve French void 1778*38c8a9a5SSteve French cifs_move_llist(struct list_head *source, struct list_head *dest) 1779*38c8a9a5SSteve French { 1780*38c8a9a5SSteve French struct list_head *li, *tmp; 1781*38c8a9a5SSteve French list_for_each_safe(li, tmp, source) 1782*38c8a9a5SSteve French list_move(li, dest); 1783*38c8a9a5SSteve French } 1784*38c8a9a5SSteve French 1785*38c8a9a5SSteve French void 1786*38c8a9a5SSteve French cifs_free_llist(struct list_head *llist) 1787*38c8a9a5SSteve French { 1788*38c8a9a5SSteve French struct cifsLockInfo *li, *tmp; 1789*38c8a9a5SSteve French list_for_each_entry_safe(li, tmp, llist, llist) { 1790*38c8a9a5SSteve French cifs_del_lock_waiters(li); 1791*38c8a9a5SSteve French list_del(&li->llist); 1792*38c8a9a5SSteve French kfree(li); 1793*38c8a9a5SSteve French } 1794*38c8a9a5SSteve French } 1795*38c8a9a5SSteve French 1796*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1797*38c8a9a5SSteve French int 1798*38c8a9a5SSteve French cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, 1799*38c8a9a5SSteve French unsigned int xid) 1800*38c8a9a5SSteve French { 1801*38c8a9a5SSteve French int rc = 0, stored_rc; 1802*38c8a9a5SSteve French static const int types[] = { 1803*38c8a9a5SSteve French LOCKING_ANDX_LARGE_FILES, 1804*38c8a9a5SSteve French LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES 1805*38c8a9a5SSteve French }; 1806*38c8a9a5SSteve French unsigned int i; 1807*38c8a9a5SSteve French unsigned int max_num, num, max_buf; 1808*38c8a9a5SSteve French LOCKING_ANDX_RANGE *buf, *cur; 1809*38c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1810*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1811*38c8a9a5SSteve French struct cifsLockInfo *li, *tmp; 1812*38c8a9a5SSteve French __u64 length = cifs_flock_len(flock); 1813*38c8a9a5SSteve French struct list_head tmp_llist; 1814*38c8a9a5SSteve French 1815*38c8a9a5SSteve French INIT_LIST_HEAD(&tmp_llist); 1816*38c8a9a5SSteve French 1817*38c8a9a5SSteve French /* 1818*38c8a9a5SSteve French * Accessing maxBuf is racy with cifs_reconnect - need to store value 1819*38c8a9a5SSteve French * and check it before using. 1820*38c8a9a5SSteve French */ 1821*38c8a9a5SSteve French max_buf = tcon->ses->server->maxBuf; 1822*38c8a9a5SSteve French if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) 1823*38c8a9a5SSteve French return -EINVAL; 1824*38c8a9a5SSteve French 1825*38c8a9a5SSteve French BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) > 1826*38c8a9a5SSteve French PAGE_SIZE); 1827*38c8a9a5SSteve French max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr), 1828*38c8a9a5SSteve French PAGE_SIZE); 1829*38c8a9a5SSteve French max_num = (max_buf - sizeof(struct smb_hdr)) / 1830*38c8a9a5SSteve French sizeof(LOCKING_ANDX_RANGE); 1831*38c8a9a5SSteve French buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL); 1832*38c8a9a5SSteve French if (!buf) 1833*38c8a9a5SSteve French return -ENOMEM; 1834*38c8a9a5SSteve French 1835*38c8a9a5SSteve French cifs_down_write(&cinode->lock_sem); 1836*38c8a9a5SSteve French for (i = 0; i < 2; i++) { 1837*38c8a9a5SSteve French cur = buf; 1838*38c8a9a5SSteve French num = 0; 1839*38c8a9a5SSteve French list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) { 1840*38c8a9a5SSteve French if (flock->fl_start > li->offset || 1841*38c8a9a5SSteve French (flock->fl_start + length) < 1842*38c8a9a5SSteve French (li->offset + li->length)) 1843*38c8a9a5SSteve French continue; 1844*38c8a9a5SSteve French if (current->tgid != li->pid) 1845*38c8a9a5SSteve French continue; 1846*38c8a9a5SSteve French if (types[i] != li->type) 1847*38c8a9a5SSteve French continue; 1848*38c8a9a5SSteve French if (cinode->can_cache_brlcks) { 1849*38c8a9a5SSteve French /* 1850*38c8a9a5SSteve French * We can cache brlock requests - simply remove 1851*38c8a9a5SSteve French * a lock from the file's list. 1852*38c8a9a5SSteve French */ 1853*38c8a9a5SSteve French list_del(&li->llist); 1854*38c8a9a5SSteve French cifs_del_lock_waiters(li); 1855*38c8a9a5SSteve French kfree(li); 1856*38c8a9a5SSteve French continue; 1857*38c8a9a5SSteve French } 1858*38c8a9a5SSteve French cur->Pid = cpu_to_le16(li->pid); 1859*38c8a9a5SSteve French cur->LengthLow = cpu_to_le32((u32)li->length); 1860*38c8a9a5SSteve French cur->LengthHigh = cpu_to_le32((u32)(li->length>>32)); 1861*38c8a9a5SSteve French cur->OffsetLow = cpu_to_le32((u32)li->offset); 1862*38c8a9a5SSteve French cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32)); 1863*38c8a9a5SSteve French /* 1864*38c8a9a5SSteve French * We need to save a lock here to let us add it again to 1865*38c8a9a5SSteve French * the file's list if the unlock range request fails on 1866*38c8a9a5SSteve French * the server. 1867*38c8a9a5SSteve French */ 1868*38c8a9a5SSteve French list_move(&li->llist, &tmp_llist); 1869*38c8a9a5SSteve French if (++num == max_num) { 1870*38c8a9a5SSteve French stored_rc = cifs_lockv(xid, tcon, 1871*38c8a9a5SSteve French cfile->fid.netfid, 1872*38c8a9a5SSteve French li->type, num, 0, buf); 1873*38c8a9a5SSteve French if (stored_rc) { 1874*38c8a9a5SSteve French /* 1875*38c8a9a5SSteve French * We failed on the unlock range 1876*38c8a9a5SSteve French * request - add all locks from the tmp 1877*38c8a9a5SSteve French * list to the head of the file's list. 1878*38c8a9a5SSteve French */ 1879*38c8a9a5SSteve French cifs_move_llist(&tmp_llist, 1880*38c8a9a5SSteve French &cfile->llist->locks); 1881*38c8a9a5SSteve French rc = stored_rc; 1882*38c8a9a5SSteve French } else 1883*38c8a9a5SSteve French /* 1884*38c8a9a5SSteve French * The unlock range request succeed - 1885*38c8a9a5SSteve French * free the tmp list. 1886*38c8a9a5SSteve French */ 1887*38c8a9a5SSteve French cifs_free_llist(&tmp_llist); 1888*38c8a9a5SSteve French cur = buf; 1889*38c8a9a5SSteve French num = 0; 1890*38c8a9a5SSteve French } else 1891*38c8a9a5SSteve French cur++; 1892*38c8a9a5SSteve French } 1893*38c8a9a5SSteve French if (num) { 1894*38c8a9a5SSteve French stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid, 1895*38c8a9a5SSteve French types[i], num, 0, buf); 1896*38c8a9a5SSteve French if (stored_rc) { 1897*38c8a9a5SSteve French cifs_move_llist(&tmp_llist, 1898*38c8a9a5SSteve French &cfile->llist->locks); 1899*38c8a9a5SSteve French rc = stored_rc; 1900*38c8a9a5SSteve French } else 1901*38c8a9a5SSteve French cifs_free_llist(&tmp_llist); 1902*38c8a9a5SSteve French } 1903*38c8a9a5SSteve French } 1904*38c8a9a5SSteve French 1905*38c8a9a5SSteve French up_write(&cinode->lock_sem); 1906*38c8a9a5SSteve French kfree(buf); 1907*38c8a9a5SSteve French return rc; 1908*38c8a9a5SSteve French } 1909*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1910*38c8a9a5SSteve French 1911*38c8a9a5SSteve French static int 1912*38c8a9a5SSteve French cifs_setlk(struct file *file, struct file_lock *flock, __u32 type, 1913*38c8a9a5SSteve French bool wait_flag, bool posix_lck, int lock, int unlock, 1914*38c8a9a5SSteve French unsigned int xid) 1915*38c8a9a5SSteve French { 1916*38c8a9a5SSteve French int rc = 0; 1917*38c8a9a5SSteve French __u64 length = cifs_flock_len(flock); 1918*38c8a9a5SSteve French struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data; 1919*38c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1920*38c8a9a5SSteve French struct TCP_Server_Info *server = tcon->ses->server; 1921*38c8a9a5SSteve French struct inode *inode = d_inode(cfile->dentry); 1922*38c8a9a5SSteve French 1923*38c8a9a5SSteve French #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1924*38c8a9a5SSteve French if (posix_lck) { 1925*38c8a9a5SSteve French int posix_lock_type; 1926*38c8a9a5SSteve French 1927*38c8a9a5SSteve French rc = cifs_posix_lock_set(file, flock); 1928*38c8a9a5SSteve French if (rc <= FILE_LOCK_DEFERRED) 1929*38c8a9a5SSteve French return rc; 1930*38c8a9a5SSteve French 1931*38c8a9a5SSteve French if (type & server->vals->shared_lock_type) 1932*38c8a9a5SSteve French posix_lock_type = CIFS_RDLCK; 1933*38c8a9a5SSteve French else 1934*38c8a9a5SSteve French posix_lock_type = CIFS_WRLCK; 1935*38c8a9a5SSteve French 1936*38c8a9a5SSteve French if (unlock == 1) 1937*38c8a9a5SSteve French posix_lock_type = CIFS_UNLCK; 1938*38c8a9a5SSteve French 1939*38c8a9a5SSteve French rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid, 1940*38c8a9a5SSteve French hash_lockowner(flock->fl_owner), 1941*38c8a9a5SSteve French flock->fl_start, length, 1942*38c8a9a5SSteve French NULL, posix_lock_type, wait_flag); 1943*38c8a9a5SSteve French goto out; 1944*38c8a9a5SSteve French } 1945*38c8a9a5SSteve French #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1946*38c8a9a5SSteve French if (lock) { 1947*38c8a9a5SSteve French struct cifsLockInfo *lock; 1948*38c8a9a5SSteve French 1949*38c8a9a5SSteve French lock = cifs_lock_init(flock->fl_start, length, type, 1950*38c8a9a5SSteve French flock->fl_flags); 1951*38c8a9a5SSteve French if (!lock) 1952*38c8a9a5SSteve French return -ENOMEM; 1953*38c8a9a5SSteve French 1954*38c8a9a5SSteve French rc = cifs_lock_add_if(cfile, lock, wait_flag); 1955*38c8a9a5SSteve French if (rc < 0) { 1956*38c8a9a5SSteve French kfree(lock); 1957*38c8a9a5SSteve French return rc; 1958*38c8a9a5SSteve French } 1959*38c8a9a5SSteve French if (!rc) 1960*38c8a9a5SSteve French goto out; 1961*38c8a9a5SSteve French 1962*38c8a9a5SSteve French /* 1963*38c8a9a5SSteve French * Windows 7 server can delay breaking lease from read to None 1964*38c8a9a5SSteve French * if we set a byte-range lock on a file - break it explicitly 1965*38c8a9a5SSteve French * before sending the lock to the server to be sure the next 1966*38c8a9a5SSteve French * read won't conflict with non-overlapted locks due to 1967*38c8a9a5SSteve French * pagereading. 1968*38c8a9a5SSteve French */ 1969*38c8a9a5SSteve French if (!CIFS_CACHE_WRITE(CIFS_I(inode)) && 1970*38c8a9a5SSteve French CIFS_CACHE_READ(CIFS_I(inode))) { 1971*38c8a9a5SSteve French cifs_zap_mapping(inode); 1972*38c8a9a5SSteve French cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n", 1973*38c8a9a5SSteve French inode); 1974*38c8a9a5SSteve French CIFS_I(inode)->oplock = 0; 1975*38c8a9a5SSteve French } 1976*38c8a9a5SSteve French 1977*38c8a9a5SSteve French rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, 1978*38c8a9a5SSteve French type, 1, 0, wait_flag); 1979*38c8a9a5SSteve French if (rc) { 1980*38c8a9a5SSteve French kfree(lock); 1981*38c8a9a5SSteve French return rc; 1982*38c8a9a5SSteve French } 1983*38c8a9a5SSteve French 1984*38c8a9a5SSteve French cifs_lock_add(cfile, lock); 1985*38c8a9a5SSteve French } else if (unlock) 1986*38c8a9a5SSteve French rc = server->ops->mand_unlock_range(cfile, flock, xid); 1987*38c8a9a5SSteve French 1988*38c8a9a5SSteve French out: 1989*38c8a9a5SSteve French if ((flock->fl_flags & FL_POSIX) || (flock->fl_flags & FL_FLOCK)) { 1990*38c8a9a5SSteve French /* 1991*38c8a9a5SSteve French * If this is a request to remove all locks because we 1992*38c8a9a5SSteve French * are closing the file, it doesn't matter if the 1993*38c8a9a5SSteve French * unlocking failed as both cifs.ko and the SMB server 1994*38c8a9a5SSteve French * remove the lock on file close 1995*38c8a9a5SSteve French */ 1996*38c8a9a5SSteve French if (rc) { 1997*38c8a9a5SSteve French cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc); 1998*38c8a9a5SSteve French if (!(flock->fl_flags & FL_CLOSE)) 1999*38c8a9a5SSteve French return rc; 2000*38c8a9a5SSteve French } 2001*38c8a9a5SSteve French rc = locks_lock_file_wait(file, flock); 2002*38c8a9a5SSteve French } 2003*38c8a9a5SSteve French return rc; 2004*38c8a9a5SSteve French } 2005*38c8a9a5SSteve French 2006*38c8a9a5SSteve French int cifs_flock(struct file *file, int cmd, struct file_lock *fl) 2007*38c8a9a5SSteve French { 2008*38c8a9a5SSteve French int rc, xid; 2009*38c8a9a5SSteve French int lock = 0, unlock = 0; 2010*38c8a9a5SSteve French bool wait_flag = false; 2011*38c8a9a5SSteve French bool posix_lck = false; 2012*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb; 2013*38c8a9a5SSteve French struct cifs_tcon *tcon; 2014*38c8a9a5SSteve French struct cifsFileInfo *cfile; 2015*38c8a9a5SSteve French __u32 type; 2016*38c8a9a5SSteve French 2017*38c8a9a5SSteve French xid = get_xid(); 2018*38c8a9a5SSteve French 2019*38c8a9a5SSteve French if (!(fl->fl_flags & FL_FLOCK)) { 2020*38c8a9a5SSteve French rc = -ENOLCK; 2021*38c8a9a5SSteve French free_xid(xid); 2022*38c8a9a5SSteve French return rc; 2023*38c8a9a5SSteve French } 2024*38c8a9a5SSteve French 2025*38c8a9a5SSteve French cfile = (struct cifsFileInfo *)file->private_data; 2026*38c8a9a5SSteve French tcon = tlink_tcon(cfile->tlink); 2027*38c8a9a5SSteve French 2028*38c8a9a5SSteve French cifs_read_flock(fl, &type, &lock, &unlock, &wait_flag, 2029*38c8a9a5SSteve French tcon->ses->server); 2030*38c8a9a5SSteve French cifs_sb = CIFS_FILE_SB(file); 2031*38c8a9a5SSteve French 2032*38c8a9a5SSteve French if (cap_unix(tcon->ses) && 2033*38c8a9a5SSteve French (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) && 2034*38c8a9a5SSteve French ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) 2035*38c8a9a5SSteve French posix_lck = true; 2036*38c8a9a5SSteve French 2037*38c8a9a5SSteve French if (!lock && !unlock) { 2038*38c8a9a5SSteve French /* 2039*38c8a9a5SSteve French * if no lock or unlock then nothing to do since we do not 2040*38c8a9a5SSteve French * know what it is 2041*38c8a9a5SSteve French */ 2042*38c8a9a5SSteve French rc = -EOPNOTSUPP; 2043*38c8a9a5SSteve French free_xid(xid); 2044*38c8a9a5SSteve French return rc; 2045*38c8a9a5SSteve French } 2046*38c8a9a5SSteve French 2047*38c8a9a5SSteve French rc = cifs_setlk(file, fl, type, wait_flag, posix_lck, lock, unlock, 2048*38c8a9a5SSteve French xid); 2049*38c8a9a5SSteve French free_xid(xid); 2050*38c8a9a5SSteve French return rc; 2051*38c8a9a5SSteve French 2052*38c8a9a5SSteve French 2053*38c8a9a5SSteve French } 2054*38c8a9a5SSteve French 2055*38c8a9a5SSteve French int cifs_lock(struct file *file, int cmd, struct file_lock *flock) 2056*38c8a9a5SSteve French { 2057*38c8a9a5SSteve French int rc, xid; 2058*38c8a9a5SSteve French int lock = 0, unlock = 0; 2059*38c8a9a5SSteve French bool wait_flag = false; 2060*38c8a9a5SSteve French bool posix_lck = false; 2061*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb; 2062*38c8a9a5SSteve French struct cifs_tcon *tcon; 2063*38c8a9a5SSteve French struct cifsFileInfo *cfile; 2064*38c8a9a5SSteve French __u32 type; 2065*38c8a9a5SSteve French 2066*38c8a9a5SSteve French rc = -EACCES; 2067*38c8a9a5SSteve French xid = get_xid(); 2068*38c8a9a5SSteve French 2069*38c8a9a5SSteve French cifs_dbg(FYI, "%s: %pD2 cmd=0x%x type=0x%x flags=0x%x r=%lld:%lld\n", __func__, file, cmd, 2070*38c8a9a5SSteve French flock->fl_flags, flock->fl_type, (long long)flock->fl_start, 2071*38c8a9a5SSteve French (long long)flock->fl_end); 2072*38c8a9a5SSteve French 2073*38c8a9a5SSteve French cfile = (struct cifsFileInfo *)file->private_data; 2074*38c8a9a5SSteve French tcon = tlink_tcon(cfile->tlink); 2075*38c8a9a5SSteve French 2076*38c8a9a5SSteve French cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag, 2077*38c8a9a5SSteve French tcon->ses->server); 2078*38c8a9a5SSteve French cifs_sb = CIFS_FILE_SB(file); 2079*38c8a9a5SSteve French set_bit(CIFS_INO_CLOSE_ON_LOCK, &CIFS_I(d_inode(cfile->dentry))->flags); 2080*38c8a9a5SSteve French 2081*38c8a9a5SSteve French if (cap_unix(tcon->ses) && 2082*38c8a9a5SSteve French (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) && 2083*38c8a9a5SSteve French ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) 2084*38c8a9a5SSteve French posix_lck = true; 2085*38c8a9a5SSteve French /* 2086*38c8a9a5SSteve French * BB add code here to normalize offset and length to account for 2087*38c8a9a5SSteve French * negative length which we can not accept over the wire. 2088*38c8a9a5SSteve French */ 2089*38c8a9a5SSteve French if (IS_GETLK(cmd)) { 2090*38c8a9a5SSteve French rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid); 2091*38c8a9a5SSteve French free_xid(xid); 2092*38c8a9a5SSteve French return rc; 2093*38c8a9a5SSteve French } 2094*38c8a9a5SSteve French 2095*38c8a9a5SSteve French if (!lock && !unlock) { 2096*38c8a9a5SSteve French /* 2097*38c8a9a5SSteve French * if no lock or unlock then nothing to do since we do not 2098*38c8a9a5SSteve French * know what it is 2099*38c8a9a5SSteve French */ 2100*38c8a9a5SSteve French free_xid(xid); 2101*38c8a9a5SSteve French return -EOPNOTSUPP; 2102*38c8a9a5SSteve French } 2103*38c8a9a5SSteve French 2104*38c8a9a5SSteve French rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock, 2105*38c8a9a5SSteve French xid); 2106*38c8a9a5SSteve French free_xid(xid); 2107*38c8a9a5SSteve French return rc; 2108*38c8a9a5SSteve French } 2109*38c8a9a5SSteve French 2110*38c8a9a5SSteve French /* 2111*38c8a9a5SSteve French * update the file size (if needed) after a write. Should be called with 2112*38c8a9a5SSteve French * the inode->i_lock held 2113*38c8a9a5SSteve French */ 2114*38c8a9a5SSteve French void 2115*38c8a9a5SSteve French cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset, 2116*38c8a9a5SSteve French unsigned int bytes_written) 2117*38c8a9a5SSteve French { 2118*38c8a9a5SSteve French loff_t end_of_write = offset + bytes_written; 2119*38c8a9a5SSteve French 2120*38c8a9a5SSteve French if (end_of_write > cifsi->server_eof) 2121*38c8a9a5SSteve French cifsi->server_eof = end_of_write; 2122*38c8a9a5SSteve French } 2123*38c8a9a5SSteve French 2124*38c8a9a5SSteve French static ssize_t 2125*38c8a9a5SSteve French cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data, 2126*38c8a9a5SSteve French size_t write_size, loff_t *offset) 2127*38c8a9a5SSteve French { 2128*38c8a9a5SSteve French int rc = 0; 2129*38c8a9a5SSteve French unsigned int bytes_written = 0; 2130*38c8a9a5SSteve French unsigned int total_written; 2131*38c8a9a5SSteve French struct cifs_tcon *tcon; 2132*38c8a9a5SSteve French struct TCP_Server_Info *server; 2133*38c8a9a5SSteve French unsigned int xid; 2134*38c8a9a5SSteve French struct dentry *dentry = open_file->dentry; 2135*38c8a9a5SSteve French struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry)); 2136*38c8a9a5SSteve French struct cifs_io_parms io_parms = {0}; 2137*38c8a9a5SSteve French 2138*38c8a9a5SSteve French cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n", 2139*38c8a9a5SSteve French write_size, *offset, dentry); 2140*38c8a9a5SSteve French 2141*38c8a9a5SSteve French tcon = tlink_tcon(open_file->tlink); 2142*38c8a9a5SSteve French server = tcon->ses->server; 2143*38c8a9a5SSteve French 2144*38c8a9a5SSteve French if (!server->ops->sync_write) 2145*38c8a9a5SSteve French return -ENOSYS; 2146*38c8a9a5SSteve French 2147*38c8a9a5SSteve French xid = get_xid(); 2148*38c8a9a5SSteve French 2149*38c8a9a5SSteve French for (total_written = 0; write_size > total_written; 2150*38c8a9a5SSteve French total_written += bytes_written) { 2151*38c8a9a5SSteve French rc = -EAGAIN; 2152*38c8a9a5SSteve French while (rc == -EAGAIN) { 2153*38c8a9a5SSteve French struct kvec iov[2]; 2154*38c8a9a5SSteve French unsigned int len; 2155*38c8a9a5SSteve French 2156*38c8a9a5SSteve French if (open_file->invalidHandle) { 2157*38c8a9a5SSteve French /* we could deadlock if we called 2158*38c8a9a5SSteve French filemap_fdatawait from here so tell 2159*38c8a9a5SSteve French reopen_file not to flush data to 2160*38c8a9a5SSteve French server now */ 2161*38c8a9a5SSteve French rc = cifs_reopen_file(open_file, false); 2162*38c8a9a5SSteve French if (rc != 0) 2163*38c8a9a5SSteve French break; 2164*38c8a9a5SSteve French } 2165*38c8a9a5SSteve French 2166*38c8a9a5SSteve French len = min(server->ops->wp_retry_size(d_inode(dentry)), 2167*38c8a9a5SSteve French (unsigned int)write_size - total_written); 2168*38c8a9a5SSteve French /* iov[0] is reserved for smb header */ 2169*38c8a9a5SSteve French iov[1].iov_base = (char *)write_data + total_written; 2170*38c8a9a5SSteve French iov[1].iov_len = len; 2171*38c8a9a5SSteve French io_parms.pid = pid; 2172*38c8a9a5SSteve French io_parms.tcon = tcon; 2173*38c8a9a5SSteve French io_parms.offset = *offset; 2174*38c8a9a5SSteve French io_parms.length = len; 2175*38c8a9a5SSteve French rc = server->ops->sync_write(xid, &open_file->fid, 2176*38c8a9a5SSteve French &io_parms, &bytes_written, iov, 1); 2177*38c8a9a5SSteve French } 2178*38c8a9a5SSteve French if (rc || (bytes_written == 0)) { 2179*38c8a9a5SSteve French if (total_written) 2180*38c8a9a5SSteve French break; 2181*38c8a9a5SSteve French else { 2182*38c8a9a5SSteve French free_xid(xid); 2183*38c8a9a5SSteve French return rc; 2184*38c8a9a5SSteve French } 2185*38c8a9a5SSteve French } else { 2186*38c8a9a5SSteve French spin_lock(&d_inode(dentry)->i_lock); 2187*38c8a9a5SSteve French cifs_update_eof(cifsi, *offset, bytes_written); 2188*38c8a9a5SSteve French spin_unlock(&d_inode(dentry)->i_lock); 2189*38c8a9a5SSteve French *offset += bytes_written; 2190*38c8a9a5SSteve French } 2191*38c8a9a5SSteve French } 2192*38c8a9a5SSteve French 2193*38c8a9a5SSteve French cifs_stats_bytes_written(tcon, total_written); 2194*38c8a9a5SSteve French 2195*38c8a9a5SSteve French if (total_written > 0) { 2196*38c8a9a5SSteve French spin_lock(&d_inode(dentry)->i_lock); 2197*38c8a9a5SSteve French if (*offset > d_inode(dentry)->i_size) { 2198*38c8a9a5SSteve French i_size_write(d_inode(dentry), *offset); 2199*38c8a9a5SSteve French d_inode(dentry)->i_blocks = (512 - 1 + *offset) >> 9; 2200*38c8a9a5SSteve French } 2201*38c8a9a5SSteve French spin_unlock(&d_inode(dentry)->i_lock); 2202*38c8a9a5SSteve French } 2203*38c8a9a5SSteve French mark_inode_dirty_sync(d_inode(dentry)); 2204*38c8a9a5SSteve French free_xid(xid); 2205*38c8a9a5SSteve French return total_written; 2206*38c8a9a5SSteve French } 2207*38c8a9a5SSteve French 2208*38c8a9a5SSteve French struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode, 2209*38c8a9a5SSteve French bool fsuid_only) 2210*38c8a9a5SSteve French { 2211*38c8a9a5SSteve French struct cifsFileInfo *open_file = NULL; 2212*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->netfs.inode.i_sb); 2213*38c8a9a5SSteve French 2214*38c8a9a5SSteve French /* only filter by fsuid on multiuser mounts */ 2215*38c8a9a5SSteve French if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)) 2216*38c8a9a5SSteve French fsuid_only = false; 2217*38c8a9a5SSteve French 2218*38c8a9a5SSteve French spin_lock(&cifs_inode->open_file_lock); 2219*38c8a9a5SSteve French /* we could simply get the first_list_entry since write-only entries 2220*38c8a9a5SSteve French are always at the end of the list but since the first entry might 2221*38c8a9a5SSteve French have a close pending, we go through the whole list */ 2222*38c8a9a5SSteve French list_for_each_entry(open_file, &cifs_inode->openFileList, flist) { 2223*38c8a9a5SSteve French if (fsuid_only && !uid_eq(open_file->uid, current_fsuid())) 2224*38c8a9a5SSteve French continue; 2225*38c8a9a5SSteve French if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) { 2226*38c8a9a5SSteve French if ((!open_file->invalidHandle)) { 2227*38c8a9a5SSteve French /* found a good file */ 2228*38c8a9a5SSteve French /* lock it so it will not be closed on us */ 2229*38c8a9a5SSteve French cifsFileInfo_get(open_file); 2230*38c8a9a5SSteve French spin_unlock(&cifs_inode->open_file_lock); 2231*38c8a9a5SSteve French return open_file; 2232*38c8a9a5SSteve French } /* else might as well continue, and look for 2233*38c8a9a5SSteve French another, or simply have the caller reopen it 2234*38c8a9a5SSteve French again rather than trying to fix this handle */ 2235*38c8a9a5SSteve French } else /* write only file */ 2236*38c8a9a5SSteve French break; /* write only files are last so must be done */ 2237*38c8a9a5SSteve French } 2238*38c8a9a5SSteve French spin_unlock(&cifs_inode->open_file_lock); 2239*38c8a9a5SSteve French return NULL; 2240*38c8a9a5SSteve French } 2241*38c8a9a5SSteve French 2242*38c8a9a5SSteve French /* Return -EBADF if no handle is found and general rc otherwise */ 2243*38c8a9a5SSteve French int 2244*38c8a9a5SSteve French cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, int flags, 2245*38c8a9a5SSteve French struct cifsFileInfo **ret_file) 2246*38c8a9a5SSteve French { 2247*38c8a9a5SSteve French struct cifsFileInfo *open_file, *inv_file = NULL; 2248*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb; 2249*38c8a9a5SSteve French bool any_available = false; 2250*38c8a9a5SSteve French int rc = -EBADF; 2251*38c8a9a5SSteve French unsigned int refind = 0; 2252*38c8a9a5SSteve French bool fsuid_only = flags & FIND_WR_FSUID_ONLY; 2253*38c8a9a5SSteve French bool with_delete = flags & FIND_WR_WITH_DELETE; 2254*38c8a9a5SSteve French *ret_file = NULL; 2255*38c8a9a5SSteve French 2256*38c8a9a5SSteve French /* 2257*38c8a9a5SSteve French * Having a null inode here (because mapping->host was set to zero by 2258*38c8a9a5SSteve French * the VFS or MM) should not happen but we had reports of on oops (due 2259*38c8a9a5SSteve French * to it being zero) during stress testcases so we need to check for it 2260*38c8a9a5SSteve French */ 2261*38c8a9a5SSteve French 2262*38c8a9a5SSteve French if (cifs_inode == NULL) { 2263*38c8a9a5SSteve French cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n"); 2264*38c8a9a5SSteve French dump_stack(); 2265*38c8a9a5SSteve French return rc; 2266*38c8a9a5SSteve French } 2267*38c8a9a5SSteve French 2268*38c8a9a5SSteve French cifs_sb = CIFS_SB(cifs_inode->netfs.inode.i_sb); 2269*38c8a9a5SSteve French 2270*38c8a9a5SSteve French /* only filter by fsuid on multiuser mounts */ 2271*38c8a9a5SSteve French if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER)) 2272*38c8a9a5SSteve French fsuid_only = false; 2273*38c8a9a5SSteve French 2274*38c8a9a5SSteve French spin_lock(&cifs_inode->open_file_lock); 2275*38c8a9a5SSteve French refind_writable: 2276*38c8a9a5SSteve French if (refind > MAX_REOPEN_ATT) { 2277*38c8a9a5SSteve French spin_unlock(&cifs_inode->open_file_lock); 2278*38c8a9a5SSteve French return rc; 2279*38c8a9a5SSteve French } 2280*38c8a9a5SSteve French list_for_each_entry(open_file, &cifs_inode->openFileList, flist) { 2281*38c8a9a5SSteve French if (!any_available && open_file->pid != current->tgid) 2282*38c8a9a5SSteve French continue; 2283*38c8a9a5SSteve French if (fsuid_only && !uid_eq(open_file->uid, current_fsuid())) 2284*38c8a9a5SSteve French continue; 2285*38c8a9a5SSteve French if (with_delete && !(open_file->fid.access & DELETE)) 2286*38c8a9a5SSteve French continue; 2287*38c8a9a5SSteve French if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) { 2288*38c8a9a5SSteve French if (!open_file->invalidHandle) { 2289*38c8a9a5SSteve French /* found a good writable file */ 2290*38c8a9a5SSteve French cifsFileInfo_get(open_file); 2291*38c8a9a5SSteve French spin_unlock(&cifs_inode->open_file_lock); 2292*38c8a9a5SSteve French *ret_file = open_file; 2293*38c8a9a5SSteve French return 0; 2294*38c8a9a5SSteve French } else { 2295*38c8a9a5SSteve French if (!inv_file) 2296*38c8a9a5SSteve French inv_file = open_file; 2297*38c8a9a5SSteve French } 2298*38c8a9a5SSteve French } 2299*38c8a9a5SSteve French } 2300*38c8a9a5SSteve French /* couldn't find useable FH with same pid, try any available */ 2301*38c8a9a5SSteve French if (!any_available) { 2302*38c8a9a5SSteve French any_available = true; 2303*38c8a9a5SSteve French goto refind_writable; 2304*38c8a9a5SSteve French } 2305*38c8a9a5SSteve French 2306*38c8a9a5SSteve French if (inv_file) { 2307*38c8a9a5SSteve French any_available = false; 2308*38c8a9a5SSteve French cifsFileInfo_get(inv_file); 2309*38c8a9a5SSteve French } 2310*38c8a9a5SSteve French 2311*38c8a9a5SSteve French spin_unlock(&cifs_inode->open_file_lock); 2312*38c8a9a5SSteve French 2313*38c8a9a5SSteve French if (inv_file) { 2314*38c8a9a5SSteve French rc = cifs_reopen_file(inv_file, false); 2315*38c8a9a5SSteve French if (!rc) { 2316*38c8a9a5SSteve French *ret_file = inv_file; 2317*38c8a9a5SSteve French return 0; 2318*38c8a9a5SSteve French } 2319*38c8a9a5SSteve French 2320*38c8a9a5SSteve French spin_lock(&cifs_inode->open_file_lock); 2321*38c8a9a5SSteve French list_move_tail(&inv_file->flist, &cifs_inode->openFileList); 2322*38c8a9a5SSteve French spin_unlock(&cifs_inode->open_file_lock); 2323*38c8a9a5SSteve French cifsFileInfo_put(inv_file); 2324*38c8a9a5SSteve French ++refind; 2325*38c8a9a5SSteve French inv_file = NULL; 2326*38c8a9a5SSteve French spin_lock(&cifs_inode->open_file_lock); 2327*38c8a9a5SSteve French goto refind_writable; 2328*38c8a9a5SSteve French } 2329*38c8a9a5SSteve French 2330*38c8a9a5SSteve French return rc; 2331*38c8a9a5SSteve French } 2332*38c8a9a5SSteve French 2333*38c8a9a5SSteve French struct cifsFileInfo * 2334*38c8a9a5SSteve French find_writable_file(struct cifsInodeInfo *cifs_inode, int flags) 2335*38c8a9a5SSteve French { 2336*38c8a9a5SSteve French struct cifsFileInfo *cfile; 2337*38c8a9a5SSteve French int rc; 2338*38c8a9a5SSteve French 2339*38c8a9a5SSteve French rc = cifs_get_writable_file(cifs_inode, flags, &cfile); 2340*38c8a9a5SSteve French if (rc) 2341*38c8a9a5SSteve French cifs_dbg(FYI, "Couldn't find writable handle rc=%d\n", rc); 2342*38c8a9a5SSteve French 2343*38c8a9a5SSteve French return cfile; 2344*38c8a9a5SSteve French } 2345*38c8a9a5SSteve French 2346*38c8a9a5SSteve French int 2347*38c8a9a5SSteve French cifs_get_writable_path(struct cifs_tcon *tcon, const char *name, 2348*38c8a9a5SSteve French int flags, 2349*38c8a9a5SSteve French struct cifsFileInfo **ret_file) 2350*38c8a9a5SSteve French { 2351*38c8a9a5SSteve French struct cifsFileInfo *cfile; 2352*38c8a9a5SSteve French void *page = alloc_dentry_path(); 2353*38c8a9a5SSteve French 2354*38c8a9a5SSteve French *ret_file = NULL; 2355*38c8a9a5SSteve French 2356*38c8a9a5SSteve French spin_lock(&tcon->open_file_lock); 2357*38c8a9a5SSteve French list_for_each_entry(cfile, &tcon->openFileList, tlist) { 2358*38c8a9a5SSteve French struct cifsInodeInfo *cinode; 2359*38c8a9a5SSteve French const char *full_path = build_path_from_dentry(cfile->dentry, page); 2360*38c8a9a5SSteve French if (IS_ERR(full_path)) { 2361*38c8a9a5SSteve French spin_unlock(&tcon->open_file_lock); 2362*38c8a9a5SSteve French free_dentry_path(page); 2363*38c8a9a5SSteve French return PTR_ERR(full_path); 2364*38c8a9a5SSteve French } 2365*38c8a9a5SSteve French if (strcmp(full_path, name)) 2366*38c8a9a5SSteve French continue; 2367*38c8a9a5SSteve French 2368*38c8a9a5SSteve French cinode = CIFS_I(d_inode(cfile->dentry)); 2369*38c8a9a5SSteve French spin_unlock(&tcon->open_file_lock); 2370*38c8a9a5SSteve French free_dentry_path(page); 2371*38c8a9a5SSteve French return cifs_get_writable_file(cinode, flags, ret_file); 2372*38c8a9a5SSteve French } 2373*38c8a9a5SSteve French 2374*38c8a9a5SSteve French spin_unlock(&tcon->open_file_lock); 2375*38c8a9a5SSteve French free_dentry_path(page); 2376*38c8a9a5SSteve French return -ENOENT; 2377*38c8a9a5SSteve French } 2378*38c8a9a5SSteve French 2379*38c8a9a5SSteve French int 2380*38c8a9a5SSteve French cifs_get_readable_path(struct cifs_tcon *tcon, const char *name, 2381*38c8a9a5SSteve French struct cifsFileInfo **ret_file) 2382*38c8a9a5SSteve French { 2383*38c8a9a5SSteve French struct cifsFileInfo *cfile; 2384*38c8a9a5SSteve French void *page = alloc_dentry_path(); 2385*38c8a9a5SSteve French 2386*38c8a9a5SSteve French *ret_file = NULL; 2387*38c8a9a5SSteve French 2388*38c8a9a5SSteve French spin_lock(&tcon->open_file_lock); 2389*38c8a9a5SSteve French list_for_each_entry(cfile, &tcon->openFileList, tlist) { 2390*38c8a9a5SSteve French struct cifsInodeInfo *cinode; 2391*38c8a9a5SSteve French const char *full_path = build_path_from_dentry(cfile->dentry, page); 2392*38c8a9a5SSteve French if (IS_ERR(full_path)) { 2393*38c8a9a5SSteve French spin_unlock(&tcon->open_file_lock); 2394*38c8a9a5SSteve French free_dentry_path(page); 2395*38c8a9a5SSteve French return PTR_ERR(full_path); 2396*38c8a9a5SSteve French } 2397*38c8a9a5SSteve French if (strcmp(full_path, name)) 2398*38c8a9a5SSteve French continue; 2399*38c8a9a5SSteve French 2400*38c8a9a5SSteve French cinode = CIFS_I(d_inode(cfile->dentry)); 2401*38c8a9a5SSteve French spin_unlock(&tcon->open_file_lock); 2402*38c8a9a5SSteve French free_dentry_path(page); 2403*38c8a9a5SSteve French *ret_file = find_readable_file(cinode, 0); 2404*38c8a9a5SSteve French return *ret_file ? 0 : -ENOENT; 2405*38c8a9a5SSteve French } 2406*38c8a9a5SSteve French 2407*38c8a9a5SSteve French spin_unlock(&tcon->open_file_lock); 2408*38c8a9a5SSteve French free_dentry_path(page); 2409*38c8a9a5SSteve French return -ENOENT; 2410*38c8a9a5SSteve French } 2411*38c8a9a5SSteve French 2412*38c8a9a5SSteve French void 2413*38c8a9a5SSteve French cifs_writedata_release(struct kref *refcount) 2414*38c8a9a5SSteve French { 2415*38c8a9a5SSteve French struct cifs_writedata *wdata = container_of(refcount, 2416*38c8a9a5SSteve French struct cifs_writedata, refcount); 2417*38c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 2418*38c8a9a5SSteve French if (wdata->mr) { 2419*38c8a9a5SSteve French smbd_deregister_mr(wdata->mr); 2420*38c8a9a5SSteve French wdata->mr = NULL; 2421*38c8a9a5SSteve French } 2422*38c8a9a5SSteve French #endif 2423*38c8a9a5SSteve French 2424*38c8a9a5SSteve French if (wdata->cfile) 2425*38c8a9a5SSteve French cifsFileInfo_put(wdata->cfile); 2426*38c8a9a5SSteve French 2427*38c8a9a5SSteve French kfree(wdata); 2428*38c8a9a5SSteve French } 2429*38c8a9a5SSteve French 2430*38c8a9a5SSteve French /* 2431*38c8a9a5SSteve French * Write failed with a retryable error. Resend the write request. It's also 2432*38c8a9a5SSteve French * possible that the page was redirtied so re-clean the page. 2433*38c8a9a5SSteve French */ 2434*38c8a9a5SSteve French static void 2435*38c8a9a5SSteve French cifs_writev_requeue(struct cifs_writedata *wdata) 2436*38c8a9a5SSteve French { 2437*38c8a9a5SSteve French int rc = 0; 2438*38c8a9a5SSteve French struct inode *inode = d_inode(wdata->cfile->dentry); 2439*38c8a9a5SSteve French struct TCP_Server_Info *server; 2440*38c8a9a5SSteve French unsigned int rest_len = wdata->bytes; 2441*38c8a9a5SSteve French loff_t fpos = wdata->offset; 2442*38c8a9a5SSteve French 2443*38c8a9a5SSteve French server = tlink_tcon(wdata->cfile->tlink)->ses->server; 2444*38c8a9a5SSteve French do { 2445*38c8a9a5SSteve French struct cifs_writedata *wdata2; 2446*38c8a9a5SSteve French unsigned int wsize, cur_len; 2447*38c8a9a5SSteve French 2448*38c8a9a5SSteve French wsize = server->ops->wp_retry_size(inode); 2449*38c8a9a5SSteve French if (wsize < rest_len) { 2450*38c8a9a5SSteve French if (wsize < PAGE_SIZE) { 2451*38c8a9a5SSteve French rc = -EOPNOTSUPP; 2452*38c8a9a5SSteve French break; 2453*38c8a9a5SSteve French } 2454*38c8a9a5SSteve French cur_len = min(round_down(wsize, PAGE_SIZE), rest_len); 2455*38c8a9a5SSteve French } else { 2456*38c8a9a5SSteve French cur_len = rest_len; 2457*38c8a9a5SSteve French } 2458*38c8a9a5SSteve French 2459*38c8a9a5SSteve French wdata2 = cifs_writedata_alloc(cifs_writev_complete); 2460*38c8a9a5SSteve French if (!wdata2) { 2461*38c8a9a5SSteve French rc = -ENOMEM; 2462*38c8a9a5SSteve French break; 2463*38c8a9a5SSteve French } 2464*38c8a9a5SSteve French 2465*38c8a9a5SSteve French wdata2->sync_mode = wdata->sync_mode; 2466*38c8a9a5SSteve French wdata2->offset = fpos; 2467*38c8a9a5SSteve French wdata2->bytes = cur_len; 2468*38c8a9a5SSteve French wdata2->iter = wdata->iter; 2469*38c8a9a5SSteve French 2470*38c8a9a5SSteve French iov_iter_advance(&wdata2->iter, fpos - wdata->offset); 2471*38c8a9a5SSteve French iov_iter_truncate(&wdata2->iter, wdata2->bytes); 2472*38c8a9a5SSteve French 2473*38c8a9a5SSteve French if (iov_iter_is_xarray(&wdata2->iter)) 2474*38c8a9a5SSteve French /* Check for pages having been redirtied and clean 2475*38c8a9a5SSteve French * them. We can do this by walking the xarray. If 2476*38c8a9a5SSteve French * it's not an xarray, then it's a DIO and we shouldn't 2477*38c8a9a5SSteve French * be mucking around with the page bits. 2478*38c8a9a5SSteve French */ 2479*38c8a9a5SSteve French cifs_undirty_folios(inode, fpos, cur_len); 2480*38c8a9a5SSteve French 2481*38c8a9a5SSteve French rc = cifs_get_writable_file(CIFS_I(inode), FIND_WR_ANY, 2482*38c8a9a5SSteve French &wdata2->cfile); 2483*38c8a9a5SSteve French if (!wdata2->cfile) { 2484*38c8a9a5SSteve French cifs_dbg(VFS, "No writable handle to retry writepages rc=%d\n", 2485*38c8a9a5SSteve French rc); 2486*38c8a9a5SSteve French if (!is_retryable_error(rc)) 2487*38c8a9a5SSteve French rc = -EBADF; 2488*38c8a9a5SSteve French } else { 2489*38c8a9a5SSteve French wdata2->pid = wdata2->cfile->pid; 2490*38c8a9a5SSteve French rc = server->ops->async_writev(wdata2, 2491*38c8a9a5SSteve French cifs_writedata_release); 2492*38c8a9a5SSteve French } 2493*38c8a9a5SSteve French 2494*38c8a9a5SSteve French kref_put(&wdata2->refcount, cifs_writedata_release); 2495*38c8a9a5SSteve French if (rc) { 2496*38c8a9a5SSteve French if (is_retryable_error(rc)) 2497*38c8a9a5SSteve French continue; 2498*38c8a9a5SSteve French fpos += cur_len; 2499*38c8a9a5SSteve French rest_len -= cur_len; 2500*38c8a9a5SSteve French break; 2501*38c8a9a5SSteve French } 2502*38c8a9a5SSteve French 2503*38c8a9a5SSteve French fpos += cur_len; 2504*38c8a9a5SSteve French rest_len -= cur_len; 2505*38c8a9a5SSteve French } while (rest_len > 0); 2506*38c8a9a5SSteve French 2507*38c8a9a5SSteve French /* Clean up remaining pages from the original wdata */ 2508*38c8a9a5SSteve French if (iov_iter_is_xarray(&wdata->iter)) 2509*38c8a9a5SSteve French cifs_pages_write_failed(inode, fpos, rest_len); 2510*38c8a9a5SSteve French 2511*38c8a9a5SSteve French if (rc != 0 && !is_retryable_error(rc)) 2512*38c8a9a5SSteve French mapping_set_error(inode->i_mapping, rc); 2513*38c8a9a5SSteve French kref_put(&wdata->refcount, cifs_writedata_release); 2514*38c8a9a5SSteve French } 2515*38c8a9a5SSteve French 2516*38c8a9a5SSteve French void 2517*38c8a9a5SSteve French cifs_writev_complete(struct work_struct *work) 2518*38c8a9a5SSteve French { 2519*38c8a9a5SSteve French struct cifs_writedata *wdata = container_of(work, 2520*38c8a9a5SSteve French struct cifs_writedata, work); 2521*38c8a9a5SSteve French struct inode *inode = d_inode(wdata->cfile->dentry); 2522*38c8a9a5SSteve French 2523*38c8a9a5SSteve French if (wdata->result == 0) { 2524*38c8a9a5SSteve French spin_lock(&inode->i_lock); 2525*38c8a9a5SSteve French cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes); 2526*38c8a9a5SSteve French spin_unlock(&inode->i_lock); 2527*38c8a9a5SSteve French cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink), 2528*38c8a9a5SSteve French wdata->bytes); 2529*38c8a9a5SSteve French } else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN) 2530*38c8a9a5SSteve French return cifs_writev_requeue(wdata); 2531*38c8a9a5SSteve French 2532*38c8a9a5SSteve French if (wdata->result == -EAGAIN) 2533*38c8a9a5SSteve French cifs_pages_write_redirty(inode, wdata->offset, wdata->bytes); 2534*38c8a9a5SSteve French else if (wdata->result < 0) 2535*38c8a9a5SSteve French cifs_pages_write_failed(inode, wdata->offset, wdata->bytes); 2536*38c8a9a5SSteve French else 2537*38c8a9a5SSteve French cifs_pages_written_back(inode, wdata->offset, wdata->bytes); 2538*38c8a9a5SSteve French 2539*38c8a9a5SSteve French if (wdata->result != -EAGAIN) 2540*38c8a9a5SSteve French mapping_set_error(inode->i_mapping, wdata->result); 2541*38c8a9a5SSteve French kref_put(&wdata->refcount, cifs_writedata_release); 2542*38c8a9a5SSteve French } 2543*38c8a9a5SSteve French 2544*38c8a9a5SSteve French struct cifs_writedata *cifs_writedata_alloc(work_func_t complete) 2545*38c8a9a5SSteve French { 2546*38c8a9a5SSteve French struct cifs_writedata *wdata; 2547*38c8a9a5SSteve French 2548*38c8a9a5SSteve French wdata = kzalloc(sizeof(*wdata), GFP_NOFS); 2549*38c8a9a5SSteve French if (wdata != NULL) { 2550*38c8a9a5SSteve French kref_init(&wdata->refcount); 2551*38c8a9a5SSteve French INIT_LIST_HEAD(&wdata->list); 2552*38c8a9a5SSteve French init_completion(&wdata->done); 2553*38c8a9a5SSteve French INIT_WORK(&wdata->work, complete); 2554*38c8a9a5SSteve French } 2555*38c8a9a5SSteve French return wdata; 2556*38c8a9a5SSteve French } 2557*38c8a9a5SSteve French 2558*38c8a9a5SSteve French static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to) 2559*38c8a9a5SSteve French { 2560*38c8a9a5SSteve French struct address_space *mapping = page->mapping; 2561*38c8a9a5SSteve French loff_t offset = (loff_t)page->index << PAGE_SHIFT; 2562*38c8a9a5SSteve French char *write_data; 2563*38c8a9a5SSteve French int rc = -EFAULT; 2564*38c8a9a5SSteve French int bytes_written = 0; 2565*38c8a9a5SSteve French struct inode *inode; 2566*38c8a9a5SSteve French struct cifsFileInfo *open_file; 2567*38c8a9a5SSteve French 2568*38c8a9a5SSteve French if (!mapping || !mapping->host) 2569*38c8a9a5SSteve French return -EFAULT; 2570*38c8a9a5SSteve French 2571*38c8a9a5SSteve French inode = page->mapping->host; 2572*38c8a9a5SSteve French 2573*38c8a9a5SSteve French offset += (loff_t)from; 2574*38c8a9a5SSteve French write_data = kmap(page); 2575*38c8a9a5SSteve French write_data += from; 2576*38c8a9a5SSteve French 2577*38c8a9a5SSteve French if ((to > PAGE_SIZE) || (from > to)) { 2578*38c8a9a5SSteve French kunmap(page); 2579*38c8a9a5SSteve French return -EIO; 2580*38c8a9a5SSteve French } 2581*38c8a9a5SSteve French 2582*38c8a9a5SSteve French /* racing with truncate? */ 2583*38c8a9a5SSteve French if (offset > mapping->host->i_size) { 2584*38c8a9a5SSteve French kunmap(page); 2585*38c8a9a5SSteve French return 0; /* don't care */ 2586*38c8a9a5SSteve French } 2587*38c8a9a5SSteve French 2588*38c8a9a5SSteve French /* check to make sure that we are not extending the file */ 2589*38c8a9a5SSteve French if (mapping->host->i_size - offset < (loff_t)to) 2590*38c8a9a5SSteve French to = (unsigned)(mapping->host->i_size - offset); 2591*38c8a9a5SSteve French 2592*38c8a9a5SSteve French rc = cifs_get_writable_file(CIFS_I(mapping->host), FIND_WR_ANY, 2593*38c8a9a5SSteve French &open_file); 2594*38c8a9a5SSteve French if (!rc) { 2595*38c8a9a5SSteve French bytes_written = cifs_write(open_file, open_file->pid, 2596*38c8a9a5SSteve French write_data, to - from, &offset); 2597*38c8a9a5SSteve French cifsFileInfo_put(open_file); 2598*38c8a9a5SSteve French /* Does mm or vfs already set times? */ 2599*38c8a9a5SSteve French inode->i_atime = inode->i_mtime = current_time(inode); 2600*38c8a9a5SSteve French if ((bytes_written > 0) && (offset)) 2601*38c8a9a5SSteve French rc = 0; 2602*38c8a9a5SSteve French else if (bytes_written < 0) 2603*38c8a9a5SSteve French rc = bytes_written; 2604*38c8a9a5SSteve French else 2605*38c8a9a5SSteve French rc = -EFAULT; 2606*38c8a9a5SSteve French } else { 2607*38c8a9a5SSteve French cifs_dbg(FYI, "No writable handle for write page rc=%d\n", rc); 2608*38c8a9a5SSteve French if (!is_retryable_error(rc)) 2609*38c8a9a5SSteve French rc = -EIO; 2610*38c8a9a5SSteve French } 2611*38c8a9a5SSteve French 2612*38c8a9a5SSteve French kunmap(page); 2613*38c8a9a5SSteve French return rc; 2614*38c8a9a5SSteve French } 2615*38c8a9a5SSteve French 2616*38c8a9a5SSteve French /* 2617*38c8a9a5SSteve French * Extend the region to be written back to include subsequent contiguously 2618*38c8a9a5SSteve French * dirty pages if possible, but don't sleep while doing so. 2619*38c8a9a5SSteve French */ 2620*38c8a9a5SSteve French static void cifs_extend_writeback(struct address_space *mapping, 2621*38c8a9a5SSteve French long *_count, 2622*38c8a9a5SSteve French loff_t start, 2623*38c8a9a5SSteve French int max_pages, 2624*38c8a9a5SSteve French size_t max_len, 2625*38c8a9a5SSteve French unsigned int *_len) 2626*38c8a9a5SSteve French { 2627*38c8a9a5SSteve French struct folio_batch batch; 2628*38c8a9a5SSteve French struct folio *folio; 2629*38c8a9a5SSteve French unsigned int psize, nr_pages; 2630*38c8a9a5SSteve French size_t len = *_len; 2631*38c8a9a5SSteve French pgoff_t index = (start + len) / PAGE_SIZE; 2632*38c8a9a5SSteve French bool stop = true; 2633*38c8a9a5SSteve French unsigned int i; 2634*38c8a9a5SSteve French XA_STATE(xas, &mapping->i_pages, index); 2635*38c8a9a5SSteve French 2636*38c8a9a5SSteve French folio_batch_init(&batch); 2637*38c8a9a5SSteve French 2638*38c8a9a5SSteve French do { 2639*38c8a9a5SSteve French /* Firstly, we gather up a batch of contiguous dirty pages 2640*38c8a9a5SSteve French * under the RCU read lock - but we can't clear the dirty flags 2641*38c8a9a5SSteve French * there if any of those pages are mapped. 2642*38c8a9a5SSteve French */ 2643*38c8a9a5SSteve French rcu_read_lock(); 2644*38c8a9a5SSteve French 2645*38c8a9a5SSteve French xas_for_each(&xas, folio, ULONG_MAX) { 2646*38c8a9a5SSteve French stop = true; 2647*38c8a9a5SSteve French if (xas_retry(&xas, folio)) 2648*38c8a9a5SSteve French continue; 2649*38c8a9a5SSteve French if (xa_is_value(folio)) 2650*38c8a9a5SSteve French break; 2651*38c8a9a5SSteve French if (folio_index(folio) != index) 2652*38c8a9a5SSteve French break; 2653*38c8a9a5SSteve French if (!folio_try_get_rcu(folio)) { 2654*38c8a9a5SSteve French xas_reset(&xas); 2655*38c8a9a5SSteve French continue; 2656*38c8a9a5SSteve French } 2657*38c8a9a5SSteve French nr_pages = folio_nr_pages(folio); 2658*38c8a9a5SSteve French if (nr_pages > max_pages) 2659*38c8a9a5SSteve French break; 2660*38c8a9a5SSteve French 2661*38c8a9a5SSteve French /* Has the page moved or been split? */ 2662*38c8a9a5SSteve French if (unlikely(folio != xas_reload(&xas))) { 2663*38c8a9a5SSteve French folio_put(folio); 2664*38c8a9a5SSteve French break; 2665*38c8a9a5SSteve French } 2666*38c8a9a5SSteve French 2667*38c8a9a5SSteve French if (!folio_trylock(folio)) { 2668*38c8a9a5SSteve French folio_put(folio); 2669*38c8a9a5SSteve French break; 2670*38c8a9a5SSteve French } 2671*38c8a9a5SSteve French if (!folio_test_dirty(folio) || folio_test_writeback(folio)) { 2672*38c8a9a5SSteve French folio_unlock(folio); 2673*38c8a9a5SSteve French folio_put(folio); 2674*38c8a9a5SSteve French break; 2675*38c8a9a5SSteve French } 2676*38c8a9a5SSteve French 2677*38c8a9a5SSteve French max_pages -= nr_pages; 2678*38c8a9a5SSteve French psize = folio_size(folio); 2679*38c8a9a5SSteve French len += psize; 2680*38c8a9a5SSteve French stop = false; 2681*38c8a9a5SSteve French if (max_pages <= 0 || len >= max_len || *_count <= 0) 2682*38c8a9a5SSteve French stop = true; 2683*38c8a9a5SSteve French 2684*38c8a9a5SSteve French index += nr_pages; 2685*38c8a9a5SSteve French if (!folio_batch_add(&batch, folio)) 2686*38c8a9a5SSteve French break; 2687*38c8a9a5SSteve French if (stop) 2688*38c8a9a5SSteve French break; 2689*38c8a9a5SSteve French } 2690*38c8a9a5SSteve French 2691*38c8a9a5SSteve French if (!stop) 2692*38c8a9a5SSteve French xas_pause(&xas); 2693*38c8a9a5SSteve French rcu_read_unlock(); 2694*38c8a9a5SSteve French 2695*38c8a9a5SSteve French /* Now, if we obtained any pages, we can shift them to being 2696*38c8a9a5SSteve French * writable and mark them for caching. 2697*38c8a9a5SSteve French */ 2698*38c8a9a5SSteve French if (!folio_batch_count(&batch)) 2699*38c8a9a5SSteve French break; 2700*38c8a9a5SSteve French 2701*38c8a9a5SSteve French for (i = 0; i < folio_batch_count(&batch); i++) { 2702*38c8a9a5SSteve French folio = batch.folios[i]; 2703*38c8a9a5SSteve French /* The folio should be locked, dirty and not undergoing 2704*38c8a9a5SSteve French * writeback from the loop above. 2705*38c8a9a5SSteve French */ 2706*38c8a9a5SSteve French if (!folio_clear_dirty_for_io(folio)) 2707*38c8a9a5SSteve French WARN_ON(1); 2708*38c8a9a5SSteve French if (folio_start_writeback(folio)) 2709*38c8a9a5SSteve French WARN_ON(1); 2710*38c8a9a5SSteve French 2711*38c8a9a5SSteve French *_count -= folio_nr_pages(folio); 2712*38c8a9a5SSteve French folio_unlock(folio); 2713*38c8a9a5SSteve French } 2714*38c8a9a5SSteve French 2715*38c8a9a5SSteve French folio_batch_release(&batch); 2716*38c8a9a5SSteve French cond_resched(); 2717*38c8a9a5SSteve French } while (!stop); 2718*38c8a9a5SSteve French 2719*38c8a9a5SSteve French *_len = len; 2720*38c8a9a5SSteve French } 2721*38c8a9a5SSteve French 2722*38c8a9a5SSteve French /* 2723*38c8a9a5SSteve French * Write back the locked page and any subsequent non-locked dirty pages. 2724*38c8a9a5SSteve French */ 2725*38c8a9a5SSteve French static ssize_t cifs_write_back_from_locked_folio(struct address_space *mapping, 2726*38c8a9a5SSteve French struct writeback_control *wbc, 2727*38c8a9a5SSteve French struct folio *folio, 2728*38c8a9a5SSteve French loff_t start, loff_t end) 2729*38c8a9a5SSteve French { 2730*38c8a9a5SSteve French struct inode *inode = mapping->host; 2731*38c8a9a5SSteve French struct TCP_Server_Info *server; 2732*38c8a9a5SSteve French struct cifs_writedata *wdata; 2733*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 2734*38c8a9a5SSteve French struct cifs_credits credits_on_stack; 2735*38c8a9a5SSteve French struct cifs_credits *credits = &credits_on_stack; 2736*38c8a9a5SSteve French struct cifsFileInfo *cfile = NULL; 2737*38c8a9a5SSteve French unsigned int xid, wsize, len; 2738*38c8a9a5SSteve French loff_t i_size = i_size_read(inode); 2739*38c8a9a5SSteve French size_t max_len; 2740*38c8a9a5SSteve French long count = wbc->nr_to_write; 2741*38c8a9a5SSteve French int rc; 2742*38c8a9a5SSteve French 2743*38c8a9a5SSteve French /* The folio should be locked, dirty and not undergoing writeback. */ 2744*38c8a9a5SSteve French if (folio_start_writeback(folio)) 2745*38c8a9a5SSteve French WARN_ON(1); 2746*38c8a9a5SSteve French 2747*38c8a9a5SSteve French count -= folio_nr_pages(folio); 2748*38c8a9a5SSteve French len = folio_size(folio); 2749*38c8a9a5SSteve French 2750*38c8a9a5SSteve French xid = get_xid(); 2751*38c8a9a5SSteve French server = cifs_pick_channel(cifs_sb_master_tcon(cifs_sb)->ses); 2752*38c8a9a5SSteve French 2753*38c8a9a5SSteve French rc = cifs_get_writable_file(CIFS_I(inode), FIND_WR_ANY, &cfile); 2754*38c8a9a5SSteve French if (rc) { 2755*38c8a9a5SSteve French cifs_dbg(VFS, "No writable handle in writepages rc=%d\n", rc); 2756*38c8a9a5SSteve French goto err_xid; 2757*38c8a9a5SSteve French } 2758*38c8a9a5SSteve French 2759*38c8a9a5SSteve French rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->wsize, 2760*38c8a9a5SSteve French &wsize, credits); 2761*38c8a9a5SSteve French if (rc != 0) 2762*38c8a9a5SSteve French goto err_close; 2763*38c8a9a5SSteve French 2764*38c8a9a5SSteve French wdata = cifs_writedata_alloc(cifs_writev_complete); 2765*38c8a9a5SSteve French if (!wdata) { 2766*38c8a9a5SSteve French rc = -ENOMEM; 2767*38c8a9a5SSteve French goto err_uncredit; 2768*38c8a9a5SSteve French } 2769*38c8a9a5SSteve French 2770*38c8a9a5SSteve French wdata->sync_mode = wbc->sync_mode; 2771*38c8a9a5SSteve French wdata->offset = folio_pos(folio); 2772*38c8a9a5SSteve French wdata->pid = cfile->pid; 2773*38c8a9a5SSteve French wdata->credits = credits_on_stack; 2774*38c8a9a5SSteve French wdata->cfile = cfile; 2775*38c8a9a5SSteve French wdata->server = server; 2776*38c8a9a5SSteve French cfile = NULL; 2777*38c8a9a5SSteve French 2778*38c8a9a5SSteve French /* Find all consecutive lockable dirty pages, stopping when we find a 2779*38c8a9a5SSteve French * page that is not immediately lockable, is not dirty or is missing, 2780*38c8a9a5SSteve French * or we reach the end of the range. 2781*38c8a9a5SSteve French */ 2782*38c8a9a5SSteve French if (start < i_size) { 2783*38c8a9a5SSteve French /* Trim the write to the EOF; the extra data is ignored. Also 2784*38c8a9a5SSteve French * put an upper limit on the size of a single storedata op. 2785*38c8a9a5SSteve French */ 2786*38c8a9a5SSteve French max_len = wsize; 2787*38c8a9a5SSteve French max_len = min_t(unsigned long long, max_len, end - start + 1); 2788*38c8a9a5SSteve French max_len = min_t(unsigned long long, max_len, i_size - start); 2789*38c8a9a5SSteve French 2790*38c8a9a5SSteve French if (len < max_len) { 2791*38c8a9a5SSteve French int max_pages = INT_MAX; 2792*38c8a9a5SSteve French 2793*38c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 2794*38c8a9a5SSteve French if (server->smbd_conn) 2795*38c8a9a5SSteve French max_pages = server->smbd_conn->max_frmr_depth; 2796*38c8a9a5SSteve French #endif 2797*38c8a9a5SSteve French max_pages -= folio_nr_pages(folio); 2798*38c8a9a5SSteve French 2799*38c8a9a5SSteve French if (max_pages > 0) 2800*38c8a9a5SSteve French cifs_extend_writeback(mapping, &count, start, 2801*38c8a9a5SSteve French max_pages, max_len, &len); 2802*38c8a9a5SSteve French } 2803*38c8a9a5SSteve French len = min_t(loff_t, len, max_len); 2804*38c8a9a5SSteve French } 2805*38c8a9a5SSteve French 2806*38c8a9a5SSteve French wdata->bytes = len; 2807*38c8a9a5SSteve French 2808*38c8a9a5SSteve French /* We now have a contiguous set of dirty pages, each with writeback 2809*38c8a9a5SSteve French * set; the first page is still locked at this point, but all the rest 2810*38c8a9a5SSteve French * have been unlocked. 2811*38c8a9a5SSteve French */ 2812*38c8a9a5SSteve French folio_unlock(folio); 2813*38c8a9a5SSteve French 2814*38c8a9a5SSteve French if (start < i_size) { 2815*38c8a9a5SSteve French iov_iter_xarray(&wdata->iter, ITER_SOURCE, &mapping->i_pages, 2816*38c8a9a5SSteve French start, len); 2817*38c8a9a5SSteve French 2818*38c8a9a5SSteve French rc = adjust_credits(wdata->server, &wdata->credits, wdata->bytes); 2819*38c8a9a5SSteve French if (rc) 2820*38c8a9a5SSteve French goto err_wdata; 2821*38c8a9a5SSteve French 2822*38c8a9a5SSteve French if (wdata->cfile->invalidHandle) 2823*38c8a9a5SSteve French rc = -EAGAIN; 2824*38c8a9a5SSteve French else 2825*38c8a9a5SSteve French rc = wdata->server->ops->async_writev(wdata, 2826*38c8a9a5SSteve French cifs_writedata_release); 2827*38c8a9a5SSteve French if (rc >= 0) { 2828*38c8a9a5SSteve French kref_put(&wdata->refcount, cifs_writedata_release); 2829*38c8a9a5SSteve French goto err_close; 2830*38c8a9a5SSteve French } 2831*38c8a9a5SSteve French } else { 2832*38c8a9a5SSteve French /* The dirty region was entirely beyond the EOF. */ 2833*38c8a9a5SSteve French cifs_pages_written_back(inode, start, len); 2834*38c8a9a5SSteve French rc = 0; 2835*38c8a9a5SSteve French } 2836*38c8a9a5SSteve French 2837*38c8a9a5SSteve French err_wdata: 2838*38c8a9a5SSteve French kref_put(&wdata->refcount, cifs_writedata_release); 2839*38c8a9a5SSteve French err_uncredit: 2840*38c8a9a5SSteve French add_credits_and_wake_if(server, credits, 0); 2841*38c8a9a5SSteve French err_close: 2842*38c8a9a5SSteve French if (cfile) 2843*38c8a9a5SSteve French cifsFileInfo_put(cfile); 2844*38c8a9a5SSteve French err_xid: 2845*38c8a9a5SSteve French free_xid(xid); 2846*38c8a9a5SSteve French if (rc == 0) { 2847*38c8a9a5SSteve French wbc->nr_to_write = count; 2848*38c8a9a5SSteve French rc = len; 2849*38c8a9a5SSteve French } else if (is_retryable_error(rc)) { 2850*38c8a9a5SSteve French cifs_pages_write_redirty(inode, start, len); 2851*38c8a9a5SSteve French } else { 2852*38c8a9a5SSteve French cifs_pages_write_failed(inode, start, len); 2853*38c8a9a5SSteve French mapping_set_error(mapping, rc); 2854*38c8a9a5SSteve French } 2855*38c8a9a5SSteve French /* Indication to update ctime and mtime as close is deferred */ 2856*38c8a9a5SSteve French set_bit(CIFS_INO_MODIFIED_ATTR, &CIFS_I(inode)->flags); 2857*38c8a9a5SSteve French return rc; 2858*38c8a9a5SSteve French } 2859*38c8a9a5SSteve French 2860*38c8a9a5SSteve French /* 2861*38c8a9a5SSteve French * write a region of pages back to the server 2862*38c8a9a5SSteve French */ 2863*38c8a9a5SSteve French static int cifs_writepages_region(struct address_space *mapping, 2864*38c8a9a5SSteve French struct writeback_control *wbc, 2865*38c8a9a5SSteve French loff_t start, loff_t end, loff_t *_next) 2866*38c8a9a5SSteve French { 2867*38c8a9a5SSteve French struct folio_batch fbatch; 2868*38c8a9a5SSteve French int skips = 0; 2869*38c8a9a5SSteve French 2870*38c8a9a5SSteve French folio_batch_init(&fbatch); 2871*38c8a9a5SSteve French do { 2872*38c8a9a5SSteve French int nr; 2873*38c8a9a5SSteve French pgoff_t index = start / PAGE_SIZE; 2874*38c8a9a5SSteve French 2875*38c8a9a5SSteve French nr = filemap_get_folios_tag(mapping, &index, end / PAGE_SIZE, 2876*38c8a9a5SSteve French PAGECACHE_TAG_DIRTY, &fbatch); 2877*38c8a9a5SSteve French if (!nr) 2878*38c8a9a5SSteve French break; 2879*38c8a9a5SSteve French 2880*38c8a9a5SSteve French for (int i = 0; i < nr; i++) { 2881*38c8a9a5SSteve French ssize_t ret; 2882*38c8a9a5SSteve French struct folio *folio = fbatch.folios[i]; 2883*38c8a9a5SSteve French 2884*38c8a9a5SSteve French redo_folio: 2885*38c8a9a5SSteve French start = folio_pos(folio); /* May regress with THPs */ 2886*38c8a9a5SSteve French 2887*38c8a9a5SSteve French /* At this point we hold neither the i_pages lock nor the 2888*38c8a9a5SSteve French * page lock: the page may be truncated or invalidated 2889*38c8a9a5SSteve French * (changing page->mapping to NULL), or even swizzled 2890*38c8a9a5SSteve French * back from swapper_space to tmpfs file mapping 2891*38c8a9a5SSteve French */ 2892*38c8a9a5SSteve French if (wbc->sync_mode != WB_SYNC_NONE) { 2893*38c8a9a5SSteve French ret = folio_lock_killable(folio); 2894*38c8a9a5SSteve French if (ret < 0) 2895*38c8a9a5SSteve French goto write_error; 2896*38c8a9a5SSteve French } else { 2897*38c8a9a5SSteve French if (!folio_trylock(folio)) 2898*38c8a9a5SSteve French goto skip_write; 2899*38c8a9a5SSteve French } 2900*38c8a9a5SSteve French 2901*38c8a9a5SSteve French if (folio_mapping(folio) != mapping || 2902*38c8a9a5SSteve French !folio_test_dirty(folio)) { 2903*38c8a9a5SSteve French start += folio_size(folio); 2904*38c8a9a5SSteve French folio_unlock(folio); 2905*38c8a9a5SSteve French continue; 2906*38c8a9a5SSteve French } 2907*38c8a9a5SSteve French 2908*38c8a9a5SSteve French if (folio_test_writeback(folio) || 2909*38c8a9a5SSteve French folio_test_fscache(folio)) { 2910*38c8a9a5SSteve French folio_unlock(folio); 2911*38c8a9a5SSteve French if (wbc->sync_mode == WB_SYNC_NONE) 2912*38c8a9a5SSteve French goto skip_write; 2913*38c8a9a5SSteve French 2914*38c8a9a5SSteve French folio_wait_writeback(folio); 2915*38c8a9a5SSteve French #ifdef CONFIG_CIFS_FSCACHE 2916*38c8a9a5SSteve French folio_wait_fscache(folio); 2917*38c8a9a5SSteve French #endif 2918*38c8a9a5SSteve French goto redo_folio; 2919*38c8a9a5SSteve French } 2920*38c8a9a5SSteve French 2921*38c8a9a5SSteve French if (!folio_clear_dirty_for_io(folio)) 2922*38c8a9a5SSteve French /* We hold the page lock - it should've been dirty. */ 2923*38c8a9a5SSteve French WARN_ON(1); 2924*38c8a9a5SSteve French 2925*38c8a9a5SSteve French ret = cifs_write_back_from_locked_folio(mapping, wbc, folio, start, end); 2926*38c8a9a5SSteve French if (ret < 0) 2927*38c8a9a5SSteve French goto write_error; 2928*38c8a9a5SSteve French 2929*38c8a9a5SSteve French start += ret; 2930*38c8a9a5SSteve French continue; 2931*38c8a9a5SSteve French 2932*38c8a9a5SSteve French write_error: 2933*38c8a9a5SSteve French folio_batch_release(&fbatch); 2934*38c8a9a5SSteve French *_next = start; 2935*38c8a9a5SSteve French return ret; 2936*38c8a9a5SSteve French 2937*38c8a9a5SSteve French skip_write: 2938*38c8a9a5SSteve French /* 2939*38c8a9a5SSteve French * Too many skipped writes, or need to reschedule? 2940*38c8a9a5SSteve French * Treat it as a write error without an error code. 2941*38c8a9a5SSteve French */ 2942*38c8a9a5SSteve French if (skips >= 5 || need_resched()) { 2943*38c8a9a5SSteve French ret = 0; 2944*38c8a9a5SSteve French goto write_error; 2945*38c8a9a5SSteve French } 2946*38c8a9a5SSteve French 2947*38c8a9a5SSteve French /* Otherwise, just skip that folio and go on to the next */ 2948*38c8a9a5SSteve French skips++; 2949*38c8a9a5SSteve French start += folio_size(folio); 2950*38c8a9a5SSteve French continue; 2951*38c8a9a5SSteve French } 2952*38c8a9a5SSteve French 2953*38c8a9a5SSteve French folio_batch_release(&fbatch); 2954*38c8a9a5SSteve French cond_resched(); 2955*38c8a9a5SSteve French } while (wbc->nr_to_write > 0); 2956*38c8a9a5SSteve French 2957*38c8a9a5SSteve French *_next = start; 2958*38c8a9a5SSteve French return 0; 2959*38c8a9a5SSteve French } 2960*38c8a9a5SSteve French 2961*38c8a9a5SSteve French /* 2962*38c8a9a5SSteve French * Write some of the pending data back to the server 2963*38c8a9a5SSteve French */ 2964*38c8a9a5SSteve French static int cifs_writepages(struct address_space *mapping, 2965*38c8a9a5SSteve French struct writeback_control *wbc) 2966*38c8a9a5SSteve French { 2967*38c8a9a5SSteve French loff_t start, next; 2968*38c8a9a5SSteve French int ret; 2969*38c8a9a5SSteve French 2970*38c8a9a5SSteve French /* We have to be careful as we can end up racing with setattr() 2971*38c8a9a5SSteve French * truncating the pagecache since the caller doesn't take a lock here 2972*38c8a9a5SSteve French * to prevent it. 2973*38c8a9a5SSteve French */ 2974*38c8a9a5SSteve French 2975*38c8a9a5SSteve French if (wbc->range_cyclic) { 2976*38c8a9a5SSteve French start = mapping->writeback_index * PAGE_SIZE; 2977*38c8a9a5SSteve French ret = cifs_writepages_region(mapping, wbc, start, LLONG_MAX, &next); 2978*38c8a9a5SSteve French if (ret == 0) { 2979*38c8a9a5SSteve French mapping->writeback_index = next / PAGE_SIZE; 2980*38c8a9a5SSteve French if (start > 0 && wbc->nr_to_write > 0) { 2981*38c8a9a5SSteve French ret = cifs_writepages_region(mapping, wbc, 0, 2982*38c8a9a5SSteve French start, &next); 2983*38c8a9a5SSteve French if (ret == 0) 2984*38c8a9a5SSteve French mapping->writeback_index = 2985*38c8a9a5SSteve French next / PAGE_SIZE; 2986*38c8a9a5SSteve French } 2987*38c8a9a5SSteve French } 2988*38c8a9a5SSteve French } else if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX) { 2989*38c8a9a5SSteve French ret = cifs_writepages_region(mapping, wbc, 0, LLONG_MAX, &next); 2990*38c8a9a5SSteve French if (wbc->nr_to_write > 0 && ret == 0) 2991*38c8a9a5SSteve French mapping->writeback_index = next / PAGE_SIZE; 2992*38c8a9a5SSteve French } else { 2993*38c8a9a5SSteve French ret = cifs_writepages_region(mapping, wbc, 2994*38c8a9a5SSteve French wbc->range_start, wbc->range_end, &next); 2995*38c8a9a5SSteve French } 2996*38c8a9a5SSteve French 2997*38c8a9a5SSteve French return ret; 2998*38c8a9a5SSteve French } 2999*38c8a9a5SSteve French 3000*38c8a9a5SSteve French static int 3001*38c8a9a5SSteve French cifs_writepage_locked(struct page *page, struct writeback_control *wbc) 3002*38c8a9a5SSteve French { 3003*38c8a9a5SSteve French int rc; 3004*38c8a9a5SSteve French unsigned int xid; 3005*38c8a9a5SSteve French 3006*38c8a9a5SSteve French xid = get_xid(); 3007*38c8a9a5SSteve French /* BB add check for wbc flags */ 3008*38c8a9a5SSteve French get_page(page); 3009*38c8a9a5SSteve French if (!PageUptodate(page)) 3010*38c8a9a5SSteve French cifs_dbg(FYI, "ppw - page not up to date\n"); 3011*38c8a9a5SSteve French 3012*38c8a9a5SSteve French /* 3013*38c8a9a5SSteve French * Set the "writeback" flag, and clear "dirty" in the radix tree. 3014*38c8a9a5SSteve French * 3015*38c8a9a5SSteve French * A writepage() implementation always needs to do either this, 3016*38c8a9a5SSteve French * or re-dirty the page with "redirty_page_for_writepage()" in 3017*38c8a9a5SSteve French * the case of a failure. 3018*38c8a9a5SSteve French * 3019*38c8a9a5SSteve French * Just unlocking the page will cause the radix tree tag-bits 3020*38c8a9a5SSteve French * to fail to update with the state of the page correctly. 3021*38c8a9a5SSteve French */ 3022*38c8a9a5SSteve French set_page_writeback(page); 3023*38c8a9a5SSteve French retry_write: 3024*38c8a9a5SSteve French rc = cifs_partialpagewrite(page, 0, PAGE_SIZE); 3025*38c8a9a5SSteve French if (is_retryable_error(rc)) { 3026*38c8a9a5SSteve French if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) 3027*38c8a9a5SSteve French goto retry_write; 3028*38c8a9a5SSteve French redirty_page_for_writepage(wbc, page); 3029*38c8a9a5SSteve French } else if (rc != 0) { 3030*38c8a9a5SSteve French SetPageError(page); 3031*38c8a9a5SSteve French mapping_set_error(page->mapping, rc); 3032*38c8a9a5SSteve French } else { 3033*38c8a9a5SSteve French SetPageUptodate(page); 3034*38c8a9a5SSteve French } 3035*38c8a9a5SSteve French end_page_writeback(page); 3036*38c8a9a5SSteve French put_page(page); 3037*38c8a9a5SSteve French free_xid(xid); 3038*38c8a9a5SSteve French return rc; 3039*38c8a9a5SSteve French } 3040*38c8a9a5SSteve French 3041*38c8a9a5SSteve French static int cifs_write_end(struct file *file, struct address_space *mapping, 3042*38c8a9a5SSteve French loff_t pos, unsigned len, unsigned copied, 3043*38c8a9a5SSteve French struct page *page, void *fsdata) 3044*38c8a9a5SSteve French { 3045*38c8a9a5SSteve French int rc; 3046*38c8a9a5SSteve French struct inode *inode = mapping->host; 3047*38c8a9a5SSteve French struct cifsFileInfo *cfile = file->private_data; 3048*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb); 3049*38c8a9a5SSteve French struct folio *folio = page_folio(page); 3050*38c8a9a5SSteve French __u32 pid; 3051*38c8a9a5SSteve French 3052*38c8a9a5SSteve French if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD) 3053*38c8a9a5SSteve French pid = cfile->pid; 3054*38c8a9a5SSteve French else 3055*38c8a9a5SSteve French pid = current->tgid; 3056*38c8a9a5SSteve French 3057*38c8a9a5SSteve French cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n", 3058*38c8a9a5SSteve French page, pos, copied); 3059*38c8a9a5SSteve French 3060*38c8a9a5SSteve French if (folio_test_checked(folio)) { 3061*38c8a9a5SSteve French if (copied == len) 3062*38c8a9a5SSteve French folio_mark_uptodate(folio); 3063*38c8a9a5SSteve French folio_clear_checked(folio); 3064*38c8a9a5SSteve French } else if (!folio_test_uptodate(folio) && copied == PAGE_SIZE) 3065*38c8a9a5SSteve French folio_mark_uptodate(folio); 3066*38c8a9a5SSteve French 3067*38c8a9a5SSteve French if (!folio_test_uptodate(folio)) { 3068*38c8a9a5SSteve French char *page_data; 3069*38c8a9a5SSteve French unsigned offset = pos & (PAGE_SIZE - 1); 3070*38c8a9a5SSteve French unsigned int xid; 3071*38c8a9a5SSteve French 3072*38c8a9a5SSteve French xid = get_xid(); 3073*38c8a9a5SSteve French /* this is probably better than directly calling 3074*38c8a9a5SSteve French partialpage_write since in this function the file handle is 3075*38c8a9a5SSteve French known which we might as well leverage */ 3076*38c8a9a5SSteve French /* BB check if anything else missing out of ppw 3077*38c8a9a5SSteve French such as updating last write time */ 3078*38c8a9a5SSteve French page_data = kmap(page); 3079*38c8a9a5SSteve French rc = cifs_write(cfile, pid, page_data + offset, copied, &pos); 3080*38c8a9a5SSteve French /* if (rc < 0) should we set writebehind rc? */ 3081*38c8a9a5SSteve French kunmap(page); 3082*38c8a9a5SSteve French 3083*38c8a9a5SSteve French free_xid(xid); 3084*38c8a9a5SSteve French } else { 3085*38c8a9a5SSteve French rc = copied; 3086*38c8a9a5SSteve French pos += copied; 3087*38c8a9a5SSteve French set_page_dirty(page); 3088*38c8a9a5SSteve French } 3089*38c8a9a5SSteve French 3090*38c8a9a5SSteve French if (rc > 0) { 3091*38c8a9a5SSteve French spin_lock(&inode->i_lock); 3092*38c8a9a5SSteve French if (pos > inode->i_size) { 3093*38c8a9a5SSteve French i_size_write(inode, pos); 3094*38c8a9a5SSteve French inode->i_blocks = (512 - 1 + pos) >> 9; 3095*38c8a9a5SSteve French } 3096*38c8a9a5SSteve French spin_unlock(&inode->i_lock); 3097*38c8a9a5SSteve French } 3098*38c8a9a5SSteve French 3099*38c8a9a5SSteve French unlock_page(page); 3100*38c8a9a5SSteve French put_page(page); 3101*38c8a9a5SSteve French /* Indication to update ctime and mtime as close is deferred */ 3102*38c8a9a5SSteve French set_bit(CIFS_INO_MODIFIED_ATTR, &CIFS_I(inode)->flags); 3103*38c8a9a5SSteve French 3104*38c8a9a5SSteve French return rc; 3105*38c8a9a5SSteve French } 3106*38c8a9a5SSteve French 3107*38c8a9a5SSteve French int cifs_strict_fsync(struct file *file, loff_t start, loff_t end, 3108*38c8a9a5SSteve French int datasync) 3109*38c8a9a5SSteve French { 3110*38c8a9a5SSteve French unsigned int xid; 3111*38c8a9a5SSteve French int rc = 0; 3112*38c8a9a5SSteve French struct cifs_tcon *tcon; 3113*38c8a9a5SSteve French struct TCP_Server_Info *server; 3114*38c8a9a5SSteve French struct cifsFileInfo *smbfile = file->private_data; 3115*38c8a9a5SSteve French struct inode *inode = file_inode(file); 3116*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 3117*38c8a9a5SSteve French 3118*38c8a9a5SSteve French rc = file_write_and_wait_range(file, start, end); 3119*38c8a9a5SSteve French if (rc) { 3120*38c8a9a5SSteve French trace_cifs_fsync_err(inode->i_ino, rc); 3121*38c8a9a5SSteve French return rc; 3122*38c8a9a5SSteve French } 3123*38c8a9a5SSteve French 3124*38c8a9a5SSteve French xid = get_xid(); 3125*38c8a9a5SSteve French 3126*38c8a9a5SSteve French cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n", 3127*38c8a9a5SSteve French file, datasync); 3128*38c8a9a5SSteve French 3129*38c8a9a5SSteve French if (!CIFS_CACHE_READ(CIFS_I(inode))) { 3130*38c8a9a5SSteve French rc = cifs_zap_mapping(inode); 3131*38c8a9a5SSteve French if (rc) { 3132*38c8a9a5SSteve French cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc); 3133*38c8a9a5SSteve French rc = 0; /* don't care about it in fsync */ 3134*38c8a9a5SSteve French } 3135*38c8a9a5SSteve French } 3136*38c8a9a5SSteve French 3137*38c8a9a5SSteve French tcon = tlink_tcon(smbfile->tlink); 3138*38c8a9a5SSteve French if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) { 3139*38c8a9a5SSteve French server = tcon->ses->server; 3140*38c8a9a5SSteve French if (server->ops->flush == NULL) { 3141*38c8a9a5SSteve French rc = -ENOSYS; 3142*38c8a9a5SSteve French goto strict_fsync_exit; 3143*38c8a9a5SSteve French } 3144*38c8a9a5SSteve French 3145*38c8a9a5SSteve French if ((OPEN_FMODE(smbfile->f_flags) & FMODE_WRITE) == 0) { 3146*38c8a9a5SSteve French smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY); 3147*38c8a9a5SSteve French if (smbfile) { 3148*38c8a9a5SSteve French rc = server->ops->flush(xid, tcon, &smbfile->fid); 3149*38c8a9a5SSteve French cifsFileInfo_put(smbfile); 3150*38c8a9a5SSteve French } else 3151*38c8a9a5SSteve French cifs_dbg(FYI, "ignore fsync for file not open for write\n"); 3152*38c8a9a5SSteve French } else 3153*38c8a9a5SSteve French rc = server->ops->flush(xid, tcon, &smbfile->fid); 3154*38c8a9a5SSteve French } 3155*38c8a9a5SSteve French 3156*38c8a9a5SSteve French strict_fsync_exit: 3157*38c8a9a5SSteve French free_xid(xid); 3158*38c8a9a5SSteve French return rc; 3159*38c8a9a5SSteve French } 3160*38c8a9a5SSteve French 3161*38c8a9a5SSteve French int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync) 3162*38c8a9a5SSteve French { 3163*38c8a9a5SSteve French unsigned int xid; 3164*38c8a9a5SSteve French int rc = 0; 3165*38c8a9a5SSteve French struct cifs_tcon *tcon; 3166*38c8a9a5SSteve French struct TCP_Server_Info *server; 3167*38c8a9a5SSteve French struct cifsFileInfo *smbfile = file->private_data; 3168*38c8a9a5SSteve French struct inode *inode = file_inode(file); 3169*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file); 3170*38c8a9a5SSteve French 3171*38c8a9a5SSteve French rc = file_write_and_wait_range(file, start, end); 3172*38c8a9a5SSteve French if (rc) { 3173*38c8a9a5SSteve French trace_cifs_fsync_err(file_inode(file)->i_ino, rc); 3174*38c8a9a5SSteve French return rc; 3175*38c8a9a5SSteve French } 3176*38c8a9a5SSteve French 3177*38c8a9a5SSteve French xid = get_xid(); 3178*38c8a9a5SSteve French 3179*38c8a9a5SSteve French cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n", 3180*38c8a9a5SSteve French file, datasync); 3181*38c8a9a5SSteve French 3182*38c8a9a5SSteve French tcon = tlink_tcon(smbfile->tlink); 3183*38c8a9a5SSteve French if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) { 3184*38c8a9a5SSteve French server = tcon->ses->server; 3185*38c8a9a5SSteve French if (server->ops->flush == NULL) { 3186*38c8a9a5SSteve French rc = -ENOSYS; 3187*38c8a9a5SSteve French goto fsync_exit; 3188*38c8a9a5SSteve French } 3189*38c8a9a5SSteve French 3190*38c8a9a5SSteve French if ((OPEN_FMODE(smbfile->f_flags) & FMODE_WRITE) == 0) { 3191*38c8a9a5SSteve French smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY); 3192*38c8a9a5SSteve French if (smbfile) { 3193*38c8a9a5SSteve French rc = server->ops->flush(xid, tcon, &smbfile->fid); 3194*38c8a9a5SSteve French cifsFileInfo_put(smbfile); 3195*38c8a9a5SSteve French } else 3196*38c8a9a5SSteve French cifs_dbg(FYI, "ignore fsync for file not open for write\n"); 3197*38c8a9a5SSteve French } else 3198*38c8a9a5SSteve French rc = server->ops->flush(xid, tcon, &smbfile->fid); 3199*38c8a9a5SSteve French } 3200*38c8a9a5SSteve French 3201*38c8a9a5SSteve French fsync_exit: 3202*38c8a9a5SSteve French free_xid(xid); 3203*38c8a9a5SSteve French return rc; 3204*38c8a9a5SSteve French } 3205*38c8a9a5SSteve French 3206*38c8a9a5SSteve French /* 3207*38c8a9a5SSteve French * As file closes, flush all cached write data for this inode checking 3208*38c8a9a5SSteve French * for write behind errors. 3209*38c8a9a5SSteve French */ 3210*38c8a9a5SSteve French int cifs_flush(struct file *file, fl_owner_t id) 3211*38c8a9a5SSteve French { 3212*38c8a9a5SSteve French struct inode *inode = file_inode(file); 3213*38c8a9a5SSteve French int rc = 0; 3214*38c8a9a5SSteve French 3215*38c8a9a5SSteve French if (file->f_mode & FMODE_WRITE) 3216*38c8a9a5SSteve French rc = filemap_write_and_wait(inode->i_mapping); 3217*38c8a9a5SSteve French 3218*38c8a9a5SSteve French cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc); 3219*38c8a9a5SSteve French if (rc) { 3220*38c8a9a5SSteve French /* get more nuanced writeback errors */ 3221*38c8a9a5SSteve French rc = filemap_check_wb_err(file->f_mapping, 0); 3222*38c8a9a5SSteve French trace_cifs_flush_err(inode->i_ino, rc); 3223*38c8a9a5SSteve French } 3224*38c8a9a5SSteve French return rc; 3225*38c8a9a5SSteve French } 3226*38c8a9a5SSteve French 3227*38c8a9a5SSteve French static void 3228*38c8a9a5SSteve French cifs_uncached_writedata_release(struct kref *refcount) 3229*38c8a9a5SSteve French { 3230*38c8a9a5SSteve French struct cifs_writedata *wdata = container_of(refcount, 3231*38c8a9a5SSteve French struct cifs_writedata, refcount); 3232*38c8a9a5SSteve French 3233*38c8a9a5SSteve French kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release); 3234*38c8a9a5SSteve French cifs_writedata_release(refcount); 3235*38c8a9a5SSteve French } 3236*38c8a9a5SSteve French 3237*38c8a9a5SSteve French static void collect_uncached_write_data(struct cifs_aio_ctx *ctx); 3238*38c8a9a5SSteve French 3239*38c8a9a5SSteve French static void 3240*38c8a9a5SSteve French cifs_uncached_writev_complete(struct work_struct *work) 3241*38c8a9a5SSteve French { 3242*38c8a9a5SSteve French struct cifs_writedata *wdata = container_of(work, 3243*38c8a9a5SSteve French struct cifs_writedata, work); 3244*38c8a9a5SSteve French struct inode *inode = d_inode(wdata->cfile->dentry); 3245*38c8a9a5SSteve French struct cifsInodeInfo *cifsi = CIFS_I(inode); 3246*38c8a9a5SSteve French 3247*38c8a9a5SSteve French spin_lock(&inode->i_lock); 3248*38c8a9a5SSteve French cifs_update_eof(cifsi, wdata->offset, wdata->bytes); 3249*38c8a9a5SSteve French if (cifsi->server_eof > inode->i_size) 3250*38c8a9a5SSteve French i_size_write(inode, cifsi->server_eof); 3251*38c8a9a5SSteve French spin_unlock(&inode->i_lock); 3252*38c8a9a5SSteve French 3253*38c8a9a5SSteve French complete(&wdata->done); 3254*38c8a9a5SSteve French collect_uncached_write_data(wdata->ctx); 3255*38c8a9a5SSteve French /* the below call can possibly free the last ref to aio ctx */ 3256*38c8a9a5SSteve French kref_put(&wdata->refcount, cifs_uncached_writedata_release); 3257*38c8a9a5SSteve French } 3258*38c8a9a5SSteve French 3259*38c8a9a5SSteve French static int 3260*38c8a9a5SSteve French cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list, 3261*38c8a9a5SSteve French struct cifs_aio_ctx *ctx) 3262*38c8a9a5SSteve French { 3263*38c8a9a5SSteve French unsigned int wsize; 3264*38c8a9a5SSteve French struct cifs_credits credits; 3265*38c8a9a5SSteve French int rc; 3266*38c8a9a5SSteve French struct TCP_Server_Info *server = wdata->server; 3267*38c8a9a5SSteve French 3268*38c8a9a5SSteve French do { 3269*38c8a9a5SSteve French if (wdata->cfile->invalidHandle) { 3270*38c8a9a5SSteve French rc = cifs_reopen_file(wdata->cfile, false); 3271*38c8a9a5SSteve French if (rc == -EAGAIN) 3272*38c8a9a5SSteve French continue; 3273*38c8a9a5SSteve French else if (rc) 3274*38c8a9a5SSteve French break; 3275*38c8a9a5SSteve French } 3276*38c8a9a5SSteve French 3277*38c8a9a5SSteve French 3278*38c8a9a5SSteve French /* 3279*38c8a9a5SSteve French * Wait for credits to resend this wdata. 3280*38c8a9a5SSteve French * Note: we are attempting to resend the whole wdata not in 3281*38c8a9a5SSteve French * segments 3282*38c8a9a5SSteve French */ 3283*38c8a9a5SSteve French do { 3284*38c8a9a5SSteve French rc = server->ops->wait_mtu_credits(server, wdata->bytes, 3285*38c8a9a5SSteve French &wsize, &credits); 3286*38c8a9a5SSteve French if (rc) 3287*38c8a9a5SSteve French goto fail; 3288*38c8a9a5SSteve French 3289*38c8a9a5SSteve French if (wsize < wdata->bytes) { 3290*38c8a9a5SSteve French add_credits_and_wake_if(server, &credits, 0); 3291*38c8a9a5SSteve French msleep(1000); 3292*38c8a9a5SSteve French } 3293*38c8a9a5SSteve French } while (wsize < wdata->bytes); 3294*38c8a9a5SSteve French wdata->credits = credits; 3295*38c8a9a5SSteve French 3296*38c8a9a5SSteve French rc = adjust_credits(server, &wdata->credits, wdata->bytes); 3297*38c8a9a5SSteve French 3298*38c8a9a5SSteve French if (!rc) { 3299*38c8a9a5SSteve French if (wdata->cfile->invalidHandle) 3300*38c8a9a5SSteve French rc = -EAGAIN; 3301*38c8a9a5SSteve French else { 3302*38c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 3303*38c8a9a5SSteve French if (wdata->mr) { 3304*38c8a9a5SSteve French wdata->mr->need_invalidate = true; 3305*38c8a9a5SSteve French smbd_deregister_mr(wdata->mr); 3306*38c8a9a5SSteve French wdata->mr = NULL; 3307*38c8a9a5SSteve French } 3308*38c8a9a5SSteve French #endif 3309*38c8a9a5SSteve French rc = server->ops->async_writev(wdata, 3310*38c8a9a5SSteve French cifs_uncached_writedata_release); 3311*38c8a9a5SSteve French } 3312*38c8a9a5SSteve French } 3313*38c8a9a5SSteve French 3314*38c8a9a5SSteve French /* If the write was successfully sent, we are done */ 3315*38c8a9a5SSteve French if (!rc) { 3316*38c8a9a5SSteve French list_add_tail(&wdata->list, wdata_list); 3317*38c8a9a5SSteve French return 0; 3318*38c8a9a5SSteve French } 3319*38c8a9a5SSteve French 3320*38c8a9a5SSteve French /* Roll back credits and retry if needed */ 3321*38c8a9a5SSteve French add_credits_and_wake_if(server, &wdata->credits, 0); 3322*38c8a9a5SSteve French } while (rc == -EAGAIN); 3323*38c8a9a5SSteve French 3324*38c8a9a5SSteve French fail: 3325*38c8a9a5SSteve French kref_put(&wdata->refcount, cifs_uncached_writedata_release); 3326*38c8a9a5SSteve French return rc; 3327*38c8a9a5SSteve French } 3328*38c8a9a5SSteve French 3329*38c8a9a5SSteve French /* 3330*38c8a9a5SSteve French * Select span of a bvec iterator we're going to use. Limit it by both maximum 3331*38c8a9a5SSteve French * size and maximum number of segments. 3332*38c8a9a5SSteve French */ 3333*38c8a9a5SSteve French static size_t cifs_limit_bvec_subset(const struct iov_iter *iter, size_t max_size, 3334*38c8a9a5SSteve French size_t max_segs, unsigned int *_nsegs) 3335*38c8a9a5SSteve French { 3336*38c8a9a5SSteve French const struct bio_vec *bvecs = iter->bvec; 3337*38c8a9a5SSteve French unsigned int nbv = iter->nr_segs, ix = 0, nsegs = 0; 3338*38c8a9a5SSteve French size_t len, span = 0, n = iter->count; 3339*38c8a9a5SSteve French size_t skip = iter->iov_offset; 3340*38c8a9a5SSteve French 3341*38c8a9a5SSteve French if (WARN_ON(!iov_iter_is_bvec(iter)) || n == 0) 3342*38c8a9a5SSteve French return 0; 3343*38c8a9a5SSteve French 3344*38c8a9a5SSteve French while (n && ix < nbv && skip) { 3345*38c8a9a5SSteve French len = bvecs[ix].bv_len; 3346*38c8a9a5SSteve French if (skip < len) 3347*38c8a9a5SSteve French break; 3348*38c8a9a5SSteve French skip -= len; 3349*38c8a9a5SSteve French n -= len; 3350*38c8a9a5SSteve French ix++; 3351*38c8a9a5SSteve French } 3352*38c8a9a5SSteve French 3353*38c8a9a5SSteve French while (n && ix < nbv) { 3354*38c8a9a5SSteve French len = min3(n, bvecs[ix].bv_len - skip, max_size); 3355*38c8a9a5SSteve French span += len; 3356*38c8a9a5SSteve French max_size -= len; 3357*38c8a9a5SSteve French nsegs++; 3358*38c8a9a5SSteve French ix++; 3359*38c8a9a5SSteve French if (max_size == 0 || nsegs >= max_segs) 3360*38c8a9a5SSteve French break; 3361*38c8a9a5SSteve French skip = 0; 3362*38c8a9a5SSteve French n -= len; 3363*38c8a9a5SSteve French } 3364*38c8a9a5SSteve French 3365*38c8a9a5SSteve French *_nsegs = nsegs; 3366*38c8a9a5SSteve French return span; 3367*38c8a9a5SSteve French } 3368*38c8a9a5SSteve French 3369*38c8a9a5SSteve French static int 3370*38c8a9a5SSteve French cifs_write_from_iter(loff_t fpos, size_t len, struct iov_iter *from, 3371*38c8a9a5SSteve French struct cifsFileInfo *open_file, 3372*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb, struct list_head *wdata_list, 3373*38c8a9a5SSteve French struct cifs_aio_ctx *ctx) 3374*38c8a9a5SSteve French { 3375*38c8a9a5SSteve French int rc = 0; 3376*38c8a9a5SSteve French size_t cur_len, max_len; 3377*38c8a9a5SSteve French struct cifs_writedata *wdata; 3378*38c8a9a5SSteve French pid_t pid; 3379*38c8a9a5SSteve French struct TCP_Server_Info *server; 3380*38c8a9a5SSteve French unsigned int xid, max_segs = INT_MAX; 3381*38c8a9a5SSteve French 3382*38c8a9a5SSteve French if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD) 3383*38c8a9a5SSteve French pid = open_file->pid; 3384*38c8a9a5SSteve French else 3385*38c8a9a5SSteve French pid = current->tgid; 3386*38c8a9a5SSteve French 3387*38c8a9a5SSteve French server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses); 3388*38c8a9a5SSteve French xid = get_xid(); 3389*38c8a9a5SSteve French 3390*38c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 3391*38c8a9a5SSteve French if (server->smbd_conn) 3392*38c8a9a5SSteve French max_segs = server->smbd_conn->max_frmr_depth; 3393*38c8a9a5SSteve French #endif 3394*38c8a9a5SSteve French 3395*38c8a9a5SSteve French do { 3396*38c8a9a5SSteve French struct cifs_credits credits_on_stack; 3397*38c8a9a5SSteve French struct cifs_credits *credits = &credits_on_stack; 3398*38c8a9a5SSteve French unsigned int wsize, nsegs = 0; 3399*38c8a9a5SSteve French 3400*38c8a9a5SSteve French if (signal_pending(current)) { 3401*38c8a9a5SSteve French rc = -EINTR; 3402*38c8a9a5SSteve French break; 3403*38c8a9a5SSteve French } 3404*38c8a9a5SSteve French 3405*38c8a9a5SSteve French if (open_file->invalidHandle) { 3406*38c8a9a5SSteve French rc = cifs_reopen_file(open_file, false); 3407*38c8a9a5SSteve French if (rc == -EAGAIN) 3408*38c8a9a5SSteve French continue; 3409*38c8a9a5SSteve French else if (rc) 3410*38c8a9a5SSteve French break; 3411*38c8a9a5SSteve French } 3412*38c8a9a5SSteve French 3413*38c8a9a5SSteve French rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->wsize, 3414*38c8a9a5SSteve French &wsize, credits); 3415*38c8a9a5SSteve French if (rc) 3416*38c8a9a5SSteve French break; 3417*38c8a9a5SSteve French 3418*38c8a9a5SSteve French max_len = min_t(const size_t, len, wsize); 3419*38c8a9a5SSteve French if (!max_len) { 3420*38c8a9a5SSteve French rc = -EAGAIN; 3421*38c8a9a5SSteve French add_credits_and_wake_if(server, credits, 0); 3422*38c8a9a5SSteve French break; 3423*38c8a9a5SSteve French } 3424*38c8a9a5SSteve French 3425*38c8a9a5SSteve French cur_len = cifs_limit_bvec_subset(from, max_len, max_segs, &nsegs); 3426*38c8a9a5SSteve French cifs_dbg(FYI, "write_from_iter len=%zx/%zx nsegs=%u/%lu/%u\n", 3427*38c8a9a5SSteve French cur_len, max_len, nsegs, from->nr_segs, max_segs); 3428*38c8a9a5SSteve French if (cur_len == 0) { 3429*38c8a9a5SSteve French rc = -EIO; 3430*38c8a9a5SSteve French add_credits_and_wake_if(server, credits, 0); 3431*38c8a9a5SSteve French break; 3432*38c8a9a5SSteve French } 3433*38c8a9a5SSteve French 3434*38c8a9a5SSteve French wdata = cifs_writedata_alloc(cifs_uncached_writev_complete); 3435*38c8a9a5SSteve French if (!wdata) { 3436*38c8a9a5SSteve French rc = -ENOMEM; 3437*38c8a9a5SSteve French add_credits_and_wake_if(server, credits, 0); 3438*38c8a9a5SSteve French break; 3439*38c8a9a5SSteve French } 3440*38c8a9a5SSteve French 3441*38c8a9a5SSteve French wdata->sync_mode = WB_SYNC_ALL; 3442*38c8a9a5SSteve French wdata->offset = (__u64)fpos; 3443*38c8a9a5SSteve French wdata->cfile = cifsFileInfo_get(open_file); 3444*38c8a9a5SSteve French wdata->server = server; 3445*38c8a9a5SSteve French wdata->pid = pid; 3446*38c8a9a5SSteve French wdata->bytes = cur_len; 3447*38c8a9a5SSteve French wdata->credits = credits_on_stack; 3448*38c8a9a5SSteve French wdata->iter = *from; 3449*38c8a9a5SSteve French wdata->ctx = ctx; 3450*38c8a9a5SSteve French kref_get(&ctx->refcount); 3451*38c8a9a5SSteve French 3452*38c8a9a5SSteve French iov_iter_truncate(&wdata->iter, cur_len); 3453*38c8a9a5SSteve French 3454*38c8a9a5SSteve French rc = adjust_credits(server, &wdata->credits, wdata->bytes); 3455*38c8a9a5SSteve French 3456*38c8a9a5SSteve French if (!rc) { 3457*38c8a9a5SSteve French if (wdata->cfile->invalidHandle) 3458*38c8a9a5SSteve French rc = -EAGAIN; 3459*38c8a9a5SSteve French else 3460*38c8a9a5SSteve French rc = server->ops->async_writev(wdata, 3461*38c8a9a5SSteve French cifs_uncached_writedata_release); 3462*38c8a9a5SSteve French } 3463*38c8a9a5SSteve French 3464*38c8a9a5SSteve French if (rc) { 3465*38c8a9a5SSteve French add_credits_and_wake_if(server, &wdata->credits, 0); 3466*38c8a9a5SSteve French kref_put(&wdata->refcount, 3467*38c8a9a5SSteve French cifs_uncached_writedata_release); 3468*38c8a9a5SSteve French if (rc == -EAGAIN) 3469*38c8a9a5SSteve French continue; 3470*38c8a9a5SSteve French break; 3471*38c8a9a5SSteve French } 3472*38c8a9a5SSteve French 3473*38c8a9a5SSteve French list_add_tail(&wdata->list, wdata_list); 3474*38c8a9a5SSteve French iov_iter_advance(from, cur_len); 3475*38c8a9a5SSteve French fpos += cur_len; 3476*38c8a9a5SSteve French len -= cur_len; 3477*38c8a9a5SSteve French } while (len > 0); 3478*38c8a9a5SSteve French 3479*38c8a9a5SSteve French free_xid(xid); 3480*38c8a9a5SSteve French return rc; 3481*38c8a9a5SSteve French } 3482*38c8a9a5SSteve French 3483*38c8a9a5SSteve French static void collect_uncached_write_data(struct cifs_aio_ctx *ctx) 3484*38c8a9a5SSteve French { 3485*38c8a9a5SSteve French struct cifs_writedata *wdata, *tmp; 3486*38c8a9a5SSteve French struct cifs_tcon *tcon; 3487*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb; 3488*38c8a9a5SSteve French struct dentry *dentry = ctx->cfile->dentry; 3489*38c8a9a5SSteve French ssize_t rc; 3490*38c8a9a5SSteve French 3491*38c8a9a5SSteve French tcon = tlink_tcon(ctx->cfile->tlink); 3492*38c8a9a5SSteve French cifs_sb = CIFS_SB(dentry->d_sb); 3493*38c8a9a5SSteve French 3494*38c8a9a5SSteve French mutex_lock(&ctx->aio_mutex); 3495*38c8a9a5SSteve French 3496*38c8a9a5SSteve French if (list_empty(&ctx->list)) { 3497*38c8a9a5SSteve French mutex_unlock(&ctx->aio_mutex); 3498*38c8a9a5SSteve French return; 3499*38c8a9a5SSteve French } 3500*38c8a9a5SSteve French 3501*38c8a9a5SSteve French rc = ctx->rc; 3502*38c8a9a5SSteve French /* 3503*38c8a9a5SSteve French * Wait for and collect replies for any successful sends in order of 3504*38c8a9a5SSteve French * increasing offset. Once an error is hit, then return without waiting 3505*38c8a9a5SSteve French * for any more replies. 3506*38c8a9a5SSteve French */ 3507*38c8a9a5SSteve French restart_loop: 3508*38c8a9a5SSteve French list_for_each_entry_safe(wdata, tmp, &ctx->list, list) { 3509*38c8a9a5SSteve French if (!rc) { 3510*38c8a9a5SSteve French if (!try_wait_for_completion(&wdata->done)) { 3511*38c8a9a5SSteve French mutex_unlock(&ctx->aio_mutex); 3512*38c8a9a5SSteve French return; 3513*38c8a9a5SSteve French } 3514*38c8a9a5SSteve French 3515*38c8a9a5SSteve French if (wdata->result) 3516*38c8a9a5SSteve French rc = wdata->result; 3517*38c8a9a5SSteve French else 3518*38c8a9a5SSteve French ctx->total_len += wdata->bytes; 3519*38c8a9a5SSteve French 3520*38c8a9a5SSteve French /* resend call if it's a retryable error */ 3521*38c8a9a5SSteve French if (rc == -EAGAIN) { 3522*38c8a9a5SSteve French struct list_head tmp_list; 3523*38c8a9a5SSteve French struct iov_iter tmp_from = ctx->iter; 3524*38c8a9a5SSteve French 3525*38c8a9a5SSteve French INIT_LIST_HEAD(&tmp_list); 3526*38c8a9a5SSteve French list_del_init(&wdata->list); 3527*38c8a9a5SSteve French 3528*38c8a9a5SSteve French if (ctx->direct_io) 3529*38c8a9a5SSteve French rc = cifs_resend_wdata( 3530*38c8a9a5SSteve French wdata, &tmp_list, ctx); 3531*38c8a9a5SSteve French else { 3532*38c8a9a5SSteve French iov_iter_advance(&tmp_from, 3533*38c8a9a5SSteve French wdata->offset - ctx->pos); 3534*38c8a9a5SSteve French 3535*38c8a9a5SSteve French rc = cifs_write_from_iter(wdata->offset, 3536*38c8a9a5SSteve French wdata->bytes, &tmp_from, 3537*38c8a9a5SSteve French ctx->cfile, cifs_sb, &tmp_list, 3538*38c8a9a5SSteve French ctx); 3539*38c8a9a5SSteve French 3540*38c8a9a5SSteve French kref_put(&wdata->refcount, 3541*38c8a9a5SSteve French cifs_uncached_writedata_release); 3542*38c8a9a5SSteve French } 3543*38c8a9a5SSteve French 3544*38c8a9a5SSteve French list_splice(&tmp_list, &ctx->list); 3545*38c8a9a5SSteve French goto restart_loop; 3546*38c8a9a5SSteve French } 3547*38c8a9a5SSteve French } 3548*38c8a9a5SSteve French list_del_init(&wdata->list); 3549*38c8a9a5SSteve French kref_put(&wdata->refcount, cifs_uncached_writedata_release); 3550*38c8a9a5SSteve French } 3551*38c8a9a5SSteve French 3552*38c8a9a5SSteve French cifs_stats_bytes_written(tcon, ctx->total_len); 3553*38c8a9a5SSteve French set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags); 3554*38c8a9a5SSteve French 3555*38c8a9a5SSteve French ctx->rc = (rc == 0) ? ctx->total_len : rc; 3556*38c8a9a5SSteve French 3557*38c8a9a5SSteve French mutex_unlock(&ctx->aio_mutex); 3558*38c8a9a5SSteve French 3559*38c8a9a5SSteve French if (ctx->iocb && ctx->iocb->ki_complete) 3560*38c8a9a5SSteve French ctx->iocb->ki_complete(ctx->iocb, ctx->rc); 3561*38c8a9a5SSteve French else 3562*38c8a9a5SSteve French complete(&ctx->done); 3563*38c8a9a5SSteve French } 3564*38c8a9a5SSteve French 3565*38c8a9a5SSteve French static ssize_t __cifs_writev( 3566*38c8a9a5SSteve French struct kiocb *iocb, struct iov_iter *from, bool direct) 3567*38c8a9a5SSteve French { 3568*38c8a9a5SSteve French struct file *file = iocb->ki_filp; 3569*38c8a9a5SSteve French ssize_t total_written = 0; 3570*38c8a9a5SSteve French struct cifsFileInfo *cfile; 3571*38c8a9a5SSteve French struct cifs_tcon *tcon; 3572*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb; 3573*38c8a9a5SSteve French struct cifs_aio_ctx *ctx; 3574*38c8a9a5SSteve French int rc; 3575*38c8a9a5SSteve French 3576*38c8a9a5SSteve French rc = generic_write_checks(iocb, from); 3577*38c8a9a5SSteve French if (rc <= 0) 3578*38c8a9a5SSteve French return rc; 3579*38c8a9a5SSteve French 3580*38c8a9a5SSteve French cifs_sb = CIFS_FILE_SB(file); 3581*38c8a9a5SSteve French cfile = file->private_data; 3582*38c8a9a5SSteve French tcon = tlink_tcon(cfile->tlink); 3583*38c8a9a5SSteve French 3584*38c8a9a5SSteve French if (!tcon->ses->server->ops->async_writev) 3585*38c8a9a5SSteve French return -ENOSYS; 3586*38c8a9a5SSteve French 3587*38c8a9a5SSteve French ctx = cifs_aio_ctx_alloc(); 3588*38c8a9a5SSteve French if (!ctx) 3589*38c8a9a5SSteve French return -ENOMEM; 3590*38c8a9a5SSteve French 3591*38c8a9a5SSteve French ctx->cfile = cifsFileInfo_get(cfile); 3592*38c8a9a5SSteve French 3593*38c8a9a5SSteve French if (!is_sync_kiocb(iocb)) 3594*38c8a9a5SSteve French ctx->iocb = iocb; 3595*38c8a9a5SSteve French 3596*38c8a9a5SSteve French ctx->pos = iocb->ki_pos; 3597*38c8a9a5SSteve French ctx->direct_io = direct; 3598*38c8a9a5SSteve French ctx->nr_pinned_pages = 0; 3599*38c8a9a5SSteve French 3600*38c8a9a5SSteve French if (user_backed_iter(from)) { 3601*38c8a9a5SSteve French /* 3602*38c8a9a5SSteve French * Extract IOVEC/UBUF-type iterators to a BVEC-type iterator as 3603*38c8a9a5SSteve French * they contain references to the calling process's virtual 3604*38c8a9a5SSteve French * memory layout which won't be available in an async worker 3605*38c8a9a5SSteve French * thread. This also takes a pin on every folio involved. 3606*38c8a9a5SSteve French */ 3607*38c8a9a5SSteve French rc = netfs_extract_user_iter(from, iov_iter_count(from), 3608*38c8a9a5SSteve French &ctx->iter, 0); 3609*38c8a9a5SSteve French if (rc < 0) { 3610*38c8a9a5SSteve French kref_put(&ctx->refcount, cifs_aio_ctx_release); 3611*38c8a9a5SSteve French return rc; 3612*38c8a9a5SSteve French } 3613*38c8a9a5SSteve French 3614*38c8a9a5SSteve French ctx->nr_pinned_pages = rc; 3615*38c8a9a5SSteve French ctx->bv = (void *)ctx->iter.bvec; 3616*38c8a9a5SSteve French ctx->bv_need_unpin = iov_iter_extract_will_pin(from); 3617*38c8a9a5SSteve French } else if ((iov_iter_is_bvec(from) || iov_iter_is_kvec(from)) && 3618*38c8a9a5SSteve French !is_sync_kiocb(iocb)) { 3619*38c8a9a5SSteve French /* 3620*38c8a9a5SSteve French * If the op is asynchronous, we need to copy the list attached 3621*38c8a9a5SSteve French * to a BVEC/KVEC-type iterator, but we assume that the storage 3622*38c8a9a5SSteve French * will be pinned by the caller; in any case, we may or may not 3623*38c8a9a5SSteve French * be able to pin the pages, so we don't try. 3624*38c8a9a5SSteve French */ 3625*38c8a9a5SSteve French ctx->bv = (void *)dup_iter(&ctx->iter, from, GFP_KERNEL); 3626*38c8a9a5SSteve French if (!ctx->bv) { 3627*38c8a9a5SSteve French kref_put(&ctx->refcount, cifs_aio_ctx_release); 3628*38c8a9a5SSteve French return -ENOMEM; 3629*38c8a9a5SSteve French } 3630*38c8a9a5SSteve French } else { 3631*38c8a9a5SSteve French /* 3632*38c8a9a5SSteve French * Otherwise, we just pass the iterator down as-is and rely on 3633*38c8a9a5SSteve French * the caller to make sure the pages referred to by the 3634*38c8a9a5SSteve French * iterator don't evaporate. 3635*38c8a9a5SSteve French */ 3636*38c8a9a5SSteve French ctx->iter = *from; 3637*38c8a9a5SSteve French } 3638*38c8a9a5SSteve French 3639*38c8a9a5SSteve French ctx->len = iov_iter_count(&ctx->iter); 3640*38c8a9a5SSteve French 3641*38c8a9a5SSteve French /* grab a lock here due to read response handlers can access ctx */ 3642*38c8a9a5SSteve French mutex_lock(&ctx->aio_mutex); 3643*38c8a9a5SSteve French 3644*38c8a9a5SSteve French rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &ctx->iter, 3645*38c8a9a5SSteve French cfile, cifs_sb, &ctx->list, ctx); 3646*38c8a9a5SSteve French 3647*38c8a9a5SSteve French /* 3648*38c8a9a5SSteve French * If at least one write was successfully sent, then discard any rc 3649*38c8a9a5SSteve French * value from the later writes. If the other write succeeds, then 3650*38c8a9a5SSteve French * we'll end up returning whatever was written. If it fails, then 3651*38c8a9a5SSteve French * we'll get a new rc value from that. 3652*38c8a9a5SSteve French */ 3653*38c8a9a5SSteve French if (!list_empty(&ctx->list)) 3654*38c8a9a5SSteve French rc = 0; 3655*38c8a9a5SSteve French 3656*38c8a9a5SSteve French mutex_unlock(&ctx->aio_mutex); 3657*38c8a9a5SSteve French 3658*38c8a9a5SSteve French if (rc) { 3659*38c8a9a5SSteve French kref_put(&ctx->refcount, cifs_aio_ctx_release); 3660*38c8a9a5SSteve French return rc; 3661*38c8a9a5SSteve French } 3662*38c8a9a5SSteve French 3663*38c8a9a5SSteve French if (!is_sync_kiocb(iocb)) { 3664*38c8a9a5SSteve French kref_put(&ctx->refcount, cifs_aio_ctx_release); 3665*38c8a9a5SSteve French return -EIOCBQUEUED; 3666*38c8a9a5SSteve French } 3667*38c8a9a5SSteve French 3668*38c8a9a5SSteve French rc = wait_for_completion_killable(&ctx->done); 3669*38c8a9a5SSteve French if (rc) { 3670*38c8a9a5SSteve French mutex_lock(&ctx->aio_mutex); 3671*38c8a9a5SSteve French ctx->rc = rc = -EINTR; 3672*38c8a9a5SSteve French total_written = ctx->total_len; 3673*38c8a9a5SSteve French mutex_unlock(&ctx->aio_mutex); 3674*38c8a9a5SSteve French } else { 3675*38c8a9a5SSteve French rc = ctx->rc; 3676*38c8a9a5SSteve French total_written = ctx->total_len; 3677*38c8a9a5SSteve French } 3678*38c8a9a5SSteve French 3679*38c8a9a5SSteve French kref_put(&ctx->refcount, cifs_aio_ctx_release); 3680*38c8a9a5SSteve French 3681*38c8a9a5SSteve French if (unlikely(!total_written)) 3682*38c8a9a5SSteve French return rc; 3683*38c8a9a5SSteve French 3684*38c8a9a5SSteve French iocb->ki_pos += total_written; 3685*38c8a9a5SSteve French return total_written; 3686*38c8a9a5SSteve French } 3687*38c8a9a5SSteve French 3688*38c8a9a5SSteve French ssize_t cifs_direct_writev(struct kiocb *iocb, struct iov_iter *from) 3689*38c8a9a5SSteve French { 3690*38c8a9a5SSteve French struct file *file = iocb->ki_filp; 3691*38c8a9a5SSteve French 3692*38c8a9a5SSteve French cifs_revalidate_mapping(file->f_inode); 3693*38c8a9a5SSteve French return __cifs_writev(iocb, from, true); 3694*38c8a9a5SSteve French } 3695*38c8a9a5SSteve French 3696*38c8a9a5SSteve French ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from) 3697*38c8a9a5SSteve French { 3698*38c8a9a5SSteve French return __cifs_writev(iocb, from, false); 3699*38c8a9a5SSteve French } 3700*38c8a9a5SSteve French 3701*38c8a9a5SSteve French static ssize_t 3702*38c8a9a5SSteve French cifs_writev(struct kiocb *iocb, struct iov_iter *from) 3703*38c8a9a5SSteve French { 3704*38c8a9a5SSteve French struct file *file = iocb->ki_filp; 3705*38c8a9a5SSteve French struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data; 3706*38c8a9a5SSteve French struct inode *inode = file->f_mapping->host; 3707*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(inode); 3708*38c8a9a5SSteve French struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server; 3709*38c8a9a5SSteve French ssize_t rc; 3710*38c8a9a5SSteve French 3711*38c8a9a5SSteve French inode_lock(inode); 3712*38c8a9a5SSteve French /* 3713*38c8a9a5SSteve French * We need to hold the sem to be sure nobody modifies lock list 3714*38c8a9a5SSteve French * with a brlock that prevents writing. 3715*38c8a9a5SSteve French */ 3716*38c8a9a5SSteve French down_read(&cinode->lock_sem); 3717*38c8a9a5SSteve French 3718*38c8a9a5SSteve French rc = generic_write_checks(iocb, from); 3719*38c8a9a5SSteve French if (rc <= 0) 3720*38c8a9a5SSteve French goto out; 3721*38c8a9a5SSteve French 3722*38c8a9a5SSteve French if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from), 3723*38c8a9a5SSteve French server->vals->exclusive_lock_type, 0, 3724*38c8a9a5SSteve French NULL, CIFS_WRITE_OP)) 3725*38c8a9a5SSteve French rc = __generic_file_write_iter(iocb, from); 3726*38c8a9a5SSteve French else 3727*38c8a9a5SSteve French rc = -EACCES; 3728*38c8a9a5SSteve French out: 3729*38c8a9a5SSteve French up_read(&cinode->lock_sem); 3730*38c8a9a5SSteve French inode_unlock(inode); 3731*38c8a9a5SSteve French 3732*38c8a9a5SSteve French if (rc > 0) 3733*38c8a9a5SSteve French rc = generic_write_sync(iocb, rc); 3734*38c8a9a5SSteve French return rc; 3735*38c8a9a5SSteve French } 3736*38c8a9a5SSteve French 3737*38c8a9a5SSteve French ssize_t 3738*38c8a9a5SSteve French cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from) 3739*38c8a9a5SSteve French { 3740*38c8a9a5SSteve French struct inode *inode = file_inode(iocb->ki_filp); 3741*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(inode); 3742*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 3743*38c8a9a5SSteve French struct cifsFileInfo *cfile = (struct cifsFileInfo *) 3744*38c8a9a5SSteve French iocb->ki_filp->private_data; 3745*38c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 3746*38c8a9a5SSteve French ssize_t written; 3747*38c8a9a5SSteve French 3748*38c8a9a5SSteve French written = cifs_get_writer(cinode); 3749*38c8a9a5SSteve French if (written) 3750*38c8a9a5SSteve French return written; 3751*38c8a9a5SSteve French 3752*38c8a9a5SSteve French if (CIFS_CACHE_WRITE(cinode)) { 3753*38c8a9a5SSteve French if (cap_unix(tcon->ses) && 3754*38c8a9a5SSteve French (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) 3755*38c8a9a5SSteve French && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) { 3756*38c8a9a5SSteve French written = generic_file_write_iter(iocb, from); 3757*38c8a9a5SSteve French goto out; 3758*38c8a9a5SSteve French } 3759*38c8a9a5SSteve French written = cifs_writev(iocb, from); 3760*38c8a9a5SSteve French goto out; 3761*38c8a9a5SSteve French } 3762*38c8a9a5SSteve French /* 3763*38c8a9a5SSteve French * For non-oplocked files in strict cache mode we need to write the data 3764*38c8a9a5SSteve French * to the server exactly from the pos to pos+len-1 rather than flush all 3765*38c8a9a5SSteve French * affected pages because it may cause a error with mandatory locks on 3766*38c8a9a5SSteve French * these pages but not on the region from pos to ppos+len-1. 3767*38c8a9a5SSteve French */ 3768*38c8a9a5SSteve French written = cifs_user_writev(iocb, from); 3769*38c8a9a5SSteve French if (CIFS_CACHE_READ(cinode)) { 3770*38c8a9a5SSteve French /* 3771*38c8a9a5SSteve French * We have read level caching and we have just sent a write 3772*38c8a9a5SSteve French * request to the server thus making data in the cache stale. 3773*38c8a9a5SSteve French * Zap the cache and set oplock/lease level to NONE to avoid 3774*38c8a9a5SSteve French * reading stale data from the cache. All subsequent read 3775*38c8a9a5SSteve French * operations will read new data from the server. 3776*38c8a9a5SSteve French */ 3777*38c8a9a5SSteve French cifs_zap_mapping(inode); 3778*38c8a9a5SSteve French cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n", 3779*38c8a9a5SSteve French inode); 3780*38c8a9a5SSteve French cinode->oplock = 0; 3781*38c8a9a5SSteve French } 3782*38c8a9a5SSteve French out: 3783*38c8a9a5SSteve French cifs_put_writer(cinode); 3784*38c8a9a5SSteve French return written; 3785*38c8a9a5SSteve French } 3786*38c8a9a5SSteve French 3787*38c8a9a5SSteve French static struct cifs_readdata *cifs_readdata_alloc(work_func_t complete) 3788*38c8a9a5SSteve French { 3789*38c8a9a5SSteve French struct cifs_readdata *rdata; 3790*38c8a9a5SSteve French 3791*38c8a9a5SSteve French rdata = kzalloc(sizeof(*rdata), GFP_KERNEL); 3792*38c8a9a5SSteve French if (rdata) { 3793*38c8a9a5SSteve French kref_init(&rdata->refcount); 3794*38c8a9a5SSteve French INIT_LIST_HEAD(&rdata->list); 3795*38c8a9a5SSteve French init_completion(&rdata->done); 3796*38c8a9a5SSteve French INIT_WORK(&rdata->work, complete); 3797*38c8a9a5SSteve French } 3798*38c8a9a5SSteve French 3799*38c8a9a5SSteve French return rdata; 3800*38c8a9a5SSteve French } 3801*38c8a9a5SSteve French 3802*38c8a9a5SSteve French void 3803*38c8a9a5SSteve French cifs_readdata_release(struct kref *refcount) 3804*38c8a9a5SSteve French { 3805*38c8a9a5SSteve French struct cifs_readdata *rdata = container_of(refcount, 3806*38c8a9a5SSteve French struct cifs_readdata, refcount); 3807*38c8a9a5SSteve French 3808*38c8a9a5SSteve French if (rdata->ctx) 3809*38c8a9a5SSteve French kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release); 3810*38c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 3811*38c8a9a5SSteve French if (rdata->mr) { 3812*38c8a9a5SSteve French smbd_deregister_mr(rdata->mr); 3813*38c8a9a5SSteve French rdata->mr = NULL; 3814*38c8a9a5SSteve French } 3815*38c8a9a5SSteve French #endif 3816*38c8a9a5SSteve French if (rdata->cfile) 3817*38c8a9a5SSteve French cifsFileInfo_put(rdata->cfile); 3818*38c8a9a5SSteve French 3819*38c8a9a5SSteve French kfree(rdata); 3820*38c8a9a5SSteve French } 3821*38c8a9a5SSteve French 3822*38c8a9a5SSteve French static void collect_uncached_read_data(struct cifs_aio_ctx *ctx); 3823*38c8a9a5SSteve French 3824*38c8a9a5SSteve French static void 3825*38c8a9a5SSteve French cifs_uncached_readv_complete(struct work_struct *work) 3826*38c8a9a5SSteve French { 3827*38c8a9a5SSteve French struct cifs_readdata *rdata = container_of(work, 3828*38c8a9a5SSteve French struct cifs_readdata, work); 3829*38c8a9a5SSteve French 3830*38c8a9a5SSteve French complete(&rdata->done); 3831*38c8a9a5SSteve French collect_uncached_read_data(rdata->ctx); 3832*38c8a9a5SSteve French /* the below call can possibly free the last ref to aio ctx */ 3833*38c8a9a5SSteve French kref_put(&rdata->refcount, cifs_readdata_release); 3834*38c8a9a5SSteve French } 3835*38c8a9a5SSteve French 3836*38c8a9a5SSteve French static int cifs_resend_rdata(struct cifs_readdata *rdata, 3837*38c8a9a5SSteve French struct list_head *rdata_list, 3838*38c8a9a5SSteve French struct cifs_aio_ctx *ctx) 3839*38c8a9a5SSteve French { 3840*38c8a9a5SSteve French unsigned int rsize; 3841*38c8a9a5SSteve French struct cifs_credits credits; 3842*38c8a9a5SSteve French int rc; 3843*38c8a9a5SSteve French struct TCP_Server_Info *server; 3844*38c8a9a5SSteve French 3845*38c8a9a5SSteve French /* XXX: should we pick a new channel here? */ 3846*38c8a9a5SSteve French server = rdata->server; 3847*38c8a9a5SSteve French 3848*38c8a9a5SSteve French do { 3849*38c8a9a5SSteve French if (rdata->cfile->invalidHandle) { 3850*38c8a9a5SSteve French rc = cifs_reopen_file(rdata->cfile, true); 3851*38c8a9a5SSteve French if (rc == -EAGAIN) 3852*38c8a9a5SSteve French continue; 3853*38c8a9a5SSteve French else if (rc) 3854*38c8a9a5SSteve French break; 3855*38c8a9a5SSteve French } 3856*38c8a9a5SSteve French 3857*38c8a9a5SSteve French /* 3858*38c8a9a5SSteve French * Wait for credits to resend this rdata. 3859*38c8a9a5SSteve French * Note: we are attempting to resend the whole rdata not in 3860*38c8a9a5SSteve French * segments 3861*38c8a9a5SSteve French */ 3862*38c8a9a5SSteve French do { 3863*38c8a9a5SSteve French rc = server->ops->wait_mtu_credits(server, rdata->bytes, 3864*38c8a9a5SSteve French &rsize, &credits); 3865*38c8a9a5SSteve French 3866*38c8a9a5SSteve French if (rc) 3867*38c8a9a5SSteve French goto fail; 3868*38c8a9a5SSteve French 3869*38c8a9a5SSteve French if (rsize < rdata->bytes) { 3870*38c8a9a5SSteve French add_credits_and_wake_if(server, &credits, 0); 3871*38c8a9a5SSteve French msleep(1000); 3872*38c8a9a5SSteve French } 3873*38c8a9a5SSteve French } while (rsize < rdata->bytes); 3874*38c8a9a5SSteve French rdata->credits = credits; 3875*38c8a9a5SSteve French 3876*38c8a9a5SSteve French rc = adjust_credits(server, &rdata->credits, rdata->bytes); 3877*38c8a9a5SSteve French if (!rc) { 3878*38c8a9a5SSteve French if (rdata->cfile->invalidHandle) 3879*38c8a9a5SSteve French rc = -EAGAIN; 3880*38c8a9a5SSteve French else { 3881*38c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 3882*38c8a9a5SSteve French if (rdata->mr) { 3883*38c8a9a5SSteve French rdata->mr->need_invalidate = true; 3884*38c8a9a5SSteve French smbd_deregister_mr(rdata->mr); 3885*38c8a9a5SSteve French rdata->mr = NULL; 3886*38c8a9a5SSteve French } 3887*38c8a9a5SSteve French #endif 3888*38c8a9a5SSteve French rc = server->ops->async_readv(rdata); 3889*38c8a9a5SSteve French } 3890*38c8a9a5SSteve French } 3891*38c8a9a5SSteve French 3892*38c8a9a5SSteve French /* If the read was successfully sent, we are done */ 3893*38c8a9a5SSteve French if (!rc) { 3894*38c8a9a5SSteve French /* Add to aio pending list */ 3895*38c8a9a5SSteve French list_add_tail(&rdata->list, rdata_list); 3896*38c8a9a5SSteve French return 0; 3897*38c8a9a5SSteve French } 3898*38c8a9a5SSteve French 3899*38c8a9a5SSteve French /* Roll back credits and retry if needed */ 3900*38c8a9a5SSteve French add_credits_and_wake_if(server, &rdata->credits, 0); 3901*38c8a9a5SSteve French } while (rc == -EAGAIN); 3902*38c8a9a5SSteve French 3903*38c8a9a5SSteve French fail: 3904*38c8a9a5SSteve French kref_put(&rdata->refcount, cifs_readdata_release); 3905*38c8a9a5SSteve French return rc; 3906*38c8a9a5SSteve French } 3907*38c8a9a5SSteve French 3908*38c8a9a5SSteve French static int 3909*38c8a9a5SSteve French cifs_send_async_read(loff_t fpos, size_t len, struct cifsFileInfo *open_file, 3910*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb, struct list_head *rdata_list, 3911*38c8a9a5SSteve French struct cifs_aio_ctx *ctx) 3912*38c8a9a5SSteve French { 3913*38c8a9a5SSteve French struct cifs_readdata *rdata; 3914*38c8a9a5SSteve French unsigned int rsize, nsegs, max_segs = INT_MAX; 3915*38c8a9a5SSteve French struct cifs_credits credits_on_stack; 3916*38c8a9a5SSteve French struct cifs_credits *credits = &credits_on_stack; 3917*38c8a9a5SSteve French size_t cur_len, max_len; 3918*38c8a9a5SSteve French int rc; 3919*38c8a9a5SSteve French pid_t pid; 3920*38c8a9a5SSteve French struct TCP_Server_Info *server; 3921*38c8a9a5SSteve French 3922*38c8a9a5SSteve French server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses); 3923*38c8a9a5SSteve French 3924*38c8a9a5SSteve French #ifdef CONFIG_CIFS_SMB_DIRECT 3925*38c8a9a5SSteve French if (server->smbd_conn) 3926*38c8a9a5SSteve French max_segs = server->smbd_conn->max_frmr_depth; 3927*38c8a9a5SSteve French #endif 3928*38c8a9a5SSteve French 3929*38c8a9a5SSteve French if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD) 3930*38c8a9a5SSteve French pid = open_file->pid; 3931*38c8a9a5SSteve French else 3932*38c8a9a5SSteve French pid = current->tgid; 3933*38c8a9a5SSteve French 3934*38c8a9a5SSteve French do { 3935*38c8a9a5SSteve French if (open_file->invalidHandle) { 3936*38c8a9a5SSteve French rc = cifs_reopen_file(open_file, true); 3937*38c8a9a5SSteve French if (rc == -EAGAIN) 3938*38c8a9a5SSteve French continue; 3939*38c8a9a5SSteve French else if (rc) 3940*38c8a9a5SSteve French break; 3941*38c8a9a5SSteve French } 3942*38c8a9a5SSteve French 3943*38c8a9a5SSteve French if (cifs_sb->ctx->rsize == 0) 3944*38c8a9a5SSteve French cifs_sb->ctx->rsize = 3945*38c8a9a5SSteve French server->ops->negotiate_rsize(tlink_tcon(open_file->tlink), 3946*38c8a9a5SSteve French cifs_sb->ctx); 3947*38c8a9a5SSteve French 3948*38c8a9a5SSteve French rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize, 3949*38c8a9a5SSteve French &rsize, credits); 3950*38c8a9a5SSteve French if (rc) 3951*38c8a9a5SSteve French break; 3952*38c8a9a5SSteve French 3953*38c8a9a5SSteve French max_len = min_t(size_t, len, rsize); 3954*38c8a9a5SSteve French 3955*38c8a9a5SSteve French cur_len = cifs_limit_bvec_subset(&ctx->iter, max_len, 3956*38c8a9a5SSteve French max_segs, &nsegs); 3957*38c8a9a5SSteve French cifs_dbg(FYI, "read-to-iter len=%zx/%zx nsegs=%u/%lu/%u\n", 3958*38c8a9a5SSteve French cur_len, max_len, nsegs, ctx->iter.nr_segs, max_segs); 3959*38c8a9a5SSteve French if (cur_len == 0) { 3960*38c8a9a5SSteve French rc = -EIO; 3961*38c8a9a5SSteve French add_credits_and_wake_if(server, credits, 0); 3962*38c8a9a5SSteve French break; 3963*38c8a9a5SSteve French } 3964*38c8a9a5SSteve French 3965*38c8a9a5SSteve French rdata = cifs_readdata_alloc(cifs_uncached_readv_complete); 3966*38c8a9a5SSteve French if (!rdata) { 3967*38c8a9a5SSteve French add_credits_and_wake_if(server, credits, 0); 3968*38c8a9a5SSteve French rc = -ENOMEM; 3969*38c8a9a5SSteve French break; 3970*38c8a9a5SSteve French } 3971*38c8a9a5SSteve French 3972*38c8a9a5SSteve French rdata->server = server; 3973*38c8a9a5SSteve French rdata->cfile = cifsFileInfo_get(open_file); 3974*38c8a9a5SSteve French rdata->offset = fpos; 3975*38c8a9a5SSteve French rdata->bytes = cur_len; 3976*38c8a9a5SSteve French rdata->pid = pid; 3977*38c8a9a5SSteve French rdata->credits = credits_on_stack; 3978*38c8a9a5SSteve French rdata->ctx = ctx; 3979*38c8a9a5SSteve French kref_get(&ctx->refcount); 3980*38c8a9a5SSteve French 3981*38c8a9a5SSteve French rdata->iter = ctx->iter; 3982*38c8a9a5SSteve French iov_iter_truncate(&rdata->iter, cur_len); 3983*38c8a9a5SSteve French 3984*38c8a9a5SSteve French rc = adjust_credits(server, &rdata->credits, rdata->bytes); 3985*38c8a9a5SSteve French 3986*38c8a9a5SSteve French if (!rc) { 3987*38c8a9a5SSteve French if (rdata->cfile->invalidHandle) 3988*38c8a9a5SSteve French rc = -EAGAIN; 3989*38c8a9a5SSteve French else 3990*38c8a9a5SSteve French rc = server->ops->async_readv(rdata); 3991*38c8a9a5SSteve French } 3992*38c8a9a5SSteve French 3993*38c8a9a5SSteve French if (rc) { 3994*38c8a9a5SSteve French add_credits_and_wake_if(server, &rdata->credits, 0); 3995*38c8a9a5SSteve French kref_put(&rdata->refcount, cifs_readdata_release); 3996*38c8a9a5SSteve French if (rc == -EAGAIN) 3997*38c8a9a5SSteve French continue; 3998*38c8a9a5SSteve French break; 3999*38c8a9a5SSteve French } 4000*38c8a9a5SSteve French 4001*38c8a9a5SSteve French list_add_tail(&rdata->list, rdata_list); 4002*38c8a9a5SSteve French iov_iter_advance(&ctx->iter, cur_len); 4003*38c8a9a5SSteve French fpos += cur_len; 4004*38c8a9a5SSteve French len -= cur_len; 4005*38c8a9a5SSteve French } while (len > 0); 4006*38c8a9a5SSteve French 4007*38c8a9a5SSteve French return rc; 4008*38c8a9a5SSteve French } 4009*38c8a9a5SSteve French 4010*38c8a9a5SSteve French static void 4011*38c8a9a5SSteve French collect_uncached_read_data(struct cifs_aio_ctx *ctx) 4012*38c8a9a5SSteve French { 4013*38c8a9a5SSteve French struct cifs_readdata *rdata, *tmp; 4014*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb; 4015*38c8a9a5SSteve French int rc; 4016*38c8a9a5SSteve French 4017*38c8a9a5SSteve French cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb); 4018*38c8a9a5SSteve French 4019*38c8a9a5SSteve French mutex_lock(&ctx->aio_mutex); 4020*38c8a9a5SSteve French 4021*38c8a9a5SSteve French if (list_empty(&ctx->list)) { 4022*38c8a9a5SSteve French mutex_unlock(&ctx->aio_mutex); 4023*38c8a9a5SSteve French return; 4024*38c8a9a5SSteve French } 4025*38c8a9a5SSteve French 4026*38c8a9a5SSteve French rc = ctx->rc; 4027*38c8a9a5SSteve French /* the loop below should proceed in the order of increasing offsets */ 4028*38c8a9a5SSteve French again: 4029*38c8a9a5SSteve French list_for_each_entry_safe(rdata, tmp, &ctx->list, list) { 4030*38c8a9a5SSteve French if (!rc) { 4031*38c8a9a5SSteve French if (!try_wait_for_completion(&rdata->done)) { 4032*38c8a9a5SSteve French mutex_unlock(&ctx->aio_mutex); 4033*38c8a9a5SSteve French return; 4034*38c8a9a5SSteve French } 4035*38c8a9a5SSteve French 4036*38c8a9a5SSteve French if (rdata->result == -EAGAIN) { 4037*38c8a9a5SSteve French /* resend call if it's a retryable error */ 4038*38c8a9a5SSteve French struct list_head tmp_list; 4039*38c8a9a5SSteve French unsigned int got_bytes = rdata->got_bytes; 4040*38c8a9a5SSteve French 4041*38c8a9a5SSteve French list_del_init(&rdata->list); 4042*38c8a9a5SSteve French INIT_LIST_HEAD(&tmp_list); 4043*38c8a9a5SSteve French 4044*38c8a9a5SSteve French if (ctx->direct_io) { 4045*38c8a9a5SSteve French /* 4046*38c8a9a5SSteve French * Re-use rdata as this is a 4047*38c8a9a5SSteve French * direct I/O 4048*38c8a9a5SSteve French */ 4049*38c8a9a5SSteve French rc = cifs_resend_rdata( 4050*38c8a9a5SSteve French rdata, 4051*38c8a9a5SSteve French &tmp_list, ctx); 4052*38c8a9a5SSteve French } else { 4053*38c8a9a5SSteve French rc = cifs_send_async_read( 4054*38c8a9a5SSteve French rdata->offset + got_bytes, 4055*38c8a9a5SSteve French rdata->bytes - got_bytes, 4056*38c8a9a5SSteve French rdata->cfile, cifs_sb, 4057*38c8a9a5SSteve French &tmp_list, ctx); 4058*38c8a9a5SSteve French 4059*38c8a9a5SSteve French kref_put(&rdata->refcount, 4060*38c8a9a5SSteve French cifs_readdata_release); 4061*38c8a9a5SSteve French } 4062*38c8a9a5SSteve French 4063*38c8a9a5SSteve French list_splice(&tmp_list, &ctx->list); 4064*38c8a9a5SSteve French 4065*38c8a9a5SSteve French goto again; 4066*38c8a9a5SSteve French } else if (rdata->result) 4067*38c8a9a5SSteve French rc = rdata->result; 4068*38c8a9a5SSteve French 4069*38c8a9a5SSteve French /* if there was a short read -- discard anything left */ 4070*38c8a9a5SSteve French if (rdata->got_bytes && rdata->got_bytes < rdata->bytes) 4071*38c8a9a5SSteve French rc = -ENODATA; 4072*38c8a9a5SSteve French 4073*38c8a9a5SSteve French ctx->total_len += rdata->got_bytes; 4074*38c8a9a5SSteve French } 4075*38c8a9a5SSteve French list_del_init(&rdata->list); 4076*38c8a9a5SSteve French kref_put(&rdata->refcount, cifs_readdata_release); 4077*38c8a9a5SSteve French } 4078*38c8a9a5SSteve French 4079*38c8a9a5SSteve French /* mask nodata case */ 4080*38c8a9a5SSteve French if (rc == -ENODATA) 4081*38c8a9a5SSteve French rc = 0; 4082*38c8a9a5SSteve French 4083*38c8a9a5SSteve French ctx->rc = (rc == 0) ? (ssize_t)ctx->total_len : rc; 4084*38c8a9a5SSteve French 4085*38c8a9a5SSteve French mutex_unlock(&ctx->aio_mutex); 4086*38c8a9a5SSteve French 4087*38c8a9a5SSteve French if (ctx->iocb && ctx->iocb->ki_complete) 4088*38c8a9a5SSteve French ctx->iocb->ki_complete(ctx->iocb, ctx->rc); 4089*38c8a9a5SSteve French else 4090*38c8a9a5SSteve French complete(&ctx->done); 4091*38c8a9a5SSteve French } 4092*38c8a9a5SSteve French 4093*38c8a9a5SSteve French static ssize_t __cifs_readv( 4094*38c8a9a5SSteve French struct kiocb *iocb, struct iov_iter *to, bool direct) 4095*38c8a9a5SSteve French { 4096*38c8a9a5SSteve French size_t len; 4097*38c8a9a5SSteve French struct file *file = iocb->ki_filp; 4098*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb; 4099*38c8a9a5SSteve French struct cifsFileInfo *cfile; 4100*38c8a9a5SSteve French struct cifs_tcon *tcon; 4101*38c8a9a5SSteve French ssize_t rc, total_read = 0; 4102*38c8a9a5SSteve French loff_t offset = iocb->ki_pos; 4103*38c8a9a5SSteve French struct cifs_aio_ctx *ctx; 4104*38c8a9a5SSteve French 4105*38c8a9a5SSteve French len = iov_iter_count(to); 4106*38c8a9a5SSteve French if (!len) 4107*38c8a9a5SSteve French return 0; 4108*38c8a9a5SSteve French 4109*38c8a9a5SSteve French cifs_sb = CIFS_FILE_SB(file); 4110*38c8a9a5SSteve French cfile = file->private_data; 4111*38c8a9a5SSteve French tcon = tlink_tcon(cfile->tlink); 4112*38c8a9a5SSteve French 4113*38c8a9a5SSteve French if (!tcon->ses->server->ops->async_readv) 4114*38c8a9a5SSteve French return -ENOSYS; 4115*38c8a9a5SSteve French 4116*38c8a9a5SSteve French if ((file->f_flags & O_ACCMODE) == O_WRONLY) 4117*38c8a9a5SSteve French cifs_dbg(FYI, "attempting read on write only file instance\n"); 4118*38c8a9a5SSteve French 4119*38c8a9a5SSteve French ctx = cifs_aio_ctx_alloc(); 4120*38c8a9a5SSteve French if (!ctx) 4121*38c8a9a5SSteve French return -ENOMEM; 4122*38c8a9a5SSteve French 4123*38c8a9a5SSteve French ctx->pos = offset; 4124*38c8a9a5SSteve French ctx->direct_io = direct; 4125*38c8a9a5SSteve French ctx->len = len; 4126*38c8a9a5SSteve French ctx->cfile = cifsFileInfo_get(cfile); 4127*38c8a9a5SSteve French ctx->nr_pinned_pages = 0; 4128*38c8a9a5SSteve French 4129*38c8a9a5SSteve French if (!is_sync_kiocb(iocb)) 4130*38c8a9a5SSteve French ctx->iocb = iocb; 4131*38c8a9a5SSteve French 4132*38c8a9a5SSteve French if (user_backed_iter(to)) { 4133*38c8a9a5SSteve French /* 4134*38c8a9a5SSteve French * Extract IOVEC/UBUF-type iterators to a BVEC-type iterator as 4135*38c8a9a5SSteve French * they contain references to the calling process's virtual 4136*38c8a9a5SSteve French * memory layout which won't be available in an async worker 4137*38c8a9a5SSteve French * thread. This also takes a pin on every folio involved. 4138*38c8a9a5SSteve French */ 4139*38c8a9a5SSteve French rc = netfs_extract_user_iter(to, iov_iter_count(to), 4140*38c8a9a5SSteve French &ctx->iter, 0); 4141*38c8a9a5SSteve French if (rc < 0) { 4142*38c8a9a5SSteve French kref_put(&ctx->refcount, cifs_aio_ctx_release); 4143*38c8a9a5SSteve French return rc; 4144*38c8a9a5SSteve French } 4145*38c8a9a5SSteve French 4146*38c8a9a5SSteve French ctx->nr_pinned_pages = rc; 4147*38c8a9a5SSteve French ctx->bv = (void *)ctx->iter.bvec; 4148*38c8a9a5SSteve French ctx->bv_need_unpin = iov_iter_extract_will_pin(to); 4149*38c8a9a5SSteve French ctx->should_dirty = true; 4150*38c8a9a5SSteve French } else if ((iov_iter_is_bvec(to) || iov_iter_is_kvec(to)) && 4151*38c8a9a5SSteve French !is_sync_kiocb(iocb)) { 4152*38c8a9a5SSteve French /* 4153*38c8a9a5SSteve French * If the op is asynchronous, we need to copy the list attached 4154*38c8a9a5SSteve French * to a BVEC/KVEC-type iterator, but we assume that the storage 4155*38c8a9a5SSteve French * will be retained by the caller; in any case, we may or may 4156*38c8a9a5SSteve French * not be able to pin the pages, so we don't try. 4157*38c8a9a5SSteve French */ 4158*38c8a9a5SSteve French ctx->bv = (void *)dup_iter(&ctx->iter, to, GFP_KERNEL); 4159*38c8a9a5SSteve French if (!ctx->bv) { 4160*38c8a9a5SSteve French kref_put(&ctx->refcount, cifs_aio_ctx_release); 4161*38c8a9a5SSteve French return -ENOMEM; 4162*38c8a9a5SSteve French } 4163*38c8a9a5SSteve French } else { 4164*38c8a9a5SSteve French /* 4165*38c8a9a5SSteve French * Otherwise, we just pass the iterator down as-is and rely on 4166*38c8a9a5SSteve French * the caller to make sure the pages referred to by the 4167*38c8a9a5SSteve French * iterator don't evaporate. 4168*38c8a9a5SSteve French */ 4169*38c8a9a5SSteve French ctx->iter = *to; 4170*38c8a9a5SSteve French } 4171*38c8a9a5SSteve French 4172*38c8a9a5SSteve French if (direct) { 4173*38c8a9a5SSteve French rc = filemap_write_and_wait_range(file->f_inode->i_mapping, 4174*38c8a9a5SSteve French offset, offset + len - 1); 4175*38c8a9a5SSteve French if (rc) { 4176*38c8a9a5SSteve French kref_put(&ctx->refcount, cifs_aio_ctx_release); 4177*38c8a9a5SSteve French return -EAGAIN; 4178*38c8a9a5SSteve French } 4179*38c8a9a5SSteve French } 4180*38c8a9a5SSteve French 4181*38c8a9a5SSteve French /* grab a lock here due to read response handlers can access ctx */ 4182*38c8a9a5SSteve French mutex_lock(&ctx->aio_mutex); 4183*38c8a9a5SSteve French 4184*38c8a9a5SSteve French rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx); 4185*38c8a9a5SSteve French 4186*38c8a9a5SSteve French /* if at least one read request send succeeded, then reset rc */ 4187*38c8a9a5SSteve French if (!list_empty(&ctx->list)) 4188*38c8a9a5SSteve French rc = 0; 4189*38c8a9a5SSteve French 4190*38c8a9a5SSteve French mutex_unlock(&ctx->aio_mutex); 4191*38c8a9a5SSteve French 4192*38c8a9a5SSteve French if (rc) { 4193*38c8a9a5SSteve French kref_put(&ctx->refcount, cifs_aio_ctx_release); 4194*38c8a9a5SSteve French return rc; 4195*38c8a9a5SSteve French } 4196*38c8a9a5SSteve French 4197*38c8a9a5SSteve French if (!is_sync_kiocb(iocb)) { 4198*38c8a9a5SSteve French kref_put(&ctx->refcount, cifs_aio_ctx_release); 4199*38c8a9a5SSteve French return -EIOCBQUEUED; 4200*38c8a9a5SSteve French } 4201*38c8a9a5SSteve French 4202*38c8a9a5SSteve French rc = wait_for_completion_killable(&ctx->done); 4203*38c8a9a5SSteve French if (rc) { 4204*38c8a9a5SSteve French mutex_lock(&ctx->aio_mutex); 4205*38c8a9a5SSteve French ctx->rc = rc = -EINTR; 4206*38c8a9a5SSteve French total_read = ctx->total_len; 4207*38c8a9a5SSteve French mutex_unlock(&ctx->aio_mutex); 4208*38c8a9a5SSteve French } else { 4209*38c8a9a5SSteve French rc = ctx->rc; 4210*38c8a9a5SSteve French total_read = ctx->total_len; 4211*38c8a9a5SSteve French } 4212*38c8a9a5SSteve French 4213*38c8a9a5SSteve French kref_put(&ctx->refcount, cifs_aio_ctx_release); 4214*38c8a9a5SSteve French 4215*38c8a9a5SSteve French if (total_read) { 4216*38c8a9a5SSteve French iocb->ki_pos += total_read; 4217*38c8a9a5SSteve French return total_read; 4218*38c8a9a5SSteve French } 4219*38c8a9a5SSteve French return rc; 4220*38c8a9a5SSteve French } 4221*38c8a9a5SSteve French 4222*38c8a9a5SSteve French ssize_t cifs_direct_readv(struct kiocb *iocb, struct iov_iter *to) 4223*38c8a9a5SSteve French { 4224*38c8a9a5SSteve French return __cifs_readv(iocb, to, true); 4225*38c8a9a5SSteve French } 4226*38c8a9a5SSteve French 4227*38c8a9a5SSteve French ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to) 4228*38c8a9a5SSteve French { 4229*38c8a9a5SSteve French return __cifs_readv(iocb, to, false); 4230*38c8a9a5SSteve French } 4231*38c8a9a5SSteve French 4232*38c8a9a5SSteve French ssize_t 4233*38c8a9a5SSteve French cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to) 4234*38c8a9a5SSteve French { 4235*38c8a9a5SSteve French struct inode *inode = file_inode(iocb->ki_filp); 4236*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(inode); 4237*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 4238*38c8a9a5SSteve French struct cifsFileInfo *cfile = (struct cifsFileInfo *) 4239*38c8a9a5SSteve French iocb->ki_filp->private_data; 4240*38c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 4241*38c8a9a5SSteve French int rc = -EACCES; 4242*38c8a9a5SSteve French 4243*38c8a9a5SSteve French /* 4244*38c8a9a5SSteve French * In strict cache mode we need to read from the server all the time 4245*38c8a9a5SSteve French * if we don't have level II oplock because the server can delay mtime 4246*38c8a9a5SSteve French * change - so we can't make a decision about inode invalidating. 4247*38c8a9a5SSteve French * And we can also fail with pagereading if there are mandatory locks 4248*38c8a9a5SSteve French * on pages affected by this read but not on the region from pos to 4249*38c8a9a5SSteve French * pos+len-1. 4250*38c8a9a5SSteve French */ 4251*38c8a9a5SSteve French if (!CIFS_CACHE_READ(cinode)) 4252*38c8a9a5SSteve French return cifs_user_readv(iocb, to); 4253*38c8a9a5SSteve French 4254*38c8a9a5SSteve French if (cap_unix(tcon->ses) && 4255*38c8a9a5SSteve French (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) && 4256*38c8a9a5SSteve French ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) 4257*38c8a9a5SSteve French return generic_file_read_iter(iocb, to); 4258*38c8a9a5SSteve French 4259*38c8a9a5SSteve French /* 4260*38c8a9a5SSteve French * We need to hold the sem to be sure nobody modifies lock list 4261*38c8a9a5SSteve French * with a brlock that prevents reading. 4262*38c8a9a5SSteve French */ 4263*38c8a9a5SSteve French down_read(&cinode->lock_sem); 4264*38c8a9a5SSteve French if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to), 4265*38c8a9a5SSteve French tcon->ses->server->vals->shared_lock_type, 4266*38c8a9a5SSteve French 0, NULL, CIFS_READ_OP)) 4267*38c8a9a5SSteve French rc = generic_file_read_iter(iocb, to); 4268*38c8a9a5SSteve French up_read(&cinode->lock_sem); 4269*38c8a9a5SSteve French return rc; 4270*38c8a9a5SSteve French } 4271*38c8a9a5SSteve French 4272*38c8a9a5SSteve French static ssize_t 4273*38c8a9a5SSteve French cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset) 4274*38c8a9a5SSteve French { 4275*38c8a9a5SSteve French int rc = -EACCES; 4276*38c8a9a5SSteve French unsigned int bytes_read = 0; 4277*38c8a9a5SSteve French unsigned int total_read; 4278*38c8a9a5SSteve French unsigned int current_read_size; 4279*38c8a9a5SSteve French unsigned int rsize; 4280*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb; 4281*38c8a9a5SSteve French struct cifs_tcon *tcon; 4282*38c8a9a5SSteve French struct TCP_Server_Info *server; 4283*38c8a9a5SSteve French unsigned int xid; 4284*38c8a9a5SSteve French char *cur_offset; 4285*38c8a9a5SSteve French struct cifsFileInfo *open_file; 4286*38c8a9a5SSteve French struct cifs_io_parms io_parms = {0}; 4287*38c8a9a5SSteve French int buf_type = CIFS_NO_BUFFER; 4288*38c8a9a5SSteve French __u32 pid; 4289*38c8a9a5SSteve French 4290*38c8a9a5SSteve French xid = get_xid(); 4291*38c8a9a5SSteve French cifs_sb = CIFS_FILE_SB(file); 4292*38c8a9a5SSteve French 4293*38c8a9a5SSteve French /* FIXME: set up handlers for larger reads and/or convert to async */ 4294*38c8a9a5SSteve French rsize = min_t(unsigned int, cifs_sb->ctx->rsize, CIFSMaxBufSize); 4295*38c8a9a5SSteve French 4296*38c8a9a5SSteve French if (file->private_data == NULL) { 4297*38c8a9a5SSteve French rc = -EBADF; 4298*38c8a9a5SSteve French free_xid(xid); 4299*38c8a9a5SSteve French return rc; 4300*38c8a9a5SSteve French } 4301*38c8a9a5SSteve French open_file = file->private_data; 4302*38c8a9a5SSteve French tcon = tlink_tcon(open_file->tlink); 4303*38c8a9a5SSteve French server = cifs_pick_channel(tcon->ses); 4304*38c8a9a5SSteve French 4305*38c8a9a5SSteve French if (!server->ops->sync_read) { 4306*38c8a9a5SSteve French free_xid(xid); 4307*38c8a9a5SSteve French return -ENOSYS; 4308*38c8a9a5SSteve French } 4309*38c8a9a5SSteve French 4310*38c8a9a5SSteve French if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD) 4311*38c8a9a5SSteve French pid = open_file->pid; 4312*38c8a9a5SSteve French else 4313*38c8a9a5SSteve French pid = current->tgid; 4314*38c8a9a5SSteve French 4315*38c8a9a5SSteve French if ((file->f_flags & O_ACCMODE) == O_WRONLY) 4316*38c8a9a5SSteve French cifs_dbg(FYI, "attempting read on write only file instance\n"); 4317*38c8a9a5SSteve French 4318*38c8a9a5SSteve French for (total_read = 0, cur_offset = read_data; read_size > total_read; 4319*38c8a9a5SSteve French total_read += bytes_read, cur_offset += bytes_read) { 4320*38c8a9a5SSteve French do { 4321*38c8a9a5SSteve French current_read_size = min_t(uint, read_size - total_read, 4322*38c8a9a5SSteve French rsize); 4323*38c8a9a5SSteve French /* 4324*38c8a9a5SSteve French * For windows me and 9x we do not want to request more 4325*38c8a9a5SSteve French * than it negotiated since it will refuse the read 4326*38c8a9a5SSteve French * then. 4327*38c8a9a5SSteve French */ 4328*38c8a9a5SSteve French if (!(tcon->ses->capabilities & 4329*38c8a9a5SSteve French tcon->ses->server->vals->cap_large_files)) { 4330*38c8a9a5SSteve French current_read_size = min_t(uint, 4331*38c8a9a5SSteve French current_read_size, CIFSMaxBufSize); 4332*38c8a9a5SSteve French } 4333*38c8a9a5SSteve French if (open_file->invalidHandle) { 4334*38c8a9a5SSteve French rc = cifs_reopen_file(open_file, true); 4335*38c8a9a5SSteve French if (rc != 0) 4336*38c8a9a5SSteve French break; 4337*38c8a9a5SSteve French } 4338*38c8a9a5SSteve French io_parms.pid = pid; 4339*38c8a9a5SSteve French io_parms.tcon = tcon; 4340*38c8a9a5SSteve French io_parms.offset = *offset; 4341*38c8a9a5SSteve French io_parms.length = current_read_size; 4342*38c8a9a5SSteve French io_parms.server = server; 4343*38c8a9a5SSteve French rc = server->ops->sync_read(xid, &open_file->fid, &io_parms, 4344*38c8a9a5SSteve French &bytes_read, &cur_offset, 4345*38c8a9a5SSteve French &buf_type); 4346*38c8a9a5SSteve French } while (rc == -EAGAIN); 4347*38c8a9a5SSteve French 4348*38c8a9a5SSteve French if (rc || (bytes_read == 0)) { 4349*38c8a9a5SSteve French if (total_read) { 4350*38c8a9a5SSteve French break; 4351*38c8a9a5SSteve French } else { 4352*38c8a9a5SSteve French free_xid(xid); 4353*38c8a9a5SSteve French return rc; 4354*38c8a9a5SSteve French } 4355*38c8a9a5SSteve French } else { 4356*38c8a9a5SSteve French cifs_stats_bytes_read(tcon, total_read); 4357*38c8a9a5SSteve French *offset += bytes_read; 4358*38c8a9a5SSteve French } 4359*38c8a9a5SSteve French } 4360*38c8a9a5SSteve French free_xid(xid); 4361*38c8a9a5SSteve French return total_read; 4362*38c8a9a5SSteve French } 4363*38c8a9a5SSteve French 4364*38c8a9a5SSteve French /* 4365*38c8a9a5SSteve French * If the page is mmap'ed into a process' page tables, then we need to make 4366*38c8a9a5SSteve French * sure that it doesn't change while being written back. 4367*38c8a9a5SSteve French */ 4368*38c8a9a5SSteve French static vm_fault_t cifs_page_mkwrite(struct vm_fault *vmf) 4369*38c8a9a5SSteve French { 4370*38c8a9a5SSteve French struct folio *folio = page_folio(vmf->page); 4371*38c8a9a5SSteve French 4372*38c8a9a5SSteve French /* Wait for the folio to be written to the cache before we allow it to 4373*38c8a9a5SSteve French * be modified. We then assume the entire folio will need writing back. 4374*38c8a9a5SSteve French */ 4375*38c8a9a5SSteve French #ifdef CONFIG_CIFS_FSCACHE 4376*38c8a9a5SSteve French if (folio_test_fscache(folio) && 4377*38c8a9a5SSteve French folio_wait_fscache_killable(folio) < 0) 4378*38c8a9a5SSteve French return VM_FAULT_RETRY; 4379*38c8a9a5SSteve French #endif 4380*38c8a9a5SSteve French 4381*38c8a9a5SSteve French folio_wait_writeback(folio); 4382*38c8a9a5SSteve French 4383*38c8a9a5SSteve French if (folio_lock_killable(folio) < 0) 4384*38c8a9a5SSteve French return VM_FAULT_RETRY; 4385*38c8a9a5SSteve French return VM_FAULT_LOCKED; 4386*38c8a9a5SSteve French } 4387*38c8a9a5SSteve French 4388*38c8a9a5SSteve French static const struct vm_operations_struct cifs_file_vm_ops = { 4389*38c8a9a5SSteve French .fault = filemap_fault, 4390*38c8a9a5SSteve French .map_pages = filemap_map_pages, 4391*38c8a9a5SSteve French .page_mkwrite = cifs_page_mkwrite, 4392*38c8a9a5SSteve French }; 4393*38c8a9a5SSteve French 4394*38c8a9a5SSteve French int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma) 4395*38c8a9a5SSteve French { 4396*38c8a9a5SSteve French int xid, rc = 0; 4397*38c8a9a5SSteve French struct inode *inode = file_inode(file); 4398*38c8a9a5SSteve French 4399*38c8a9a5SSteve French xid = get_xid(); 4400*38c8a9a5SSteve French 4401*38c8a9a5SSteve French if (!CIFS_CACHE_READ(CIFS_I(inode))) 4402*38c8a9a5SSteve French rc = cifs_zap_mapping(inode); 4403*38c8a9a5SSteve French if (!rc) 4404*38c8a9a5SSteve French rc = generic_file_mmap(file, vma); 4405*38c8a9a5SSteve French if (!rc) 4406*38c8a9a5SSteve French vma->vm_ops = &cifs_file_vm_ops; 4407*38c8a9a5SSteve French 4408*38c8a9a5SSteve French free_xid(xid); 4409*38c8a9a5SSteve French return rc; 4410*38c8a9a5SSteve French } 4411*38c8a9a5SSteve French 4412*38c8a9a5SSteve French int cifs_file_mmap(struct file *file, struct vm_area_struct *vma) 4413*38c8a9a5SSteve French { 4414*38c8a9a5SSteve French int rc, xid; 4415*38c8a9a5SSteve French 4416*38c8a9a5SSteve French xid = get_xid(); 4417*38c8a9a5SSteve French 4418*38c8a9a5SSteve French rc = cifs_revalidate_file(file); 4419*38c8a9a5SSteve French if (rc) 4420*38c8a9a5SSteve French cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n", 4421*38c8a9a5SSteve French rc); 4422*38c8a9a5SSteve French if (!rc) 4423*38c8a9a5SSteve French rc = generic_file_mmap(file, vma); 4424*38c8a9a5SSteve French if (!rc) 4425*38c8a9a5SSteve French vma->vm_ops = &cifs_file_vm_ops; 4426*38c8a9a5SSteve French 4427*38c8a9a5SSteve French free_xid(xid); 4428*38c8a9a5SSteve French return rc; 4429*38c8a9a5SSteve French } 4430*38c8a9a5SSteve French 4431*38c8a9a5SSteve French /* 4432*38c8a9a5SSteve French * Unlock a bunch of folios in the pagecache. 4433*38c8a9a5SSteve French */ 4434*38c8a9a5SSteve French static void cifs_unlock_folios(struct address_space *mapping, pgoff_t first, pgoff_t last) 4435*38c8a9a5SSteve French { 4436*38c8a9a5SSteve French struct folio *folio; 4437*38c8a9a5SSteve French XA_STATE(xas, &mapping->i_pages, first); 4438*38c8a9a5SSteve French 4439*38c8a9a5SSteve French rcu_read_lock(); 4440*38c8a9a5SSteve French xas_for_each(&xas, folio, last) { 4441*38c8a9a5SSteve French folio_unlock(folio); 4442*38c8a9a5SSteve French } 4443*38c8a9a5SSteve French rcu_read_unlock(); 4444*38c8a9a5SSteve French } 4445*38c8a9a5SSteve French 4446*38c8a9a5SSteve French static void cifs_readahead_complete(struct work_struct *work) 4447*38c8a9a5SSteve French { 4448*38c8a9a5SSteve French struct cifs_readdata *rdata = container_of(work, 4449*38c8a9a5SSteve French struct cifs_readdata, work); 4450*38c8a9a5SSteve French struct folio *folio; 4451*38c8a9a5SSteve French pgoff_t last; 4452*38c8a9a5SSteve French bool good = rdata->result == 0 || (rdata->result == -EAGAIN && rdata->got_bytes); 4453*38c8a9a5SSteve French 4454*38c8a9a5SSteve French XA_STATE(xas, &rdata->mapping->i_pages, rdata->offset / PAGE_SIZE); 4455*38c8a9a5SSteve French 4456*38c8a9a5SSteve French if (good) 4457*38c8a9a5SSteve French cifs_readahead_to_fscache(rdata->mapping->host, 4458*38c8a9a5SSteve French rdata->offset, rdata->bytes); 4459*38c8a9a5SSteve French 4460*38c8a9a5SSteve French if (iov_iter_count(&rdata->iter) > 0) 4461*38c8a9a5SSteve French iov_iter_zero(iov_iter_count(&rdata->iter), &rdata->iter); 4462*38c8a9a5SSteve French 4463*38c8a9a5SSteve French last = (rdata->offset + rdata->bytes - 1) / PAGE_SIZE; 4464*38c8a9a5SSteve French 4465*38c8a9a5SSteve French rcu_read_lock(); 4466*38c8a9a5SSteve French xas_for_each(&xas, folio, last) { 4467*38c8a9a5SSteve French if (good) { 4468*38c8a9a5SSteve French flush_dcache_folio(folio); 4469*38c8a9a5SSteve French folio_mark_uptodate(folio); 4470*38c8a9a5SSteve French } 4471*38c8a9a5SSteve French folio_unlock(folio); 4472*38c8a9a5SSteve French } 4473*38c8a9a5SSteve French rcu_read_unlock(); 4474*38c8a9a5SSteve French 4475*38c8a9a5SSteve French kref_put(&rdata->refcount, cifs_readdata_release); 4476*38c8a9a5SSteve French } 4477*38c8a9a5SSteve French 4478*38c8a9a5SSteve French static void cifs_readahead(struct readahead_control *ractl) 4479*38c8a9a5SSteve French { 4480*38c8a9a5SSteve French struct cifsFileInfo *open_file = ractl->file->private_data; 4481*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(ractl->file); 4482*38c8a9a5SSteve French struct TCP_Server_Info *server; 4483*38c8a9a5SSteve French unsigned int xid, nr_pages, cache_nr_pages = 0; 4484*38c8a9a5SSteve French unsigned int ra_pages; 4485*38c8a9a5SSteve French pgoff_t next_cached = ULONG_MAX, ra_index; 4486*38c8a9a5SSteve French bool caching = fscache_cookie_enabled(cifs_inode_cookie(ractl->mapping->host)) && 4487*38c8a9a5SSteve French cifs_inode_cookie(ractl->mapping->host)->cache_priv; 4488*38c8a9a5SSteve French bool check_cache = caching; 4489*38c8a9a5SSteve French pid_t pid; 4490*38c8a9a5SSteve French int rc = 0; 4491*38c8a9a5SSteve French 4492*38c8a9a5SSteve French /* Note that readahead_count() lags behind our dequeuing of pages from 4493*38c8a9a5SSteve French * the ractl, wo we have to keep track for ourselves. 4494*38c8a9a5SSteve French */ 4495*38c8a9a5SSteve French ra_pages = readahead_count(ractl); 4496*38c8a9a5SSteve French ra_index = readahead_index(ractl); 4497*38c8a9a5SSteve French 4498*38c8a9a5SSteve French xid = get_xid(); 4499*38c8a9a5SSteve French 4500*38c8a9a5SSteve French if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD) 4501*38c8a9a5SSteve French pid = open_file->pid; 4502*38c8a9a5SSteve French else 4503*38c8a9a5SSteve French pid = current->tgid; 4504*38c8a9a5SSteve French 4505*38c8a9a5SSteve French server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses); 4506*38c8a9a5SSteve French 4507*38c8a9a5SSteve French cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n", 4508*38c8a9a5SSteve French __func__, ractl->file, ractl->mapping, ra_pages); 4509*38c8a9a5SSteve French 4510*38c8a9a5SSteve French /* 4511*38c8a9a5SSteve French * Chop the readahead request up into rsize-sized read requests. 4512*38c8a9a5SSteve French */ 4513*38c8a9a5SSteve French while ((nr_pages = ra_pages)) { 4514*38c8a9a5SSteve French unsigned int i, rsize; 4515*38c8a9a5SSteve French struct cifs_readdata *rdata; 4516*38c8a9a5SSteve French struct cifs_credits credits_on_stack; 4517*38c8a9a5SSteve French struct cifs_credits *credits = &credits_on_stack; 4518*38c8a9a5SSteve French struct folio *folio; 4519*38c8a9a5SSteve French pgoff_t fsize; 4520*38c8a9a5SSteve French 4521*38c8a9a5SSteve French /* 4522*38c8a9a5SSteve French * Find out if we have anything cached in the range of 4523*38c8a9a5SSteve French * interest, and if so, where the next chunk of cached data is. 4524*38c8a9a5SSteve French */ 4525*38c8a9a5SSteve French if (caching) { 4526*38c8a9a5SSteve French if (check_cache) { 4527*38c8a9a5SSteve French rc = cifs_fscache_query_occupancy( 4528*38c8a9a5SSteve French ractl->mapping->host, ra_index, nr_pages, 4529*38c8a9a5SSteve French &next_cached, &cache_nr_pages); 4530*38c8a9a5SSteve French if (rc < 0) 4531*38c8a9a5SSteve French caching = false; 4532*38c8a9a5SSteve French check_cache = false; 4533*38c8a9a5SSteve French } 4534*38c8a9a5SSteve French 4535*38c8a9a5SSteve French if (ra_index == next_cached) { 4536*38c8a9a5SSteve French /* 4537*38c8a9a5SSteve French * TODO: Send a whole batch of pages to be read 4538*38c8a9a5SSteve French * by the cache. 4539*38c8a9a5SSteve French */ 4540*38c8a9a5SSteve French folio = readahead_folio(ractl); 4541*38c8a9a5SSteve French fsize = folio_nr_pages(folio); 4542*38c8a9a5SSteve French ra_pages -= fsize; 4543*38c8a9a5SSteve French ra_index += fsize; 4544*38c8a9a5SSteve French if (cifs_readpage_from_fscache(ractl->mapping->host, 4545*38c8a9a5SSteve French &folio->page) < 0) { 4546*38c8a9a5SSteve French /* 4547*38c8a9a5SSteve French * TODO: Deal with cache read failure 4548*38c8a9a5SSteve French * here, but for the moment, delegate 4549*38c8a9a5SSteve French * that to readpage. 4550*38c8a9a5SSteve French */ 4551*38c8a9a5SSteve French caching = false; 4552*38c8a9a5SSteve French } 4553*38c8a9a5SSteve French folio_unlock(folio); 4554*38c8a9a5SSteve French next_cached += fsize; 4555*38c8a9a5SSteve French cache_nr_pages -= fsize; 4556*38c8a9a5SSteve French if (cache_nr_pages == 0) 4557*38c8a9a5SSteve French check_cache = true; 4558*38c8a9a5SSteve French continue; 4559*38c8a9a5SSteve French } 4560*38c8a9a5SSteve French } 4561*38c8a9a5SSteve French 4562*38c8a9a5SSteve French if (open_file->invalidHandle) { 4563*38c8a9a5SSteve French rc = cifs_reopen_file(open_file, true); 4564*38c8a9a5SSteve French if (rc) { 4565*38c8a9a5SSteve French if (rc == -EAGAIN) 4566*38c8a9a5SSteve French continue; 4567*38c8a9a5SSteve French break; 4568*38c8a9a5SSteve French } 4569*38c8a9a5SSteve French } 4570*38c8a9a5SSteve French 4571*38c8a9a5SSteve French if (cifs_sb->ctx->rsize == 0) 4572*38c8a9a5SSteve French cifs_sb->ctx->rsize = 4573*38c8a9a5SSteve French server->ops->negotiate_rsize(tlink_tcon(open_file->tlink), 4574*38c8a9a5SSteve French cifs_sb->ctx); 4575*38c8a9a5SSteve French 4576*38c8a9a5SSteve French rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize, 4577*38c8a9a5SSteve French &rsize, credits); 4578*38c8a9a5SSteve French if (rc) 4579*38c8a9a5SSteve French break; 4580*38c8a9a5SSteve French nr_pages = min_t(size_t, rsize / PAGE_SIZE, ra_pages); 4581*38c8a9a5SSteve French if (next_cached != ULONG_MAX) 4582*38c8a9a5SSteve French nr_pages = min_t(size_t, nr_pages, next_cached - ra_index); 4583*38c8a9a5SSteve French 4584*38c8a9a5SSteve French /* 4585*38c8a9a5SSteve French * Give up immediately if rsize is too small to read an entire 4586*38c8a9a5SSteve French * page. The VFS will fall back to readpage. We should never 4587*38c8a9a5SSteve French * reach this point however since we set ra_pages to 0 when the 4588*38c8a9a5SSteve French * rsize is smaller than a cache page. 4589*38c8a9a5SSteve French */ 4590*38c8a9a5SSteve French if (unlikely(!nr_pages)) { 4591*38c8a9a5SSteve French add_credits_and_wake_if(server, credits, 0); 4592*38c8a9a5SSteve French break; 4593*38c8a9a5SSteve French } 4594*38c8a9a5SSteve French 4595*38c8a9a5SSteve French rdata = cifs_readdata_alloc(cifs_readahead_complete); 4596*38c8a9a5SSteve French if (!rdata) { 4597*38c8a9a5SSteve French /* best to give up if we're out of mem */ 4598*38c8a9a5SSteve French add_credits_and_wake_if(server, credits, 0); 4599*38c8a9a5SSteve French break; 4600*38c8a9a5SSteve French } 4601*38c8a9a5SSteve French 4602*38c8a9a5SSteve French rdata->offset = ra_index * PAGE_SIZE; 4603*38c8a9a5SSteve French rdata->bytes = nr_pages * PAGE_SIZE; 4604*38c8a9a5SSteve French rdata->cfile = cifsFileInfo_get(open_file); 4605*38c8a9a5SSteve French rdata->server = server; 4606*38c8a9a5SSteve French rdata->mapping = ractl->mapping; 4607*38c8a9a5SSteve French rdata->pid = pid; 4608*38c8a9a5SSteve French rdata->credits = credits_on_stack; 4609*38c8a9a5SSteve French 4610*38c8a9a5SSteve French for (i = 0; i < nr_pages; i++) { 4611*38c8a9a5SSteve French if (!readahead_folio(ractl)) 4612*38c8a9a5SSteve French WARN_ON(1); 4613*38c8a9a5SSteve French } 4614*38c8a9a5SSteve French ra_pages -= nr_pages; 4615*38c8a9a5SSteve French ra_index += nr_pages; 4616*38c8a9a5SSteve French 4617*38c8a9a5SSteve French iov_iter_xarray(&rdata->iter, ITER_DEST, &rdata->mapping->i_pages, 4618*38c8a9a5SSteve French rdata->offset, rdata->bytes); 4619*38c8a9a5SSteve French 4620*38c8a9a5SSteve French rc = adjust_credits(server, &rdata->credits, rdata->bytes); 4621*38c8a9a5SSteve French if (!rc) { 4622*38c8a9a5SSteve French if (rdata->cfile->invalidHandle) 4623*38c8a9a5SSteve French rc = -EAGAIN; 4624*38c8a9a5SSteve French else 4625*38c8a9a5SSteve French rc = server->ops->async_readv(rdata); 4626*38c8a9a5SSteve French } 4627*38c8a9a5SSteve French 4628*38c8a9a5SSteve French if (rc) { 4629*38c8a9a5SSteve French add_credits_and_wake_if(server, &rdata->credits, 0); 4630*38c8a9a5SSteve French cifs_unlock_folios(rdata->mapping, 4631*38c8a9a5SSteve French rdata->offset / PAGE_SIZE, 4632*38c8a9a5SSteve French (rdata->offset + rdata->bytes - 1) / PAGE_SIZE); 4633*38c8a9a5SSteve French /* Fallback to the readpage in error/reconnect cases */ 4634*38c8a9a5SSteve French kref_put(&rdata->refcount, cifs_readdata_release); 4635*38c8a9a5SSteve French break; 4636*38c8a9a5SSteve French } 4637*38c8a9a5SSteve French 4638*38c8a9a5SSteve French kref_put(&rdata->refcount, cifs_readdata_release); 4639*38c8a9a5SSteve French } 4640*38c8a9a5SSteve French 4641*38c8a9a5SSteve French free_xid(xid); 4642*38c8a9a5SSteve French } 4643*38c8a9a5SSteve French 4644*38c8a9a5SSteve French /* 4645*38c8a9a5SSteve French * cifs_readpage_worker must be called with the page pinned 4646*38c8a9a5SSteve French */ 4647*38c8a9a5SSteve French static int cifs_readpage_worker(struct file *file, struct page *page, 4648*38c8a9a5SSteve French loff_t *poffset) 4649*38c8a9a5SSteve French { 4650*38c8a9a5SSteve French char *read_data; 4651*38c8a9a5SSteve French int rc; 4652*38c8a9a5SSteve French 4653*38c8a9a5SSteve French /* Is the page cached? */ 4654*38c8a9a5SSteve French rc = cifs_readpage_from_fscache(file_inode(file), page); 4655*38c8a9a5SSteve French if (rc == 0) 4656*38c8a9a5SSteve French goto read_complete; 4657*38c8a9a5SSteve French 4658*38c8a9a5SSteve French read_data = kmap(page); 4659*38c8a9a5SSteve French /* for reads over a certain size could initiate async read ahead */ 4660*38c8a9a5SSteve French 4661*38c8a9a5SSteve French rc = cifs_read(file, read_data, PAGE_SIZE, poffset); 4662*38c8a9a5SSteve French 4663*38c8a9a5SSteve French if (rc < 0) 4664*38c8a9a5SSteve French goto io_error; 4665*38c8a9a5SSteve French else 4666*38c8a9a5SSteve French cifs_dbg(FYI, "Bytes read %d\n", rc); 4667*38c8a9a5SSteve French 4668*38c8a9a5SSteve French /* we do not want atime to be less than mtime, it broke some apps */ 4669*38c8a9a5SSteve French file_inode(file)->i_atime = current_time(file_inode(file)); 4670*38c8a9a5SSteve French if (timespec64_compare(&(file_inode(file)->i_atime), &(file_inode(file)->i_mtime))) 4671*38c8a9a5SSteve French file_inode(file)->i_atime = file_inode(file)->i_mtime; 4672*38c8a9a5SSteve French else 4673*38c8a9a5SSteve French file_inode(file)->i_atime = current_time(file_inode(file)); 4674*38c8a9a5SSteve French 4675*38c8a9a5SSteve French if (PAGE_SIZE > rc) 4676*38c8a9a5SSteve French memset(read_data + rc, 0, PAGE_SIZE - rc); 4677*38c8a9a5SSteve French 4678*38c8a9a5SSteve French flush_dcache_page(page); 4679*38c8a9a5SSteve French SetPageUptodate(page); 4680*38c8a9a5SSteve French rc = 0; 4681*38c8a9a5SSteve French 4682*38c8a9a5SSteve French io_error: 4683*38c8a9a5SSteve French kunmap(page); 4684*38c8a9a5SSteve French unlock_page(page); 4685*38c8a9a5SSteve French 4686*38c8a9a5SSteve French read_complete: 4687*38c8a9a5SSteve French return rc; 4688*38c8a9a5SSteve French } 4689*38c8a9a5SSteve French 4690*38c8a9a5SSteve French static int cifs_read_folio(struct file *file, struct folio *folio) 4691*38c8a9a5SSteve French { 4692*38c8a9a5SSteve French struct page *page = &folio->page; 4693*38c8a9a5SSteve French loff_t offset = page_file_offset(page); 4694*38c8a9a5SSteve French int rc = -EACCES; 4695*38c8a9a5SSteve French unsigned int xid; 4696*38c8a9a5SSteve French 4697*38c8a9a5SSteve French xid = get_xid(); 4698*38c8a9a5SSteve French 4699*38c8a9a5SSteve French if (file->private_data == NULL) { 4700*38c8a9a5SSteve French rc = -EBADF; 4701*38c8a9a5SSteve French free_xid(xid); 4702*38c8a9a5SSteve French return rc; 4703*38c8a9a5SSteve French } 4704*38c8a9a5SSteve French 4705*38c8a9a5SSteve French cifs_dbg(FYI, "read_folio %p at offset %d 0x%x\n", 4706*38c8a9a5SSteve French page, (int)offset, (int)offset); 4707*38c8a9a5SSteve French 4708*38c8a9a5SSteve French rc = cifs_readpage_worker(file, page, &offset); 4709*38c8a9a5SSteve French 4710*38c8a9a5SSteve French free_xid(xid); 4711*38c8a9a5SSteve French return rc; 4712*38c8a9a5SSteve French } 4713*38c8a9a5SSteve French 4714*38c8a9a5SSteve French static int is_inode_writable(struct cifsInodeInfo *cifs_inode) 4715*38c8a9a5SSteve French { 4716*38c8a9a5SSteve French struct cifsFileInfo *open_file; 4717*38c8a9a5SSteve French 4718*38c8a9a5SSteve French spin_lock(&cifs_inode->open_file_lock); 4719*38c8a9a5SSteve French list_for_each_entry(open_file, &cifs_inode->openFileList, flist) { 4720*38c8a9a5SSteve French if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) { 4721*38c8a9a5SSteve French spin_unlock(&cifs_inode->open_file_lock); 4722*38c8a9a5SSteve French return 1; 4723*38c8a9a5SSteve French } 4724*38c8a9a5SSteve French } 4725*38c8a9a5SSteve French spin_unlock(&cifs_inode->open_file_lock); 4726*38c8a9a5SSteve French return 0; 4727*38c8a9a5SSteve French } 4728*38c8a9a5SSteve French 4729*38c8a9a5SSteve French /* We do not want to update the file size from server for inodes 4730*38c8a9a5SSteve French open for write - to avoid races with writepage extending 4731*38c8a9a5SSteve French the file - in the future we could consider allowing 4732*38c8a9a5SSteve French refreshing the inode only on increases in the file size 4733*38c8a9a5SSteve French but this is tricky to do without racing with writebehind 4734*38c8a9a5SSteve French page caching in the current Linux kernel design */ 4735*38c8a9a5SSteve French bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file) 4736*38c8a9a5SSteve French { 4737*38c8a9a5SSteve French if (!cifsInode) 4738*38c8a9a5SSteve French return true; 4739*38c8a9a5SSteve French 4740*38c8a9a5SSteve French if (is_inode_writable(cifsInode)) { 4741*38c8a9a5SSteve French /* This inode is open for write at least once */ 4742*38c8a9a5SSteve French struct cifs_sb_info *cifs_sb; 4743*38c8a9a5SSteve French 4744*38c8a9a5SSteve French cifs_sb = CIFS_SB(cifsInode->netfs.inode.i_sb); 4745*38c8a9a5SSteve French if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) { 4746*38c8a9a5SSteve French /* since no page cache to corrupt on directio 4747*38c8a9a5SSteve French we can change size safely */ 4748*38c8a9a5SSteve French return true; 4749*38c8a9a5SSteve French } 4750*38c8a9a5SSteve French 4751*38c8a9a5SSteve French if (i_size_read(&cifsInode->netfs.inode) < end_of_file) 4752*38c8a9a5SSteve French return true; 4753*38c8a9a5SSteve French 4754*38c8a9a5SSteve French return false; 4755*38c8a9a5SSteve French } else 4756*38c8a9a5SSteve French return true; 4757*38c8a9a5SSteve French } 4758*38c8a9a5SSteve French 4759*38c8a9a5SSteve French static int cifs_write_begin(struct file *file, struct address_space *mapping, 4760*38c8a9a5SSteve French loff_t pos, unsigned len, 4761*38c8a9a5SSteve French struct page **pagep, void **fsdata) 4762*38c8a9a5SSteve French { 4763*38c8a9a5SSteve French int oncethru = 0; 4764*38c8a9a5SSteve French pgoff_t index = pos >> PAGE_SHIFT; 4765*38c8a9a5SSteve French loff_t offset = pos & (PAGE_SIZE - 1); 4766*38c8a9a5SSteve French loff_t page_start = pos & PAGE_MASK; 4767*38c8a9a5SSteve French loff_t i_size; 4768*38c8a9a5SSteve French struct page *page; 4769*38c8a9a5SSteve French int rc = 0; 4770*38c8a9a5SSteve French 4771*38c8a9a5SSteve French cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len); 4772*38c8a9a5SSteve French 4773*38c8a9a5SSteve French start: 4774*38c8a9a5SSteve French page = grab_cache_page_write_begin(mapping, index); 4775*38c8a9a5SSteve French if (!page) { 4776*38c8a9a5SSteve French rc = -ENOMEM; 4777*38c8a9a5SSteve French goto out; 4778*38c8a9a5SSteve French } 4779*38c8a9a5SSteve French 4780*38c8a9a5SSteve French if (PageUptodate(page)) 4781*38c8a9a5SSteve French goto out; 4782*38c8a9a5SSteve French 4783*38c8a9a5SSteve French /* 4784*38c8a9a5SSteve French * If we write a full page it will be up to date, no need to read from 4785*38c8a9a5SSteve French * the server. If the write is short, we'll end up doing a sync write 4786*38c8a9a5SSteve French * instead. 4787*38c8a9a5SSteve French */ 4788*38c8a9a5SSteve French if (len == PAGE_SIZE) 4789*38c8a9a5SSteve French goto out; 4790*38c8a9a5SSteve French 4791*38c8a9a5SSteve French /* 4792*38c8a9a5SSteve French * optimize away the read when we have an oplock, and we're not 4793*38c8a9a5SSteve French * expecting to use any of the data we'd be reading in. That 4794*38c8a9a5SSteve French * is, when the page lies beyond the EOF, or straddles the EOF 4795*38c8a9a5SSteve French * and the write will cover all of the existing data. 4796*38c8a9a5SSteve French */ 4797*38c8a9a5SSteve French if (CIFS_CACHE_READ(CIFS_I(mapping->host))) { 4798*38c8a9a5SSteve French i_size = i_size_read(mapping->host); 4799*38c8a9a5SSteve French if (page_start >= i_size || 4800*38c8a9a5SSteve French (offset == 0 && (pos + len) >= i_size)) { 4801*38c8a9a5SSteve French zero_user_segments(page, 0, offset, 4802*38c8a9a5SSteve French offset + len, 4803*38c8a9a5SSteve French PAGE_SIZE); 4804*38c8a9a5SSteve French /* 4805*38c8a9a5SSteve French * PageChecked means that the parts of the page 4806*38c8a9a5SSteve French * to which we're not writing are considered up 4807*38c8a9a5SSteve French * to date. Once the data is copied to the 4808*38c8a9a5SSteve French * page, it can be set uptodate. 4809*38c8a9a5SSteve French */ 4810*38c8a9a5SSteve French SetPageChecked(page); 4811*38c8a9a5SSteve French goto out; 4812*38c8a9a5SSteve French } 4813*38c8a9a5SSteve French } 4814*38c8a9a5SSteve French 4815*38c8a9a5SSteve French if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) { 4816*38c8a9a5SSteve French /* 4817*38c8a9a5SSteve French * might as well read a page, it is fast enough. If we get 4818*38c8a9a5SSteve French * an error, we don't need to return it. cifs_write_end will 4819*38c8a9a5SSteve French * do a sync write instead since PG_uptodate isn't set. 4820*38c8a9a5SSteve French */ 4821*38c8a9a5SSteve French cifs_readpage_worker(file, page, &page_start); 4822*38c8a9a5SSteve French put_page(page); 4823*38c8a9a5SSteve French oncethru = 1; 4824*38c8a9a5SSteve French goto start; 4825*38c8a9a5SSteve French } else { 4826*38c8a9a5SSteve French /* we could try using another file handle if there is one - 4827*38c8a9a5SSteve French but how would we lock it to prevent close of that handle 4828*38c8a9a5SSteve French racing with this read? In any case 4829*38c8a9a5SSteve French this will be written out by write_end so is fine */ 4830*38c8a9a5SSteve French } 4831*38c8a9a5SSteve French out: 4832*38c8a9a5SSteve French *pagep = page; 4833*38c8a9a5SSteve French return rc; 4834*38c8a9a5SSteve French } 4835*38c8a9a5SSteve French 4836*38c8a9a5SSteve French static bool cifs_release_folio(struct folio *folio, gfp_t gfp) 4837*38c8a9a5SSteve French { 4838*38c8a9a5SSteve French if (folio_test_private(folio)) 4839*38c8a9a5SSteve French return 0; 4840*38c8a9a5SSteve French if (folio_test_fscache(folio)) { 4841*38c8a9a5SSteve French if (current_is_kswapd() || !(gfp & __GFP_FS)) 4842*38c8a9a5SSteve French return false; 4843*38c8a9a5SSteve French folio_wait_fscache(folio); 4844*38c8a9a5SSteve French } 4845*38c8a9a5SSteve French fscache_note_page_release(cifs_inode_cookie(folio->mapping->host)); 4846*38c8a9a5SSteve French return true; 4847*38c8a9a5SSteve French } 4848*38c8a9a5SSteve French 4849*38c8a9a5SSteve French static void cifs_invalidate_folio(struct folio *folio, size_t offset, 4850*38c8a9a5SSteve French size_t length) 4851*38c8a9a5SSteve French { 4852*38c8a9a5SSteve French folio_wait_fscache(folio); 4853*38c8a9a5SSteve French } 4854*38c8a9a5SSteve French 4855*38c8a9a5SSteve French static int cifs_launder_folio(struct folio *folio) 4856*38c8a9a5SSteve French { 4857*38c8a9a5SSteve French int rc = 0; 4858*38c8a9a5SSteve French loff_t range_start = folio_pos(folio); 4859*38c8a9a5SSteve French loff_t range_end = range_start + folio_size(folio); 4860*38c8a9a5SSteve French struct writeback_control wbc = { 4861*38c8a9a5SSteve French .sync_mode = WB_SYNC_ALL, 4862*38c8a9a5SSteve French .nr_to_write = 0, 4863*38c8a9a5SSteve French .range_start = range_start, 4864*38c8a9a5SSteve French .range_end = range_end, 4865*38c8a9a5SSteve French }; 4866*38c8a9a5SSteve French 4867*38c8a9a5SSteve French cifs_dbg(FYI, "Launder page: %lu\n", folio->index); 4868*38c8a9a5SSteve French 4869*38c8a9a5SSteve French if (folio_clear_dirty_for_io(folio)) 4870*38c8a9a5SSteve French rc = cifs_writepage_locked(&folio->page, &wbc); 4871*38c8a9a5SSteve French 4872*38c8a9a5SSteve French folio_wait_fscache(folio); 4873*38c8a9a5SSteve French return rc; 4874*38c8a9a5SSteve French } 4875*38c8a9a5SSteve French 4876*38c8a9a5SSteve French void cifs_oplock_break(struct work_struct *work) 4877*38c8a9a5SSteve French { 4878*38c8a9a5SSteve French struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo, 4879*38c8a9a5SSteve French oplock_break); 4880*38c8a9a5SSteve French struct inode *inode = d_inode(cfile->dentry); 4881*38c8a9a5SSteve French struct cifsInodeInfo *cinode = CIFS_I(inode); 4882*38c8a9a5SSteve French struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 4883*38c8a9a5SSteve French struct TCP_Server_Info *server = tcon->ses->server; 4884*38c8a9a5SSteve French int rc = 0; 4885*38c8a9a5SSteve French bool purge_cache = false, oplock_break_cancelled; 4886*38c8a9a5SSteve French __u64 persistent_fid, volatile_fid; 4887*38c8a9a5SSteve French __u16 net_fid; 4888*38c8a9a5SSteve French 4889*38c8a9a5SSteve French wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS, 4890*38c8a9a5SSteve French TASK_UNINTERRUPTIBLE); 4891*38c8a9a5SSteve French 4892*38c8a9a5SSteve French server->ops->downgrade_oplock(server, cinode, cfile->oplock_level, 4893*38c8a9a5SSteve French cfile->oplock_epoch, &purge_cache); 4894*38c8a9a5SSteve French 4895*38c8a9a5SSteve French if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) && 4896*38c8a9a5SSteve French cifs_has_mand_locks(cinode)) { 4897*38c8a9a5SSteve French cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n", 4898*38c8a9a5SSteve French inode); 4899*38c8a9a5SSteve French cinode->oplock = 0; 4900*38c8a9a5SSteve French } 4901*38c8a9a5SSteve French 4902*38c8a9a5SSteve French if (inode && S_ISREG(inode->i_mode)) { 4903*38c8a9a5SSteve French if (CIFS_CACHE_READ(cinode)) 4904*38c8a9a5SSteve French break_lease(inode, O_RDONLY); 4905*38c8a9a5SSteve French else 4906*38c8a9a5SSteve French break_lease(inode, O_WRONLY); 4907*38c8a9a5SSteve French rc = filemap_fdatawrite(inode->i_mapping); 4908*38c8a9a5SSteve French if (!CIFS_CACHE_READ(cinode) || purge_cache) { 4909*38c8a9a5SSteve French rc = filemap_fdatawait(inode->i_mapping); 4910*38c8a9a5SSteve French mapping_set_error(inode->i_mapping, rc); 4911*38c8a9a5SSteve French cifs_zap_mapping(inode); 4912*38c8a9a5SSteve French } 4913*38c8a9a5SSteve French cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc); 4914*38c8a9a5SSteve French if (CIFS_CACHE_WRITE(cinode)) 4915*38c8a9a5SSteve French goto oplock_break_ack; 4916*38c8a9a5SSteve French } 4917*38c8a9a5SSteve French 4918*38c8a9a5SSteve French rc = cifs_push_locks(cfile); 4919*38c8a9a5SSteve French if (rc) 4920*38c8a9a5SSteve French cifs_dbg(VFS, "Push locks rc = %d\n", rc); 4921*38c8a9a5SSteve French 4922*38c8a9a5SSteve French oplock_break_ack: 4923*38c8a9a5SSteve French /* 4924*38c8a9a5SSteve French * When oplock break is received and there are no active 4925*38c8a9a5SSteve French * file handles but cached, then schedule deferred close immediately. 4926*38c8a9a5SSteve French * So, new open will not use cached handle. 4927*38c8a9a5SSteve French */ 4928*38c8a9a5SSteve French 4929*38c8a9a5SSteve French if (!CIFS_CACHE_HANDLE(cinode) && !list_empty(&cinode->deferred_closes)) 4930*38c8a9a5SSteve French cifs_close_deferred_file(cinode); 4931*38c8a9a5SSteve French 4932*38c8a9a5SSteve French persistent_fid = cfile->fid.persistent_fid; 4933*38c8a9a5SSteve French volatile_fid = cfile->fid.volatile_fid; 4934*38c8a9a5SSteve French net_fid = cfile->fid.netfid; 4935*38c8a9a5SSteve French oplock_break_cancelled = cfile->oplock_break_cancelled; 4936*38c8a9a5SSteve French 4937*38c8a9a5SSteve French _cifsFileInfo_put(cfile, false /* do not wait for ourself */, false); 4938*38c8a9a5SSteve French /* 4939*38c8a9a5SSteve French * releasing stale oplock after recent reconnect of smb session using 4940*38c8a9a5SSteve French * a now incorrect file handle is not a data integrity issue but do 4941*38c8a9a5SSteve French * not bother sending an oplock release if session to server still is 4942*38c8a9a5SSteve French * disconnected since oplock already released by the server 4943*38c8a9a5SSteve French */ 4944*38c8a9a5SSteve French if (!oplock_break_cancelled) { 4945*38c8a9a5SSteve French rc = tcon->ses->server->ops->oplock_response(tcon, persistent_fid, 4946*38c8a9a5SSteve French volatile_fid, net_fid, cinode); 4947*38c8a9a5SSteve French cifs_dbg(FYI, "Oplock release rc = %d\n", rc); 4948*38c8a9a5SSteve French } 4949*38c8a9a5SSteve French 4950*38c8a9a5SSteve French cifs_done_oplock_break(cinode); 4951*38c8a9a5SSteve French } 4952*38c8a9a5SSteve French 4953*38c8a9a5SSteve French /* 4954*38c8a9a5SSteve French * The presence of cifs_direct_io() in the address space ops vector 4955*38c8a9a5SSteve French * allowes open() O_DIRECT flags which would have failed otherwise. 4956*38c8a9a5SSteve French * 4957*38c8a9a5SSteve French * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests 4958*38c8a9a5SSteve French * so this method should never be called. 4959*38c8a9a5SSteve French * 4960*38c8a9a5SSteve French * Direct IO is not yet supported in the cached mode. 4961*38c8a9a5SSteve French */ 4962*38c8a9a5SSteve French static ssize_t 4963*38c8a9a5SSteve French cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter) 4964*38c8a9a5SSteve French { 4965*38c8a9a5SSteve French /* 4966*38c8a9a5SSteve French * FIXME 4967*38c8a9a5SSteve French * Eventually need to support direct IO for non forcedirectio mounts 4968*38c8a9a5SSteve French */ 4969*38c8a9a5SSteve French return -EINVAL; 4970*38c8a9a5SSteve French } 4971*38c8a9a5SSteve French 4972*38c8a9a5SSteve French static int cifs_swap_activate(struct swap_info_struct *sis, 4973*38c8a9a5SSteve French struct file *swap_file, sector_t *span) 4974*38c8a9a5SSteve French { 4975*38c8a9a5SSteve French struct cifsFileInfo *cfile = swap_file->private_data; 4976*38c8a9a5SSteve French struct inode *inode = swap_file->f_mapping->host; 4977*38c8a9a5SSteve French unsigned long blocks; 4978*38c8a9a5SSteve French long long isize; 4979*38c8a9a5SSteve French 4980*38c8a9a5SSteve French cifs_dbg(FYI, "swap activate\n"); 4981*38c8a9a5SSteve French 4982*38c8a9a5SSteve French if (!swap_file->f_mapping->a_ops->swap_rw) 4983*38c8a9a5SSteve French /* Cannot support swap */ 4984*38c8a9a5SSteve French return -EINVAL; 4985*38c8a9a5SSteve French 4986*38c8a9a5SSteve French spin_lock(&inode->i_lock); 4987*38c8a9a5SSteve French blocks = inode->i_blocks; 4988*38c8a9a5SSteve French isize = inode->i_size; 4989*38c8a9a5SSteve French spin_unlock(&inode->i_lock); 4990*38c8a9a5SSteve French if (blocks*512 < isize) { 4991*38c8a9a5SSteve French pr_warn("swap activate: swapfile has holes\n"); 4992*38c8a9a5SSteve French return -EINVAL; 4993*38c8a9a5SSteve French } 4994*38c8a9a5SSteve French *span = sis->pages; 4995*38c8a9a5SSteve French 4996*38c8a9a5SSteve French pr_warn_once("Swap support over SMB3 is experimental\n"); 4997*38c8a9a5SSteve French 4998*38c8a9a5SSteve French /* 4999*38c8a9a5SSteve French * TODO: consider adding ACL (or documenting how) to prevent other 5000*38c8a9a5SSteve French * users (on this or other systems) from reading it 5001*38c8a9a5SSteve French */ 5002*38c8a9a5SSteve French 5003*38c8a9a5SSteve French 5004*38c8a9a5SSteve French /* TODO: add sk_set_memalloc(inet) or similar */ 5005*38c8a9a5SSteve French 5006*38c8a9a5SSteve French if (cfile) 5007*38c8a9a5SSteve French cfile->swapfile = true; 5008*38c8a9a5SSteve French /* 5009*38c8a9a5SSteve French * TODO: Since file already open, we can't open with DENY_ALL here 5010*38c8a9a5SSteve French * but we could add call to grab a byte range lock to prevent others 5011*38c8a9a5SSteve French * from reading or writing the file 5012*38c8a9a5SSteve French */ 5013*38c8a9a5SSteve French 5014*38c8a9a5SSteve French sis->flags |= SWP_FS_OPS; 5015*38c8a9a5SSteve French return add_swap_extent(sis, 0, sis->max, 0); 5016*38c8a9a5SSteve French } 5017*38c8a9a5SSteve French 5018*38c8a9a5SSteve French static void cifs_swap_deactivate(struct file *file) 5019*38c8a9a5SSteve French { 5020*38c8a9a5SSteve French struct cifsFileInfo *cfile = file->private_data; 5021*38c8a9a5SSteve French 5022*38c8a9a5SSteve French cifs_dbg(FYI, "swap deactivate\n"); 5023*38c8a9a5SSteve French 5024*38c8a9a5SSteve French /* TODO: undo sk_set_memalloc(inet) will eventually be needed */ 5025*38c8a9a5SSteve French 5026*38c8a9a5SSteve French if (cfile) 5027*38c8a9a5SSteve French cfile->swapfile = false; 5028*38c8a9a5SSteve French 5029*38c8a9a5SSteve French /* do we need to unpin (or unlock) the file */ 5030*38c8a9a5SSteve French } 5031*38c8a9a5SSteve French 5032*38c8a9a5SSteve French /* 5033*38c8a9a5SSteve French * Mark a page as having been made dirty and thus needing writeback. We also 5034*38c8a9a5SSteve French * need to pin the cache object to write back to. 5035*38c8a9a5SSteve French */ 5036*38c8a9a5SSteve French #ifdef CONFIG_CIFS_FSCACHE 5037*38c8a9a5SSteve French static bool cifs_dirty_folio(struct address_space *mapping, struct folio *folio) 5038*38c8a9a5SSteve French { 5039*38c8a9a5SSteve French return fscache_dirty_folio(mapping, folio, 5040*38c8a9a5SSteve French cifs_inode_cookie(mapping->host)); 5041*38c8a9a5SSteve French } 5042*38c8a9a5SSteve French #else 5043*38c8a9a5SSteve French #define cifs_dirty_folio filemap_dirty_folio 5044*38c8a9a5SSteve French #endif 5045*38c8a9a5SSteve French 5046*38c8a9a5SSteve French const struct address_space_operations cifs_addr_ops = { 5047*38c8a9a5SSteve French .read_folio = cifs_read_folio, 5048*38c8a9a5SSteve French .readahead = cifs_readahead, 5049*38c8a9a5SSteve French .writepages = cifs_writepages, 5050*38c8a9a5SSteve French .write_begin = cifs_write_begin, 5051*38c8a9a5SSteve French .write_end = cifs_write_end, 5052*38c8a9a5SSteve French .dirty_folio = cifs_dirty_folio, 5053*38c8a9a5SSteve French .release_folio = cifs_release_folio, 5054*38c8a9a5SSteve French .direct_IO = cifs_direct_io, 5055*38c8a9a5SSteve French .invalidate_folio = cifs_invalidate_folio, 5056*38c8a9a5SSteve French .launder_folio = cifs_launder_folio, 5057*38c8a9a5SSteve French .migrate_folio = filemap_migrate_folio, 5058*38c8a9a5SSteve French /* 5059*38c8a9a5SSteve French * TODO: investigate and if useful we could add an is_dirty_writeback 5060*38c8a9a5SSteve French * helper if needed 5061*38c8a9a5SSteve French */ 5062*38c8a9a5SSteve French .swap_activate = cifs_swap_activate, 5063*38c8a9a5SSteve French .swap_deactivate = cifs_swap_deactivate, 5064*38c8a9a5SSteve French }; 5065*38c8a9a5SSteve French 5066*38c8a9a5SSteve French /* 5067*38c8a9a5SSteve French * cifs_readahead requires the server to support a buffer large enough to 5068*38c8a9a5SSteve French * contain the header plus one complete page of data. Otherwise, we need 5069*38c8a9a5SSteve French * to leave cifs_readahead out of the address space operations. 5070*38c8a9a5SSteve French */ 5071*38c8a9a5SSteve French const struct address_space_operations cifs_addr_ops_smallbuf = { 5072*38c8a9a5SSteve French .read_folio = cifs_read_folio, 5073*38c8a9a5SSteve French .writepages = cifs_writepages, 5074*38c8a9a5SSteve French .write_begin = cifs_write_begin, 5075*38c8a9a5SSteve French .write_end = cifs_write_end, 5076*38c8a9a5SSteve French .dirty_folio = cifs_dirty_folio, 5077*38c8a9a5SSteve French .release_folio = cifs_release_folio, 5078*38c8a9a5SSteve French .invalidate_folio = cifs_invalidate_folio, 5079*38c8a9a5SSteve French .launder_folio = cifs_launder_folio, 5080*38c8a9a5SSteve French .migrate_folio = filemap_migrate_folio, 5081*38c8a9a5SSteve French }; 5082*38c8a9a5SSteve French 5083*38c8a9a5SSteve French /* 5084*38c8a9a5SSteve French * Splice data from a file into a pipe. 5085*38c8a9a5SSteve French */ 5086*38c8a9a5SSteve French ssize_t cifs_splice_read(struct file *in, loff_t *ppos, 5087*38c8a9a5SSteve French struct pipe_inode_info *pipe, size_t len, 5088*38c8a9a5SSteve French unsigned int flags) 5089*38c8a9a5SSteve French { 5090*38c8a9a5SSteve French if (unlikely(*ppos >= file_inode(in)->i_sb->s_maxbytes)) 5091*38c8a9a5SSteve French return 0; 5092*38c8a9a5SSteve French if (unlikely(!len)) 5093*38c8a9a5SSteve French return 0; 5094*38c8a9a5SSteve French if (in->f_flags & O_DIRECT) 5095*38c8a9a5SSteve French return direct_splice_read(in, ppos, pipe, len, flags); 5096*38c8a9a5SSteve French return filemap_splice_read(in, ppos, pipe, len, flags); 5097*38c8a9a5SSteve French } 5098