Lines Matching defs:inode
43 static void cifs_undirty_folios(struct inode *inode, loff_t start, unsigned int len)
45 struct address_space *mapping = inode->i_mapping;
71 void cifs_pages_written_back(struct inode *inode, loff_t start, unsigned int len)
73 struct address_space *mapping = inode->i_mapping;
104 void cifs_pages_write_failed(struct inode *inode, loff_t start, unsigned int len)
106 struct address_space *mapping = inode->i_mapping;
137 void cifs_pages_write_redirty(struct inode *inode, loff_t start, unsigned int len)
139 struct address_space *mapping = inode->i_mapping;
278 int cifs_posix_open(const char *full_path, struct inode **pinode,
322 /* get new inode and set it up */
341 static int cifs_nt_open(const char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
408 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
411 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
454 struct inode *inode = d_inode(dentry);
455 struct cifsInodeInfo *cinode = CIFS_I(inode);
498 cifs_sb_active(inode->i_sb);
534 cifs_zap_mapping(inode);
551 struct inode *inode = d_inode(cifs_file->dentry);
552 struct cifsInodeInfo *cifsi = CIFS_I(inode);
554 struct super_block *sb = inode->i_sb;
616 struct inode *inode = d_inode(cifs_file->dentry);
619 struct cifsInodeInfo *cifsi = CIFS_I(inode);
620 struct super_block *sb = inode->i_sb;
638 server->ops->get_lease_key(inode, &fid);
649 cifs_dbg(FYI, "closing last open instance for inode %p\n",
690 int cifs_open(struct inode *inode, struct file *file)
710 cifs_sb = CIFS_SB(inode->i_sb);
731 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
732 inode, file->f_flags, full_path);
747 spin_lock(&CIFS_I(inode)->deferred_lock);
749 spin_unlock(&CIFS_I(inode)->deferred_lock);
765 /* can not refresh inode info since size could be stale */
766 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
789 server->ops->get_lease_key(inode, &fid);
795 server->ops->get_lease_key(inode, &fid);
797 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon, file->f_flags, &oplock, &fid,
821 .mode = inode->i_mode,
899 struct inode *inode;
915 inode = d_inode(cfile->dentry);
916 cifs_sb = CIFS_SB(inode->i_sb);
935 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
936 inode, cfile->f_flags, full_path);
954 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
979 server->ops->get_lease_key(inode, &cfile->fid);
993 * Can not refresh inode by passing in file_info buf to be returned by
996 * version of file size can be stale. If we knew for sure that inode was
1019 cinode = CIFS_I(inode);
1022 rc = filemap_write_and_wait(inode->i_mapping);
1024 mapping_set_error(inode->i_mapping, rc);
1027 rc = smb311_posix_get_inode_info(&inode, full_path, inode->i_sb, xid);
1029 rc = cifs_get_inode_info_unix(&inode, full_path,
1030 inode->i_sb, xid);
1032 rc = cifs_get_inode_info(&inode, full_path, NULL,
1033 inode->i_sb, xid, NULL);
1039 * to the server to get the new inode info.
1073 int cifs_close(struct inode *inode, struct file *file)
1076 struct cifsInodeInfo *cinode = CIFS_I(inode);
1077 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1080 cifs_fscache_unuse_inode_cookie(inode, file->f_mode & FMODE_WRITE);
1091 inode_set_mtime_to_ts(inode,
1092 inode_set_ctime_current(inode));
1157 int cifs_closedir(struct inode *inode, struct file *file)
1166 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
1546 struct inode *inode = d_inode(cfile->dentry);
1549 struct file_lock_context *flctx = locks_inode_context(inode);
1572 * protects locking operations of this inode.
1925 struct inode *inode = d_inode(cfile->dentry);
1973 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1974 CIFS_CACHE_READ(CIFS_I(inode))) {
1975 cifs_zap_mapping(inode);
1976 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1977 inode);
1978 CIFS_I(inode)->oplock = 0;
2116 * the inode->i_lock held
2216 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->netfs.inode.i_sb);
2261 * Having a null inode here (because mapping->host was set to zero by
2267 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
2272 cifs_sb = CIFS_SB(cifs_inode->netfs.inode.i_sb);
2442 struct inode *inode = d_inode(wdata->cfile->dentry);
2452 wsize = server->ops->wp_retry_size(inode);
2483 cifs_undirty_folios(inode, fpos, cur_len);
2485 rc = cifs_get_writable_file(CIFS_I(inode), FIND_WR_ANY,
2513 cifs_pages_write_failed(inode, fpos, rest_len);
2516 mapping_set_error(inode->i_mapping, rc);
2525 struct inode *inode = d_inode(wdata->cfile->dentry);
2528 spin_lock(&inode->i_lock);
2529 cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
2530 spin_unlock(&inode->i_lock);
2537 cifs_pages_write_redirty(inode, wdata->offset, wdata->bytes);
2539 cifs_pages_write_failed(inode, wdata->offset, wdata->bytes);
2541 cifs_pages_written_back(inode, wdata->offset, wdata->bytes);
2544 mapping_set_error(inode->i_mapping, wdata->result);
2569 struct inode *inode;
2575 inode = page->mapping->host;
2603 simple_inode_init_ts(inode);
2741 struct inode *inode = mapping->host;
2744 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2748 unsigned long long i_size = i_size_read(inode), max_len;
2764 rc = cifs_get_writable_file(CIFS_I(inode), FIND_WR_ANY, &cfile);
2844 cifs_pages_written_back(inode, start, len);
2861 cifs_pages_write_redirty(inode, start, len);
2863 cifs_pages_write_failed(inode, start, len);
2867 set_bit(CIFS_INO_MODIFIED_ATTR, &CIFS_I(inode)->flags);
3079 struct inode *inode = mapping->host;
3124 spin_lock(&inode->i_lock);
3125 if (pos > inode->i_size) {
3126 i_size_write(inode, pos);
3127 inode->i_blocks = (512 - 1 + pos) >> 9;
3129 spin_unlock(&inode->i_lock);
3135 set_bit(CIFS_INO_MODIFIED_ATTR, &CIFS_I(inode)->flags);
3148 struct inode *inode = file_inode(file);
3149 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3153 trace_cifs_fsync_err(inode->i_ino, rc);
3162 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
3163 rc = cifs_zap_mapping(inode);
3179 smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
3201 struct inode *inode = file_inode(file);
3224 smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
3240 * As file closes, flush all cached write data for this inode checking
3245 struct inode *inode = file_inode(file);
3249 rc = filemap_write_and_wait(inode->i_mapping);
3251 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
3255 trace_cifs_flush_err(inode->i_ino, rc);
3277 struct inode *inode = d_inode(wdata->cfile->dentry);
3278 struct cifsInodeInfo *cifsi = CIFS_I(inode);
3280 spin_lock(&inode->i_lock);
3282 if (cifsi->server_eof > inode->i_size)
3283 i_size_write(inode, cifsi->server_eof);
3284 spin_unlock(&inode->i_lock);
3739 struct inode *inode = file->f_mapping->host;
3740 struct cifsInodeInfo *cinode = CIFS_I(inode);
3744 inode_lock(inode);
3763 inode_unlock(inode);
3773 struct inode *inode = file_inode(iocb->ki_filp);
3774 struct cifsInodeInfo *cinode = CIFS_I(inode);
3775 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3810 cifs_zap_mapping(inode);
3811 cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
3812 inode);
4268 struct inode *inode = file_inode(iocb->ki_filp);
4269 struct cifsInodeInfo *cinode = CIFS_I(inode);
4270 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
4279 * change - so we can't make a decision about inode invalidating.
4430 struct inode *inode = file_inode(file);
4434 if (!CIFS_CACHE_READ(CIFS_I(inode)))
4435 rc = cifs_zap_mapping(inode);
4683 struct inode *inode = file_inode(file);
4689 rc = cifs_readpage_from_fscache(inode, page);
4704 atime = inode_set_atime_to_ts(inode, current_time(inode));
4705 mtime = inode_get_mtime(inode);
4707 inode_set_atime_to_ts(inode, inode_get_mtime(inode));
4766 refreshing the inode only on increases in the file size
4777 /* This inode is open for write at least once */
4780 cifs_sb = CIFS_SB(cifsInode->netfs.inode.i_sb);
4787 if (i_size_read(&cifsInode->netfs.inode) < end_of_file)
4916 struct inode *inode = d_inode(cfile->dentry);
4917 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
4918 struct cifsInodeInfo *cinode = CIFS_I(inode);
4941 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
4942 inode);
4946 if (inode && S_ISREG(inode->i_mode)) {
4948 break_lease(inode, O_RDONLY);
4950 break_lease(inode, O_WRONLY);
4951 rc = filemap_fdatawrite(inode->i_mapping);
4953 rc = filemap_fdatawait(inode->i_mapping);
4954 mapping_set_error(inode->i_mapping, rc);
4955 cifs_zap_mapping(inode);
4957 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
5024 struct inode *inode = swap_file->f_mapping->host;
5034 spin_lock(&inode->i_lock);
5035 blocks = inode->i_blocks;
5036 isize = inode->i_size;
5037 spin_unlock(&inode->i_lock);