Lines Matching defs:inode
114 int cifs_posix_open(char *full_path, struct inode **pinode,
158 /* get new inode and set it up */
177 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
249 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
252 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
297 struct inode *inode = d_inode(dentry);
298 struct cifsInodeInfo *cinode = CIFS_I(inode);
330 cifs_sb_active(inode->i_sb);
366 cifs_zap_mapping(inode);
383 struct inode *inode = d_inode(cifs_file->dentry);
384 struct cifsInodeInfo *cifsi = CIFS_I(inode);
386 struct super_block *sb = inode->i_sb;
442 struct inode *inode = d_inode(cifs_file->dentry);
445 struct cifsInodeInfo *cifsi = CIFS_I(inode);
446 struct super_block *sb = inode->i_sb;
464 server->ops->get_lease_key(inode, &fid);
475 cifs_dbg(FYI, "closing last open instance for inode %p\n",
516 int cifs_open(struct inode *inode, struct file *file)
534 cifs_sb = CIFS_SB(inode->i_sb);
549 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
550 inode, file->f_flags, full_path);
568 /* can not refresh inode info since size could be stale */
569 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
591 server->ops->get_lease_key(inode, &fid);
597 server->ops->get_lease_key(inode, &fid);
599 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
616 cifs_fscache_set_inode_cookie(inode, file);
624 .mode = inode->i_mode,
685 struct inode *inode;
701 inode = d_inode(cfile->dentry);
702 cifs_sb = CIFS_SB(inode->i_sb);
720 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
721 inode, cfile->f_flags, full_path);
738 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
762 server->ops->get_lease_key(inode, &cfile->fid);
774 * Can not refresh inode by passing in file_info buf to be returned by
777 * version of file size can be stale. If we knew for sure that inode was
798 cinode = CIFS_I(inode);
801 rc = filemap_write_and_wait(inode->i_mapping);
803 mapping_set_error(inode->i_mapping, rc);
806 rc = smb311_posix_get_inode_info(&inode, full_path, inode->i_sb, xid);
808 rc = cifs_get_inode_info_unix(&inode, full_path,
809 inode->i_sb, xid);
811 rc = cifs_get_inode_info(&inode, full_path, NULL,
812 inode->i_sb, xid, NULL);
818 * to the server to get the new inode info.
840 int cifs_close(struct inode *inode, struct file *file)
887 int cifs_closedir(struct inode *inode, struct file *file)
896 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
1273 struct inode *inode = d_inode(cfile->dentry);
1276 struct file_lock_context *flctx = inode->i_flctx;
1299 * protects locking operations of this inode.
1643 struct inode *inode = d_inode(cfile->dentry);
1690 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1691 CIFS_CACHE_READ(CIFS_I(inode))) {
1692 cifs_zap_mapping(inode);
1693 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1694 inode);
1695 CIFS_I(inode)->oplock = 0;
1832 * the inode->i_lock held
1975 * Having a null inode here (because mapping->host was set to zero by
1981 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
2143 struct inode *inode;
2149 inode = page->mapping->host;
2177 inode->i_atime = inode->i_mtime = current_time(inode);
2322 struct inode *inode = mapping->host;
2323 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2364 rc = cifs_get_writable_file(CIFS_I(inode), FIND_WR_ANY, &cfile);
2535 struct inode *inode = mapping->host;
2579 spin_lock(&inode->i_lock);
2580 if (pos > inode->i_size)
2581 i_size_write(inode, pos);
2582 spin_unlock(&inode->i_lock);
2599 struct inode *inode = file_inode(file);
2600 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2604 trace_cifs_fsync_err(inode->i_ino, rc);
2613 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2614 rc = cifs_zap_mapping(inode);
2630 smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
2652 struct inode *inode = file_inode(file);
2675 smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
2691 * As file closes, flush all cached write data for this inode checking
2696 struct inode *inode = file_inode(file);
2700 rc = filemap_write_and_wait(inode->i_mapping);
2702 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2704 trace_cifs_flush_err(inode->i_ino, rc);
2769 struct inode *inode = d_inode(wdata->cfile->dentry);
2770 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2772 spin_lock(&inode->i_lock);
2774 if (cifsi->server_eof > inode->i_size)
2775 i_size_write(inode, cifsi->server_eof);
2776 spin_unlock(&inode->i_lock);
3266 struct inode *inode = file->f_mapping->host;
3267 struct cifsInodeInfo *cinode = CIFS_I(inode);
3271 inode_lock(inode);
3290 inode_unlock(inode);
3300 struct inode *inode = file_inode(iocb->ki_filp);
3301 struct cifsInodeInfo *cinode = CIFS_I(inode);
3302 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3337 cifs_zap_mapping(inode);
3338 cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
3339 inode);
4005 struct inode *inode = file_inode(iocb->ki_filp);
4006 struct cifsInodeInfo *cinode = CIFS_I(inode);
4007 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
4016 * change - so we can't make a decision about inode invalidating.
4156 struct inode *inode = file_inode(file);
4160 if (!CIFS_CACHE_READ(CIFS_I(inode)))
4161 rc = cifs_zap_mapping(inode);
4630 refreshing the inode only on increases in the file size
4639 /* This inode is open for write at least once */
4776 struct inode *inode = d_inode(cfile->dentry);
4777 struct cifsInodeInfo *cinode = CIFS_I(inode);
4791 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
4792 inode);
4796 if (inode && S_ISREG(inode->i_mode)) {
4798 break_lease(inode, O_RDONLY);
4800 break_lease(inode, O_WRONLY);
4801 rc = filemap_fdatawrite(inode->i_mapping);
4803 rc = filemap_fdatawait(inode->i_mapping);
4804 mapping_set_error(inode->i_mapping, rc);
4805 cifs_zap_mapping(inode);
4807 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4855 struct inode *inode = swap_file->f_mapping->host;
4861 spin_lock(&inode->i_lock);
4862 blocks = inode->i_blocks;
4863 isize = inode->i_size;
4864 spin_unlock(&inode->i_lock);