26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
34 #include <linux/slab.h>
36 #include <asm/div64.h>
46 static inline int cifs_convert_flags(
unsigned int flags)
50 else if ((flags & O_ACCMODE) ==
O_WRONLY)
52 else if ((flags & O_ACCMODE) ==
O_RDWR) {
64 static u32 cifs_posix_convert_flags(
unsigned int flags)
70 else if ((flags & O_ACCMODE) ==
O_WRONLY)
72 else if ((flags & O_ACCMODE) ==
O_RDWR)
94 static inline int cifs_get_disposition(
unsigned int flags)
96 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
98 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
100 else if ((flags & O_CREAT) == O_CREAT)
102 else if ((flags & O_TRUNC) == O_TRUNC)
113 FILE_UNIX_BASIC_INFO *presp_data;
114 __u32 posix_flags = 0;
120 cFYI(1,
"posix open %s", full_path);
122 presp_data = kzalloc(
sizeof(FILE_UNIX_BASIC_INFO),
GFP_KERNEL);
123 if (presp_data ==
NULL)
132 tcon = tlink_tcon(tlink);
135 posix_flags = cifs_posix_convert_flags(f_flags);
136 rc =
CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
154 if (*pinode ==
NULL) {
182 if (!server->
ops->open)
185 desired_access = cifs_convert_flags(f_flags);
211 disposition = cifs_get_disposition(f_flags);
222 rc = server->
ops->open(xid, tcon, full_path, disposition,
223 desired_access, create_options, fid, oplock, buf,
246 struct inode *inode = dentry->
d_inode;
250 struct cifs_tcon *tcon = tlink_tcon(tlink);
262 INIT_LIST_HEAD(&fdlocks->
locks);
263 fdlocks->
cfile = cfile;
264 cfile->
llist = fdlocks;
272 cfile->
dentry = dget(dentry);
275 cfile->
tlink = cifs_get_tlink(tlink);
284 tlink_tcon(tlink)->ses->server->ops->set_fid(cfile, fid, oplock);
302 cifsFileInfo_get_locked(cifs_file);
314 struct inode *inode = cifs_file->
dentry->d_inode;
324 if (--cifs_file->
count > 0) {
329 if (server->
ops->get_lease_key)
330 server->
ops->get_lease_key(inode, &fid);
340 cFYI(1,
"closing last open instance for inode %p",
341 cifs_file->
dentry->d_inode);
348 CIFS_I(inode)->invalid_mapping =
true;
360 if (server->
ops->close)
361 server->
ops->close(xid, tcon, &cifs_file->
fid);
397 char *full_path =
NULL;
398 bool posix_open_ok =
false;
404 cifs_sb = CIFS_SB(inode->
i_sb);
408 return PTR_ERR(tlink);
410 tcon = tlink_tcon(tlink);
411 server = tcon->
ses->server;
414 if (full_path ==
NULL) {
419 cFYI(1,
"inode = 0x%p file flags are 0x%x for %s",
420 inode, file->
f_flags, full_path);
435 cFYI(1,
"posix open succeeded");
436 posix_open_ok =
true;
438 if (tcon->
ses->serverNOS)
439 cERROR(1,
"server %s of type %s returned"
440 " unexpected error on SMB posix open"
441 ", disabling posix open support."
442 " Check if server update available.",
443 tcon->
ses->serverName,
444 tcon->
ses->serverNOS);
446 }
else if ((rc != -
EIO) && (rc != -
EREMOTE) &&
455 if (server->
ops->get_lease_key)
456 server->
ops->get_lease_key(inode, &fid);
460 if (!posix_open_ok) {
461 if (server->
ops->get_lease_key)
462 server->
ops->get_lease_key(inode, &fid);
464 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
465 file->
f_flags, &oplock, &fid, xid);
474 if (server->
ops->close)
475 server->
ops->close(xid, tcon, &fid);
512 static int cifs_relock_file(
struct cifsFileInfo *cifsFile)
522 cifs_reopen_file(
struct cifsFileInfo *cfile,
bool can_flush)
532 char *full_path =
NULL;
547 inode = cfile->
dentry->d_inode;
548 cifs_sb = CIFS_SB(inode->
i_sb);
549 tcon = tlink_tcon(cfile->
tlink);
550 server = tcon->
ses->server;
559 if (full_path ==
NULL) {
566 cFYI(1,
"inode = 0x%p file flags 0x%x for %s", inode, cfile->
f_flags,
569 if (tcon->
ses->server->oplocks)
581 unsigned int oflags = cfile->
f_flags &
586 oflags, &oplock, &fid.
netfid, xid);
588 cFYI(1,
"posix reopen succeeded");
597 desired_access = cifs_convert_flags(cfile->
f_flags);
602 if (server->
ops->get_lease_key)
603 server->
ops->get_lease_key(inode, &fid);
612 rc = server->
ops->open(xid, tcon, full_path, disposition,
613 desired_access, create_options, &fid, &oplock,
617 cFYI(1,
"cifs_reopen returned 0x%x", rc);
618 cFYI(1,
"oplock: %d", oplock);
619 goto reopen_error_exit;
625 cinode = CIFS_I(inode);
645 server->
ops->set_fid(cfile, &fid, oplock);
646 cifs_relock_file(cfile);
674 cFYI(1,
"Closedir inode = 0x%p", inode);
680 tcon = tlink_tcon(cfile->
tlink);
681 server = tcon->
ses->server;
683 cFYI(1,
"Freeing private data in close dir");
688 if (server->
ops->close_dir)
689 rc = server->
ops->close_dir(xid, tcon, &cfile->
fid);
692 cFYI(1,
"Closing uncompleted readdir with rc %d", rc);
698 buf = cfile->
srch_inf.ntwrk_buf_start;
700 cFYI(1,
"closedir free smb buf in srch struct");
727 INIT_LIST_HEAD(&lock->
blist);
737 list_del_init(&li->
blist);
752 if (offset + length <= li->offset ||
755 if (rw_check && server->
ops->compare_fids(cfile, cur_cfile) &&
758 if ((type & server->
vals->shared_lock_type) &&
759 ((server->
ops->compare_fids(cfile, cur_cfile) &&
779 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
780 cfile, conf_lock, rw_check);
813 if (conf_lock->
type & server->
vals->shared_lock_type)
855 lock->
type, &conf_lock,
false);
875 list_del_init(&lock->
blist);
894 unsigned char saved_type = flock->
fl_type;
918 cifs_posix_lock_set(
struct file *file,
struct file_lock *flock)
948 int rc = 0, stored_rc;
952 unsigned int num, max_num, max_buf;
953 LOCKING_ANDX_RANGE *
buf, *
cur;
959 tcon = tlink_tcon(cfile->
tlink);
973 max_buf = tcon->
ses->server->maxBuf;
980 max_num = (max_buf -
sizeof(
struct smb_hdr)) /
981 sizeof(LOCKING_ANDX_RANGE);
982 buf = kzalloc(max_num *
sizeof(LOCKING_ANDX_RANGE),
GFP_KERNEL);
989 for (i = 0; i < 2; i++) {
993 if (li->
type != types[i])
1000 if (++num == max_num) {
1015 (
__u8)types[i], 0, num, buf);
1030 #define cifs_for_each_lock(inode, lockp) \
1031 for (lockp = &inode->i_flock; *lockp != NULL; \
1032 lockp = &(*lockp)->fl_next)
1049 unsigned int count = 0,
i = 0;
1067 if ((*before)->fl_flags &
FL_POSIX)
1072 INIT_LIST_HEAD(&locks_to_send);
1088 el = locks_to_send.
next;
1094 if (el == &locks_to_send) {
1099 cERROR(1,
"Can't push all brlocks!");
1149 if (cap_unix(tcon->
ses) &&
1152 return cifs_push_posix_locks(cfile);
1154 return tcon->
ses->server->ops->push_mand_locks(cfile);
1158 cifs_read_flock(
struct file_lock *flock,
__u32 *type,
int *lock,
int *unlock,
1166 cFYI(1,
"Blocking lock");
1170 cFYI(1,
"Process suspended by mandatory locking - "
1171 "not implemented yet");
1173 cFYI(1,
"Lease on file - not implemented yet");
1179 *type = server->
vals->large_lock_type;
1181 cFYI(1,
"F_WRLCK ");
1182 *type |= server->
vals->exclusive_lock_type;
1186 *type |= server->
vals->unlock_lock_type;
1191 *type |= server->
vals->shared_lock_type;
1195 *type |= server->
vals->exclusive_lock_type;
1199 *type |= server->
vals->shared_lock_type;
1202 cFYI(1,
"Unknown type of lock");
1206 cifs_getlk(
struct file *file,
struct file_lock *flock,
__u32 type,
1207 bool wait_flag,
bool posix_lck,
unsigned int xid)
1217 int posix_lock_type;
1219 rc = cifs_posix_lock_test(file, flock);
1223 if (type & server->
vals->shared_lock_type)
1229 posix_lock_type, wait_flag);
1233 rc = cifs_lock_test(cfile, flock->
fl_start, length, type, flock);
1238 rc = server->
ops->mand_lock(xid, cfile, flock->
fl_start, length, type,
1241 rc = server->
ops->mand_lock(xid, cfile, flock->
fl_start, length,
1245 cERROR(1,
"Error unlocking previously locked "
1246 "range %d during test of lock", rc);
1250 if (type & server->
vals->shared_lock_type) {
1255 type &= ~server->
vals->exclusive_lock_type;
1257 rc = server->
ops->mand_lock(xid, cfile, flock->
fl_start, length,
1258 type | server->
vals->shared_lock_type,
1261 rc = server->
ops->mand_lock(xid, cfile, flock->
fl_start, length,
1262 type | server->
vals->shared_lock_type, 0, 1,
false);
1265 cERROR(1,
"Error unlocking previously locked "
1266 "range %d during test of lock", rc);
1278 list_move(li, dest);
1296 int rc = 0, stored_rc;
1300 unsigned int max_num,
num, max_buf;
1301 LOCKING_ANDX_RANGE *
buf, *
cur;
1308 INIT_LIST_HEAD(&tmp_llist);
1314 max_buf = tcon->
ses->server->maxBuf;
1318 max_num = (max_buf -
sizeof(
struct smb_hdr)) /
1319 sizeof(LOCKING_ANDX_RANGE);
1320 buf = kzalloc(max_num *
sizeof(LOCKING_ANDX_RANGE),
GFP_KERNEL);
1325 for (i = 0; i < 2; i++) {
1335 if (types[i] != li->
type)
1357 list_move(&li->
llist, &tmp_llist);
1358 if (++num == max_num) {
1361 li->
type, num, 0, buf);
1369 &cfile->
llist->locks);
1384 types[i], num, 0, buf);
1387 &cfile->
llist->locks);
1400 cifs_setlk(
struct file *file,
struct file_lock *flock,
__u32 type,
1401 bool wait_flag,
bool posix_lck,
int lock,
int unlock,
1411 int posix_lock_type;
1413 rc = cifs_posix_lock_set(file, flock);
1417 if (type & server->
vals->shared_lock_type)
1427 NULL, posix_lock_type, wait_flag);
1434 lock = cifs_lock_init(flock->
fl_start, length, type);
1438 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1444 rc = server->
ops->mand_lock(xid, cfile, flock->
fl_start, length,
1445 type, 1, 0, wait_flag);
1451 cifs_lock_add(cfile, lock);
1453 rc = server->
ops->mand_unlock_range(cfile, flock, xid);
1464 int lock = 0, unlock = 0;
1465 bool wait_flag =
false;
1466 bool posix_lck =
false;
1477 cFYI(1,
"Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1482 tcon = tlink_tcon(cfile->
tlink);
1484 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1487 cifs_sb = CIFS_SB(file->
f_path.dentry->d_sb);
1488 netfid = cfile->
fid.netfid;
1489 cinode = CIFS_I(file->
f_path.dentry->d_inode);
1491 if (cap_unix(tcon->
ses) &&
1500 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1505 if (!lock && !unlock) {
1514 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1526 unsigned int bytes_written)
1528 loff_t end_of_write = offset + bytes_written;
1539 unsigned int bytes_written = 0;
1540 unsigned int total_written;
1549 cifs_sb = CIFS_SB(dentry->
d_sb);
1551 cFYI(1,
"write %zd bytes to offset %lld of %s", write_size,
1552 *offset, dentry->
d_name.name);
1554 tcon = tlink_tcon(open_file->
tlink);
1555 server = tcon->
ses->server;
1557 if (!server->
ops->sync_write)
1562 for (total_written = 0; write_size > total_written;
1563 total_written += bytes_written) {
1574 rc = cifs_reopen_file(open_file,
false);
1579 len =
min((
size_t)cifs_sb->wsize,
1580 write_size - total_written);
1582 iov[1].iov_base = (
char *)write_data + total_written;
1583 iov[1].iov_len = len;
1585 io_parms.tcon = tcon;
1586 io_parms.offset = *
offset;
1587 io_parms.length = len;
1588 rc = server->
ops->sync_write(xid, open_file, &io_parms,
1589 &bytes_written, iov, 1);
1591 if (rc || (bytes_written == 0)) {
1599 spin_lock(&dentry->
d_inode->i_lock);
1601 spin_unlock(&dentry->
d_inode->i_lock);
1602 *offset += bytes_written;
1608 if (total_written > 0) {
1609 spin_lock(&dentry->
d_inode->i_lock);
1610 if (*offset > dentry->
d_inode->i_size)
1611 i_size_write(dentry->
d_inode, *offset);
1612 spin_unlock(&dentry->
d_inode->i_lock);
1614 mark_inode_dirty_sync(dentry->
d_inode);
1616 return total_written;
1640 cifsFileInfo_get_locked(open_file);
1658 bool any_available =
false;
1660 unsigned int refind = 0;
1666 if (cifs_inode ==
NULL) {
1667 cERROR(1,
"Null inode passed to cifs_writeable_file");
1672 cifs_sb = CIFS_SB(cifs_inode->
vfs_inode.i_sb);
1685 if (!any_available && open_file->
pid !=
current->tgid)
1692 cifsFileInfo_get_locked(open_file);
1702 if (!any_available) {
1703 any_available =
true;
1704 goto refind_writable;
1708 any_available =
false;
1709 cifsFileInfo_get_locked(inv_file);
1715 rc = cifs_reopen_file(inv_file,
false);
1720 list_move_tail(&inv_file->
flist,
1726 goto refind_writable;
1733 static int cifs_partialpagewrite(
struct page *
page,
unsigned from,
unsigned to)
1739 int bytes_written = 0;
1740 struct inode *inode;
1743 if (!mapping || !mapping->
host)
1748 offset += (loff_t)from;
1749 write_data =
kmap(page);
1758 if (offset > mapping->
host->i_size) {
1764 if (mapping->
host->i_size - offset < (loff_t)to)
1765 to = (unsigned)(mapping->
host->i_size - offset);
1769 bytes_written = cifs_write(open_file, open_file->
pid,
1770 write_data, to - from, &offset);
1774 if ((bytes_written > 0) && (offset))
1776 else if (bytes_written < 0)
1779 cFYI(1,
"No writeable filehandles for inode");
1791 bool done =
false, scanned =
false, range_whole =
false;
1816 while (!done && index <= end) {
1817 unsigned int i, nr_pages, found_pages;
1819 struct page **
pages;
1838 pages = wdata->
pages;
1843 found_pages += nr_pages;
1846 }
while (nr_pages && tofind && index <= end);
1848 if (found_pages == 0) {
1854 for (i = 0; i < found_pages; i++) {
1866 else if (!trylock_page(page))
1880 if (next && (page->
index != next)) {
1887 wait_on_page_writeback(page);
1889 if (PageWriteback(page) ||
1899 set_page_writeback(page);
1909 next = page->
index + 1;
1915 index = wdata->
pages[0]->index + 1;
1918 for (i = nr_pages; i < found_pages; i++) {
1924 if (nr_pages == 0) {
1934 min(i_size_read(mapping->
host) -
1945 if (!wdata->
cfile) {
1946 cERROR(1,
"No writable handles for inode");
1951 server = tlink_tcon(wdata->
cfile->tlink)->ses->server;
1952 rc = server->
ops->async_writev(wdata);
1955 for (i = 0; i < nr_pages; ++
i)
1960 for (i = 0; i < nr_pages; ++
i) {
1965 SetPageError(wdata->
pages[i]);
1970 mapping_set_error(mapping, rc);
1981 if (!scanned && !done) {
2006 if (!PageUptodate(page))
2007 cFYI(1,
"ppw - page not up to date");
2019 set_page_writeback(page);
2029 SetPageUptodate(page);
2038 int rc = cifs_writepage_locked(page, wbc);
2043 static int cifs_write_end(
struct file *file,
struct address_space *mapping,
2044 loff_t
pos,
unsigned len,
unsigned copied,
2045 struct page *page,
void *fsdata)
2048 struct inode *inode = mapping->
host;
2058 cFYI(1,
"write_end for page %p from pos %lld with %d bytes",
2061 if (PageChecked(page)) {
2063 SetPageUptodate(page);
2064 ClearPageChecked(page);
2066 SetPageUptodate(page);
2068 if (!PageUptodate(page)) {
2079 page_data =
kmap(page);
2080 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2092 spin_lock(&inode->
i_lock);
2094 i_size_write(inode, pos);
2095 spin_unlock(&inode->
i_lock);
2112 struct inode *inode = file->
f_path.dentry->d_inode;
2122 cFYI(1,
"Sync file - name: %s datasync: 0x%x",
2123 file->
f_path.dentry->d_name.name, datasync);
2125 if (!CIFS_I(inode)->clientCanCacheRead) {
2128 cFYI(1,
"rc: %d during invalidate phase", rc);
2133 tcon = tlink_tcon(smbfile->
tlink);
2135 server = tcon->
ses->server;
2136 if (server->
ops->flush)
2137 rc = server->
ops->flush(xid, tcon, &smbfile->
fid);
2155 struct inode *inode = file->
f_mapping->host;
2164 cFYI(1,
"Sync file - name: %s datasync: 0x%x",
2165 file->
f_path.dentry->d_name.name, datasync);
2167 tcon = tlink_tcon(smbfile->
tlink);
2169 server = tcon->
ses->server;
2170 if (server->
ops->flush)
2171 rc = server->
ops->flush(xid, tcon, &smbfile->
fid);
2187 struct inode *inode = file->
f_path.dentry->d_inode;
2193 cFYI(1,
"Flush inode %p file %p rc %d", inode, file, rc);
2199 cifs_write_allocate_pages(
struct page **pages,
unsigned long num_pages)
2225 size_t get_numpages(
const size_t wsize,
const size_t len,
size_t *cur_len)
2230 clen =
min_t(
const size_t, len, wsize);
2245 struct inode *inode = wdata->
cfile->dentry->d_inode;
2248 spin_lock(&inode->
i_lock);
2252 spin_unlock(&inode->
i_lock);
2257 for (i = 0; i < wdata->
nr_pages; i++)
2271 server = tlink_tcon(wdata->
cfile->tlink)->ses->server;
2274 if (wdata->
cfile->invalidHandle) {
2275 rc = cifs_reopen_file(wdata->
cfile,
false);
2279 rc = server->
ops->async_writev(wdata);
2286 cifs_iovec_write(
struct file *file,
const struct iovec *
iov,
2287 unsigned long nr_segs, loff_t *poffset)
2289 unsigned long nr_pages,
i;
2290 size_t copied, len, cur_len;
2302 len = iov_length(iov, nr_segs);
2310 INIT_LIST_HEAD(&wdata_list);
2311 cifs_sb = CIFS_SB(file->
f_path.dentry->d_sb);
2313 tcon = tlink_tcon(open_file->
tlink);
2315 if (!tcon->
ses->server->ops->async_writev)
2321 pid = open_file->
pid;
2325 iov_iter_init(&it, iov, nr_segs, len, 0);
2329 nr_pages = get_numpages(cifs_sb->
wsize, len, &cur_len);
2331 cifs_uncached_writev_complete);
2337 rc = cifs_write_allocate_pages(wdata->
pages, nr_pages);
2344 for (i = 0; i < nr_pages; i++) {
2351 cur_len = save_len - cur_len;
2358 wdata->
bytes = cur_len;
2361 rc = cifs_uncached_retry_writev(wdata);
2378 if (!list_empty(&wdata_list))
2396 total_written += wdata->
bytes;
2400 rc = cifs_uncached_retry_writev(wdata);
2404 list_del_init(&wdata->
list);
2408 if (total_written > 0)
2409 *poffset += total_written;
2412 return total_written ? total_written : (
ssize_t)rc;
2416 unsigned long nr_segs, loff_t pos)
2419 struct inode *
inode;
2421 inode = iocb->
ki_filp->f_path.dentry->d_inode;
2429 written = cifs_iovec_write(iocb->
ki_filp, iov, nr_segs, &pos);
2431 CIFS_I(inode)->invalid_mapping =
true;
2440 unsigned long nr_segs, loff_t pos)
2442 struct file *file = iocb->
ki_filp;
2444 struct inode *inode = file->
f_mapping->host;
2451 sb_start_write(inode->
i_sb);
2459 server->
vals->exclusive_lock_type,
NULL,
2471 if (err < 0 && rc > 0)
2476 sb_end_write(inode->
i_sb);
2482 unsigned long nr_segs, loff_t pos)
2484 struct inode *inode = iocb->
ki_filp->f_path.dentry->d_inode;
2491 #ifdef CONFIG_CIFS_SMB2
2520 if (cap_unix(tcon->
ses) &&
2525 return cifs_writev(iocb, iov, nr_segs, pos);
2533 rdata = kzalloc(
sizeof(*rdata) + (
sizeof(
struct page *) * nr_pages),
2535 if (rdata !=
NULL) {
2537 INIT_LIST_HEAD(&rdata->
list);
2538 init_completion(&rdata->
done);
2558 cifs_read_allocate_pages(
struct cifs_readdata *rdata,
unsigned int nr_pages)
2564 for (i = 0; i < nr_pages; i++) {
2574 for (i = 0; i < nr_pages; i++) {
2589 for (i = 0; i < rdata->
nr_pages; i++) {
2602 server = tlink_tcon(rdata->
cfile->tlink)->ses->server;
2605 if (rdata->
cfile->invalidHandle) {
2606 rc = cifs_reopen_file(rdata->
cfile,
true);
2610 rc = server->
ops->async_readv(rdata);
2630 unsigned long nr_segs, loff_t offset,
ssize_t *copied)
2636 unsigned char *
pdata;
2640 iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2644 for (i = 0; i < rdata->
nr_pages; i++) {
2646 struct page *page = rdata->
pages[
i];
2672 cifs_uncached_readv_complete(
struct work_struct *work)
2678 kref_put(&rdata->
refcount, cifs_uncached_readdata_release);
2685 int total_read = 0,
result = 0;
2687 unsigned int nr_pages = rdata->
nr_pages;
2691 for (i = 0; i < nr_pages; i++) {
2692 struct page *page = rdata->
pages[
i];
2698 cFYI(1,
"%u: iov_base=%p iov_len=%zu",
2701 }
else if (len > 0) {
2705 cFYI(1,
"%u: iov_base=%p iov_len=%zu",
2726 return total_read > 0 ? total_read :
result;
2730 cifs_iovec_read(
struct file *file,
const struct iovec *iov,
2731 unsigned long nr_segs, loff_t *poffset)
2734 size_t len, cur_len;
2736 loff_t offset = *poffset;
2737 unsigned int npages;
2748 len = iov_length(iov, nr_segs);
2752 INIT_LIST_HEAD(&rdata_list);
2753 cifs_sb = CIFS_SB(file->
f_path.dentry->d_sb);
2755 tcon = tlink_tcon(open_file->
tlink);
2757 if (!tcon->
ses->server->ops->async_readv)
2761 pid = open_file->
pid;
2766 cFYI(1,
"attempting read on write only file instance");
2769 cur_len =
min_t(
const size_t, len - total_read, cifs_sb->
rsize);
2773 rdata = cifs_readdata_alloc(npages,
2774 cifs_uncached_readv_complete);
2780 rc = cifs_read_allocate_pages(rdata, npages);
2787 rdata->
bytes = cur_len;
2792 rc = cifs_retry_async_readv(rdata);
2796 cifs_uncached_readdata_release);
2806 if (!list_empty(&rdata_list))
2822 rc = cifs_readdata_to_iov(rdata, iov,
2825 total_read += copied;
2830 rc = cifs_retry_async_readv(rdata);
2834 list_del_init(&rdata->
list);
2835 kref_put(&rdata->
refcount, cifs_uncached_readdata_release);
2839 *poffset += total_read;
2845 return total_read ? total_read :
rc;
2849 unsigned long nr_segs, loff_t pos)
2853 read = cifs_iovec_read(iocb->
ki_filp, iov, nr_segs, &pos);
2862 unsigned long nr_segs, loff_t pos)
2864 struct inode *inode = iocb->
ki_filp->f_path.dentry->d_inode;
2883 if (cap_unix(tcon->
ses) &&
2894 tcon->
ses->server->vals->shared_lock_type,
2902 cifs_read(
struct file *file,
char *read_data,
size_t read_size, loff_t *offset)
2905 unsigned int bytes_read = 0;
2906 unsigned int total_read;
2907 unsigned int current_read_size;
2920 cifs_sb = CIFS_SB(file->
f_path.dentry->d_sb);
2931 tcon = tlink_tcon(open_file->
tlink);
2932 server = tcon->
ses->server;
2934 if (!server->
ops->sync_read) {
2940 pid = open_file->
pid;
2945 cFYI(1,
"attempting read on write only file instance");
2947 for (total_read = 0, cur_offset = read_data; read_size > total_read;
2948 total_read += bytes_read, cur_offset += bytes_read) {
2949 current_read_size =
min_t(
uint, read_size - total_read, rsize);
2954 if ((tcon->
ses) && !(tcon->
ses->capabilities &
2955 tcon->
ses->server->vals->cap_large_files)) {
2956 current_read_size =
min_t(
uint, current_read_size,
2962 rc = cifs_reopen_file(open_file,
true);
2967 io_parms.tcon =
tcon;
2968 io_parms.offset = *
offset;
2969 io_parms.length = current_read_size;
2970 rc = server->
ops->sync_read(xid, open_file, &io_parms,
2971 &bytes_read, &cur_offset,
2974 if (rc || (bytes_read == 0)) {
2983 *offset += bytes_read;
2995 cifs_page_mkwrite(
struct vm_area_struct *vma,
struct vm_fault *vmf)
2997 struct page *page = vmf->page;
3000 return VM_FAULT_LOCKED;
3003 static struct vm_operations_struct cifs_file_vm_ops = {
3005 .page_mkwrite = cifs_page_mkwrite,
3012 struct inode *inode = file->
f_path.dentry->d_inode;
3016 if (!CIFS_I(inode)->clientCanCacheRead) {
3024 vma->
vm_ops = &cifs_file_vm_ops;
3036 cFYI(1,
"Validation prior to mmap failed, error=%d", rc);
3042 vma->
vm_ops = &cifs_file_vm_ops;
3054 for (i = 0; i < rdata->
nr_pages; i++) {
3055 struct page *page = rdata->
pages[
i];
3057 lru_cache_add_file(page);
3059 if (rdata->
result == 0) {
3061 SetPageUptodate(page);
3067 cifs_readpage_to_fscache(rdata->
mapping->host, page);
3079 int total_read = 0,
result = 0;
3083 unsigned int nr_pages = rdata->
nr_pages;
3087 eof = CIFS_I(rdata->
mapping->host)->server_eof;
3089 cFYI(1,
"eof=%llu eof_index=%lu", eof, eof_index);
3092 for (i = 0; i < nr_pages; i++) {
3093 struct page *page = rdata->
pages[
i];
3099 cFYI(1,
"%u: idx=%lu iov_base=%p iov_len=%zu",
3102 }
else if (len > 0) {
3106 cFYI(1,
"%u: idx=%lu iov_base=%p iov_len=%zu",
3112 }
else if (page->
index > eof_index) {
3122 lru_cache_add_file(page);
3124 SetPageUptodate(page);
3132 lru_cache_add_file(page);
3148 return total_read > 0 ? total_read :
result;
3151 static int cifs_readpages(
struct file *file,
struct address_space *mapping,
3152 struct list_head *page_list,
unsigned num_pages)
3158 unsigned int rsize = cifs_sb->
rsize;
3174 rc = cifs_readpages_from_fscache(mapping->
host, mapping, page_list,
3180 pid = open_file->
pid;
3185 INIT_LIST_HEAD(&tmplist);
3187 cFYI(1,
"%s: file=%p mapping=%p num_pages=%u", __func__, file,
3188 mapping, num_pages);
3201 while (!list_empty(page_list)) {
3204 unsigned int expected_index;
3205 unsigned int nr_pages = 1;
3207 struct page *
page, *tpage;
3217 __set_page_locked(page);
3223 __clear_page_locked(page);
3229 list_move_tail(&page->
lru, &tmplist);
3232 expected_index = page->
index + 1;
3235 if (page->
index != expected_index)
3242 __set_page_locked(page);
3245 __clear_page_locked(page);
3248 list_move_tail(&page->
lru, &tmplist);
3254 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3259 lru_cache_add_file(page);
3280 rc = cifs_retry_async_readv(rdata);
3282 for (i = 0; i < rdata->
nr_pages; i++) {
3284 lru_cache_add_file(page);
3298 static int cifs_readpage_worker(
struct file *file,
struct page *page,
3305 rc = cifs_readpage_from_fscache(file->
f_path.dentry->d_inode, page);
3310 read_data =
kmap(page);
3318 cFYI(1,
"Bytes read %d", rc);
3320 file->
f_path.dentry->d_inode->i_atime =
3327 SetPageUptodate(page);
3330 cifs_readpage_to_fscache(file->
f_path.dentry->d_inode, page);
3342 static int cifs_readpage(
struct file *file,
struct page *page)
3356 cFYI(1,
"readpage %p at offset %d 0x%x",
3357 page, (
int)offset, (
int)offset);
3359 rc = cifs_readpage_worker(file, page, &offset);
3367 static int is_inode_writable(
struct cifsInodeInfo *cifs_inode)
3393 if (is_inode_writable(cifsInode)) {
3397 cifs_sb = CIFS_SB(cifsInode->
vfs_inode.i_sb);
3404 if (i_size_read(&cifsInode->
vfs_inode) < end_of_file)
3412 static int cifs_write_begin(
struct file *file,
struct address_space *mapping,
3413 loff_t pos,
unsigned len,
unsigned flags,
3414 struct page **pagep,
void **fsdata)
3423 cFYI(1,
"write_begin from %lld len %d", (
long long)pos, len);
3431 if (PageUptodate(page))
3448 if (CIFS_I(mapping->
host)->clientCanCacheRead) {
3449 i_size = i_size_read(mapping->
host);
3450 if (page_start >= i_size ||
3451 (offset == 0 && (pos + len) >= i_size)) {
3452 zero_user_segments(page, 0, offset,
3461 SetPageChecked(page);
3472 cifs_readpage_worker(file, page, &page_start);
3484 static int cifs_release_page(
struct page *page,
gfp_t gfp)
3486 if (PagePrivate(page))
3492 static void cifs_invalidate_page(
struct page *page,
unsigned long offset)
3497 cifs_fscache_invalidate_page(page, &cifsi->
vfs_inode);
3500 static int cifs_launder_page(
struct page *page)
3512 cFYI(1,
"Launder page: %p", page);
3515 rc = cifs_writepage_locked(page, &wbc);
3517 cifs_fscache_invalidate_page(page, page->
mapping->host);
3525 struct inode *inode = cfile->
dentry->d_inode;
3538 mapping_set_error(inode->
i_mapping, rc);
3539 invalidate_remote_inode(inode);
3541 cFYI(1,
"Oplock flush inode %p rc %d", inode, rc);
3544 rc = cifs_push_locks(cfile);
3546 cERROR(1,
"Push locks rc = %d", rc);
3555 rc = tcon->
ses->server->ops->oplock_response(tcon, &cfile->
fid,
3557 cFYI(1,
"Oplock release rc = %d", rc);
3562 .readpage = cifs_readpage,
3563 .readpages = cifs_readpages,
3564 .writepage = cifs_writepage,
3565 .writepages = cifs_writepages,
3566 .write_begin = cifs_write_begin,
3567 .write_end = cifs_write_end,
3569 .releasepage = cifs_release_page,
3570 .invalidatepage = cifs_invalidate_page,
3571 .launder_page = cifs_launder_page,
3580 .readpage = cifs_readpage,
3581 .writepage = cifs_writepage,
3582 .writepages = cifs_writepages,
3583 .write_begin = cifs_write_begin,
3584 .write_end = cifs_write_end,
3586 .releasepage = cifs_release_page,
3587 .invalidatepage = cifs_invalidate_page,
3588 .launder_page = cifs_launder_page,