Lines Matching defs:server
69 * Completion of write to server.
102 * Failure of write to server.
167 * were closed when session to server was lost.
349 struct TCP_Server_Info *server = tcon->ses->server;
352 if (!server->ops->open)
402 rc = server->ops->open(xid, &oparms, oplock, buf);
415 server->ops->close(xid, tcon, fid);
459 struct TCP_Server_Info *server = tcon->ses->server;
501 * If the server returned a read oplock and we have mandatory brlocks,
504 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
519 server->ops->set_fid(cfile, fid, oplock);
601 * server. Must be called without holding tcon->open_file_lock,
618 struct TCP_Server_Info *server = tcon->ses->server;
637 if (server->ops->get_lease_key)
638 server->ops->get_lease_key(inode, &fid);
668 struct TCP_Server_Info *server = tcon->ses->server;
672 if (server->ops->close_getattr)
673 server->ops->close_getattr(xid, tcon, cifs_file);
674 else if (server->ops->close)
675 server->ops->close(xid, tcon, &cifs_file->fid);
697 struct TCP_Server_Info *server;
722 server = tcon->ses->server;
756 if (server->oplocks)
774 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",
788 if (server->ops->get_lease_key)
789 server->ops->get_lease_key(inode, &fid);
794 if (server->ops->get_lease_key)
795 server->ops->get_lease_key(inode, &fid);
807 if (server->ops->close)
808 server->ops->close(xid, tcon, &fid);
857 * to server was lost.
883 rc = tcon->ses->server->ops->push_mand_locks(cfile);
897 struct TCP_Server_Info *server;
918 server = tcon->ses->server;
923 * called and if the server was down that means we end up here, and we
938 if (tcon->ses->server->oplocks)
978 if (server->ops->get_lease_key)
979 server->ops->get_lease_key(inode, &cfile->fid);
995 * file might have write behind data that needs to be flushed and server
999 rc = server->ops->open(xid, &oparms, &oplock, NULL);
1002 rc = server->ops->open(xid, &oparms, &oplock, NULL);
1036 * Else we are writing out data to server already and could deadlock if
1038 * would invalidate the current end of file on the server we can not go
1039 * to the server to get the new inode info.
1043 * If the server returned a read oplock and we have mandatory brlocks,
1046 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
1051 server->ops->set_fid(cfile, &cfile->fid, oplock);
1163 struct TCP_Server_Info *server;
1173 server = tcon->ses->server;
1177 if (server->ops->dir_needs_close(cfile)) {
1180 if (server->ops->close_dir)
1181 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
1248 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1255 server->ops->compare_fids(cfile, cur_cfile)) {
1257 if (!(li->type & server->vals->shared_lock_type) ||
1261 if ((type & server->vals->shared_lock_type) &&
1262 ((server->ops->compare_fids(cfile, cur_cfile) &&
1267 server->ops->compare_fids(cfile, cur_cfile))
1301 * the server or 1 otherwise.
1310 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1322 if (conf_lock->type & server->vals->shared_lock_type)
1346 * 1) 0, if we set the lock and don't need to request to the server;
1347 * 2) 1, if no locks prevent us but we need to request to the server;
1398 * the server or 1 otherwise.
1425 * 2) 0, if we set the lock and don't need to request to the server;
1427 * 4) FILE_LOCK_DEFERRED + 1, if we need to request to the server.
1471 max_buf = tcon->ses->server->maxBuf;
1656 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1665 bool *wait_flag, struct TCP_Server_Info *server)
1684 *type = server->vals->large_lock_type;
1687 *type |= server->vals->exclusive_lock_type;
1691 *type |= server->vals->unlock_lock_type;
1696 *type |= server->vals->shared_lock_type;
1700 *type |= server->vals->exclusive_lock_type;
1704 *type |= server->vals->shared_lock_type;
1718 struct TCP_Server_Info *server = tcon->ses->server;
1729 if (type & server->vals->shared_lock_type)
1746 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1749 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1758 if (type & server->vals->shared_lock_type) {
1763 type &= ~server->vals->exclusive_lock_type;
1765 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1766 type | server->vals->shared_lock_type,
1769 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1770 type | server->vals->shared_lock_type, 0, 1, false);
1825 max_buf = tcon->ses->server->maxBuf;
1870 * the server.
1924 struct TCP_Server_Info *server = tcon->ses->server;
1935 if (type & server->vals->shared_lock_type)
1967 * Windows 7 server can delay breaking lease from read to None
1969 * before sending the lock to the server to be sure the next
1981 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1990 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1997 * unlocking failed as both cifs.ko and the SMB server
2033 tcon->ses->server);
2081 tcon->ses->server);
2136 struct TCP_Server_Info *server;
2146 server = tcon->ses->server;
2148 if (!server->ops->sync_write)
2164 server now */
2170 len = min(server->ops->wp_retry_size(d_inode(dentry)),
2179 rc = server->ops->sync_write(xid, &open_file->fid,
2443 struct TCP_Server_Info *server;
2447 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2452 wsize = server->ops->wp_retry_size(inode);
2494 rc = server->ops->async_writev(wdata2,
2742 struct TCP_Server_Info *server;
2762 server = cifs_pick_channel(cifs_sb_master_tcon(cifs_sb)->ses);
2770 rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->wsize,
2786 wdata->server = server;
2806 if (server->smbd_conn)
2807 max_pages = server->smbd_conn->max_frmr_depth;
2829 rc = adjust_credits(wdata->server, &wdata->credits, wdata->bytes);
2836 rc = wdata->server->ops->async_writev(wdata,
2851 add_credits_and_wake_if(server, credits, 0);
2872 * write a region of pages back to the server
2968 * Write a region of pages back to the server
2989 * Write some of the pending data back to the server
3146 struct TCP_Server_Info *server;
3172 server = tcon->ses->server;
3173 if (server->ops->flush == NULL) {
3181 rc = server->ops->flush(xid, tcon, &smbfile->fid);
3186 rc = server->ops->flush(xid, tcon, &smbfile->fid);
3199 struct TCP_Server_Info *server;
3217 server = tcon->ses->server;
3218 if (server->ops->flush == NULL) {
3226 rc = server->ops->flush(xid, tcon, &smbfile->fid);
3231 rc = server->ops->flush(xid, tcon, &smbfile->fid);
3299 struct TCP_Server_Info *server = wdata->server;
3317 rc = server->ops->wait_mtu_credits(server, wdata->bytes,
3323 add_credits_and_wake_if(server, &credits, 0);
3329 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
3342 rc = server->ops->async_writev(wdata,
3354 add_credits_and_wake_if(server, &wdata->credits, 0);
3412 struct TCP_Server_Info *server;
3420 server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
3424 if (server->smbd_conn)
3425 max_segs = server->smbd_conn->max_frmr_depth;
3446 rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->wsize,
3454 add_credits_and_wake_if(server, credits, 0);
3463 add_credits_and_wake_if(server, credits, 0);
3470 add_credits_and_wake_if(server, credits, 0);
3477 wdata->server = server;
3487 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
3493 rc = server->ops->async_writev(wdata,
3498 add_credits_and_wake_if(server, &wdata->credits, 0);
3617 if (!tcon->ses->server->ops->async_writev)
3741 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
3756 server->vals->exclusive_lock_type, 0,
3797 * to the server exactly from the pos to pos+len-1 rather than flush all
3805 * request to the server thus making data in the cache stale.
3808 * operations will read new data from the server.
3876 struct TCP_Server_Info *server;
3879 server = rdata->server;
3896 rc = server->ops->wait_mtu_credits(server, rdata->bytes,
3903 add_credits_and_wake_if(server, &credits, 0);
3909 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3921 rc = server->ops->async_readv(rdata);
3933 add_credits_and_wake_if(server, &rdata->credits, 0);
3953 struct TCP_Server_Info *server;
3955 server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
3958 if (server->smbd_conn)
3959 max_segs = server->smbd_conn->max_frmr_depth;
3978 server->ops->negotiate_rsize(tlink_tcon(open_file->tlink),
3981 rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
3994 add_credits_and_wake_if(server, credits, 0);
4000 add_credits_and_wake_if(server, credits, 0);
4005 rdata->server = server;
4017 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4023 rc = server->ops->async_readv(rdata);
4027 add_credits_and_wake_if(server, &rdata->credits, 0);
4146 if (!tcon->ses->server->ops->async_readv)
4277 * In strict cache mode we need to read from the server all the time
4278 * if we don't have level II oplock because the server can delay mtime
4298 tcon->ses->server->vals->shared_lock_type,
4315 struct TCP_Server_Info *server;
4336 server = cifs_pick_channel(tcon->ses);
4338 if (!server->ops->sync_read) {
4362 tcon->ses->server->vals->cap_large_files)) {
4375 io_parms.server = server;
4376 rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
4515 struct TCP_Server_Info *server;
4538 server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
4606 server->ops->negotiate_rsize(tlink_tcon(open_file->tlink),
4609 rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
4624 add_credits_and_wake_if(server, credits, 0);
4631 add_credits_and_wake_if(server, credits, 0);
4638 rdata->server = server;
4653 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4658 rc = server->ops->async_readv(rdata);
4662 add_credits_and_wake_if(server, &rdata->credits, 0);
4763 /* We do not want to update the file size from server for inodes
4821 * the server. If the write is short, we'll end up doing a sync write
4920 struct TCP_Server_Info *server;
4934 server = tcon->ses->server;
4936 server->ops->downgrade_oplock(server, cinode, cfile->oplock_level,
4990 rc = server->ops->oplock_response(tcon, persistent_fid,
5115 * cifs_readahead requires the server to support a buffer large enough to