4 * Copyright (C) International Business Machines Corp., 2002,2010
5 * Author(s): Steve French (sfrench@us.ibm.com)
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/stat.h>
23 #include <linux/slab.h>
24 #include <linux/pagemap.h>
25 #include <asm/div64.h>
29 #include "cifsproto.h"
30 #include "cifs_debug.h"
31 #include "cifs_fs_sb.h"
35 static void cifs_set_ops(struct inode *inode)
37 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
39 switch (inode->i_mode & S_IFMT) {
41 inode->i_op = &cifs_file_inode_ops;
42 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
43 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
44 inode->i_fop = &cifs_file_direct_nobrl_ops;
46 inode->i_fop = &cifs_file_direct_ops;
47 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
48 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
49 inode->i_fop = &cifs_file_strict_nobrl_ops;
51 inode->i_fop = &cifs_file_strict_ops;
52 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
53 inode->i_fop = &cifs_file_nobrl_ops;
54 else { /* not direct, send byte range locks */
55 inode->i_fop = &cifs_file_ops;
58 /* check if server can support readpages */
59 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
60 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
61 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
63 inode->i_data.a_ops = &cifs_addr_ops;
66 #ifdef CONFIG_CIFS_DFS_UPCALL
67 if (IS_AUTOMOUNT(inode)) {
68 inode->i_op = &cifs_dfs_referral_inode_operations;
70 #else /* NO DFS support, treat as a directory */
73 inode->i_op = &cifs_dir_inode_ops;
74 inode->i_fop = &cifs_dir_ops;
78 inode->i_op = &cifs_symlink_inode_ops;
81 init_special_inode(inode, inode->i_mode, inode->i_rdev);
86 /* check inode attributes against fattr. If they don't match, tag the
87 * inode for cache invalidation
90 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
92 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
94 cifs_dbg(FYI, "%s: revalidating inode %llu\n",
95 __func__, cifs_i->uniqueid);
97 if (inode->i_state & I_NEW) {
98 cifs_dbg(FYI, "%s: inode %llu is new\n",
99 __func__, cifs_i->uniqueid);
103 /* don't bother with revalidation if we have an oplock */
104 if (cifs_i->clientCanCacheRead) {
105 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
106 __func__, cifs_i->uniqueid);
110 /* revalidate if mtime or size have changed */
111 if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
112 cifs_i->server_eof == fattr->cf_eof) {
113 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
114 __func__, cifs_i->uniqueid);
118 cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
119 __func__, cifs_i->uniqueid);
120 cifs_i->invalid_mapping = true;
123 /* populate an inode with info from a cifs_fattr struct */
125 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
127 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
128 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
130 cifs_revalidate_cache(inode, fattr);
132 spin_lock(&inode->i_lock);
133 inode->i_atime = fattr->cf_atime;
134 inode->i_mtime = fattr->cf_mtime;
135 inode->i_ctime = fattr->cf_ctime;
136 inode->i_rdev = fattr->cf_rdev;
137 set_nlink(inode, fattr->cf_nlink);
138 inode->i_uid = fattr->cf_uid;
139 inode->i_gid = fattr->cf_gid;
141 /* if dynperm is set, don't clobber existing mode */
142 if (inode->i_state & I_NEW ||
143 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
144 inode->i_mode = fattr->cf_mode;
146 cifs_i->cifsAttrs = fattr->cf_cifsattrs;
148 if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
151 cifs_i->time = jiffies;
153 cifs_i->delete_pending = fattr->cf_flags & CIFS_FATTR_DELETE_PENDING;
155 cifs_i->server_eof = fattr->cf_eof;
157 * Can't safely change the file size here if the client is writing to
158 * it due to potential races.
160 if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
161 i_size_write(inode, fattr->cf_eof);
164 * i_blocks is not related to (i_size / i_blksize),
165 * but instead 512 byte (2**9) size is required for
166 * calculating num blocks.
168 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
170 spin_unlock(&inode->i_lock);
172 if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
173 inode->i_flags |= S_AUTOMOUNT;
174 if (inode->i_state & I_NEW)
179 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
181 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
183 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
186 fattr->cf_uniqueid = iunique(sb, ROOT_I);
189 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
191 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
192 struct cifs_sb_info *cifs_sb)
194 memset(fattr, 0, sizeof(*fattr));
195 fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
196 fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
197 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
199 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
200 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
201 fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
202 fattr->cf_mode = le64_to_cpu(info->Permissions);
205 * Since we set the inode type below we need to mask off
206 * to avoid strange results if bits set above.
208 fattr->cf_mode &= ~S_IFMT;
209 switch (le32_to_cpu(info->Type)) {
211 fattr->cf_mode |= S_IFREG;
212 fattr->cf_dtype = DT_REG;
215 fattr->cf_mode |= S_IFLNK;
216 fattr->cf_dtype = DT_LNK;
219 fattr->cf_mode |= S_IFDIR;
220 fattr->cf_dtype = DT_DIR;
223 fattr->cf_mode |= S_IFCHR;
224 fattr->cf_dtype = DT_CHR;
225 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
226 le64_to_cpu(info->DevMinor) & MINORMASK);
229 fattr->cf_mode |= S_IFBLK;
230 fattr->cf_dtype = DT_BLK;
231 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
232 le64_to_cpu(info->DevMinor) & MINORMASK);
235 fattr->cf_mode |= S_IFIFO;
236 fattr->cf_dtype = DT_FIFO;
239 fattr->cf_mode |= S_IFSOCK;
240 fattr->cf_dtype = DT_SOCK;
243 /* safest to call it a file if we do not know */
244 fattr->cf_mode |= S_IFREG;
245 fattr->cf_dtype = DT_REG;
246 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
250 fattr->cf_uid = cifs_sb->mnt_uid;
251 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
252 u64 id = le64_to_cpu(info->Uid);
253 if (id < ((uid_t)-1)) {
254 kuid_t uid = make_kuid(&init_user_ns, id);
260 fattr->cf_gid = cifs_sb->mnt_gid;
261 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
262 u64 id = le64_to_cpu(info->Gid);
263 if (id < ((gid_t)-1)) {
264 kgid_t gid = make_kgid(&init_user_ns, id);
270 fattr->cf_nlink = le64_to_cpu(info->Nlinks);
274 * Fill a cifs_fattr struct with fake inode info.
276 * Needed to setup cifs_fattr data for the directory which is the
277 * junction to the new submount (ie to setup the fake directory
278 * which represents a DFS referral).
281 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
283 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
285 cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
287 memset(fattr, 0, sizeof(*fattr));
288 fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
289 fattr->cf_uid = cifs_sb->mnt_uid;
290 fattr->cf_gid = cifs_sb->mnt_gid;
291 fattr->cf_atime = CURRENT_TIME;
292 fattr->cf_ctime = CURRENT_TIME;
293 fattr->cf_mtime = CURRENT_TIME;
295 fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
299 cifs_get_file_info_unix(struct file *filp)
303 FILE_UNIX_BASIC_INFO find_data;
304 struct cifs_fattr fattr;
305 struct inode *inode = file_inode(filp);
306 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
307 struct cifsFileInfo *cfile = filp->private_data;
308 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
311 rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
313 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
314 } else if (rc == -EREMOTE) {
315 cifs_create_dfs_fattr(&fattr, inode->i_sb);
319 cifs_fattr_to_inode(inode, &fattr);
324 int cifs_get_inode_info_unix(struct inode **pinode,
325 const unsigned char *full_path,
326 struct super_block *sb, unsigned int xid)
329 FILE_UNIX_BASIC_INFO find_data;
330 struct cifs_fattr fattr;
331 struct cifs_tcon *tcon;
332 struct tcon_link *tlink;
333 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
335 cifs_dbg(FYI, "Getting info on %s\n", full_path);
337 tlink = cifs_sb_tlink(cifs_sb);
339 return PTR_ERR(tlink);
340 tcon = tlink_tcon(tlink);
342 /* could have done a find first instead but this returns more info */
343 rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
344 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
345 CIFS_MOUNT_MAP_SPECIAL_CHR);
346 cifs_put_tlink(tlink);
349 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
350 } else if (rc == -EREMOTE) {
351 cifs_create_dfs_fattr(&fattr, sb);
357 /* check for Minshall+French symlinks */
358 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
359 int tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
361 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
364 if (*pinode == NULL) {
366 cifs_fill_uniqueid(sb, &fattr);
367 *pinode = cifs_iget(sb, &fattr);
371 /* we already have inode, update it */
372 cifs_fattr_to_inode(*pinode, &fattr);
379 cifs_sfu_type(struct cifs_fattr *fattr, const unsigned char *path,
380 struct cifs_sb_info *cifs_sb, unsigned int xid)
385 struct tcon_link *tlink;
386 struct cifs_tcon *tcon;
387 struct cifs_io_parms io_parms;
389 unsigned int bytes_read;
394 fattr->cf_mode &= ~S_IFMT;
396 if (fattr->cf_eof == 0) {
397 fattr->cf_mode |= S_IFIFO;
398 fattr->cf_dtype = DT_FIFO;
400 } else if (fattr->cf_eof < 8) {
401 fattr->cf_mode |= S_IFREG;
402 fattr->cf_dtype = DT_REG;
403 return -EINVAL; /* EOPNOTSUPP? */
406 tlink = cifs_sb_tlink(cifs_sb);
408 return PTR_ERR(tlink);
409 tcon = tlink_tcon(tlink);
411 rc = CIFSSMBOpen(xid, tcon, path, FILE_OPEN, GENERIC_READ,
412 CREATE_NOT_DIR, &netfid, &oplock, NULL,
414 cifs_sb->mnt_cifs_flags &
415 CIFS_MOUNT_MAP_SPECIAL_CHR);
417 int buf_type = CIFS_NO_BUFFER;
419 io_parms.netfid = netfid;
420 io_parms.pid = current->tgid;
421 io_parms.tcon = tcon;
423 io_parms.length = 24;
424 rc = CIFSSMBRead(xid, &io_parms, &bytes_read, &pbuf,
426 if ((rc == 0) && (bytes_read >= 8)) {
427 if (memcmp("IntxBLK", pbuf, 8) == 0) {
428 cifs_dbg(FYI, "Block device\n");
429 fattr->cf_mode |= S_IFBLK;
430 fattr->cf_dtype = DT_BLK;
431 if (bytes_read == 24) {
432 /* we have enough to decode dev num */
433 __u64 mjr; /* major */
434 __u64 mnr; /* minor */
435 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
436 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
437 fattr->cf_rdev = MKDEV(mjr, mnr);
439 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
440 cifs_dbg(FYI, "Char device\n");
441 fattr->cf_mode |= S_IFCHR;
442 fattr->cf_dtype = DT_CHR;
443 if (bytes_read == 24) {
444 /* we have enough to decode dev num */
445 __u64 mjr; /* major */
446 __u64 mnr; /* minor */
447 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
448 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
449 fattr->cf_rdev = MKDEV(mjr, mnr);
451 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
452 cifs_dbg(FYI, "Symlink\n");
453 fattr->cf_mode |= S_IFLNK;
454 fattr->cf_dtype = DT_LNK;
456 fattr->cf_mode |= S_IFREG; /* file? */
457 fattr->cf_dtype = DT_REG;
461 fattr->cf_mode |= S_IFREG; /* then it is a file */
462 fattr->cf_dtype = DT_REG;
463 rc = -EOPNOTSUPP; /* or some unknown SFU type */
465 CIFSSMBClose(xid, tcon, netfid);
467 cifs_put_tlink(tlink);
471 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
474 * Fetch mode bits as provided by SFU.
476 * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
478 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
479 struct cifs_sb_info *cifs_sb, unsigned int xid)
481 #ifdef CONFIG_CIFS_XATTR
485 struct tcon_link *tlink;
486 struct cifs_tcon *tcon;
488 tlink = cifs_sb_tlink(cifs_sb);
490 return PTR_ERR(tlink);
491 tcon = tlink_tcon(tlink);
493 if (tcon->ses->server->ops->query_all_EAs == NULL) {
494 cifs_put_tlink(tlink);
498 rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
499 "SETFILEBITS", ea_value, 4 /* size of buf */,
501 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
502 cifs_put_tlink(tlink);
506 mode = le32_to_cpu(*((__le32 *)ea_value));
507 fattr->cf_mode &= ~SFBITS_MASK;
508 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
509 mode, fattr->cf_mode);
510 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
511 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
520 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
522 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
523 struct cifs_sb_info *cifs_sb, bool adjust_tz)
525 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
527 memset(fattr, 0, sizeof(*fattr));
528 fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
529 if (info->DeletePending)
530 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
532 if (info->LastAccessTime)
533 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
535 fattr->cf_atime = CURRENT_TIME;
537 fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
538 fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
541 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
542 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
545 fattr->cf_eof = le64_to_cpu(info->EndOfFile);
546 fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
547 fattr->cf_createtime = le64_to_cpu(info->CreationTime);
549 if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
550 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
551 fattr->cf_dtype = DT_DIR;
553 * Server can return wrong NumberOfLinks value for directories
554 * when Unix extensions are disabled - fake it.
558 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
559 fattr->cf_dtype = DT_REG;
561 /* clear write bits if ATTR_READONLY is set */
562 if (fattr->cf_cifsattrs & ATTR_READONLY)
563 fattr->cf_mode &= ~(S_IWUGO);
565 fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
566 if (fattr->cf_nlink < 1) {
567 cifs_dbg(1, "replacing bogus file nlink value %u\n",
573 fattr->cf_uid = cifs_sb->mnt_uid;
574 fattr->cf_gid = cifs_sb->mnt_gid;
578 cifs_get_file_info(struct file *filp)
582 FILE_ALL_INFO find_data;
583 struct cifs_fattr fattr;
584 struct inode *inode = file_inode(filp);
585 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
586 struct cifsFileInfo *cfile = filp->private_data;
587 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
588 struct TCP_Server_Info *server = tcon->ses->server;
590 if (!server->ops->query_file_info)
594 rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
597 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false);
600 cifs_create_dfs_fattr(&fattr, inode->i_sb);
606 * FIXME: legacy server -- fall back to path-based call?
607 * for now, just skip revalidating and mark inode for
611 CIFS_I(inode)->time = 0;
617 * don't bother with SFU junk here -- just mark inode as needing
620 fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
621 fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
622 cifs_fattr_to_inode(inode, &fattr);
629 cifs_get_inode_info(struct inode **inode, const char *full_path,
630 FILE_ALL_INFO *data, struct super_block *sb, int xid,
633 bool validinum = false;
635 int rc = 0, tmprc = ENOSYS;
636 struct cifs_tcon *tcon;
637 struct TCP_Server_Info *server;
638 struct tcon_link *tlink;
639 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
641 bool adjust_tz = false;
642 struct cifs_fattr fattr;
643 struct cifs_search_info *srchinf = NULL;
645 tlink = cifs_sb_tlink(cifs_sb);
647 return PTR_ERR(tlink);
648 tcon = tlink_tcon(tlink);
649 server = tcon->ses->server;
651 cifs_dbg(FYI, "Getting info on %s\n", full_path);
653 if ((data == NULL) && (*inode != NULL)) {
654 if (CIFS_I(*inode)->clientCanCacheRead) {
655 cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
660 /* if inode info is not passed, get it from server */
662 if (!server->ops->query_path_info) {
666 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
671 data = (FILE_ALL_INFO *)buf;
672 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
677 cifs_all_info_to_fattr(&fattr, (FILE_ALL_INFO *)data, cifs_sb,
679 } else if (rc == -EREMOTE) {
680 cifs_create_dfs_fattr(&fattr, sb);
682 } else if (rc == -EACCES && backup_cred(cifs_sb)) {
683 srchinf = kzalloc(sizeof(struct cifs_search_info),
685 if (srchinf == NULL) {
690 srchinf->endOfSearch = false;
691 srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
693 srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
694 CIFS_SEARCH_CLOSE_AT_END |
695 CIFS_SEARCH_BACKUP_SEARCH;
697 rc = CIFSFindFirst(xid, tcon, full_path,
698 cifs_sb, NULL, srchflgs, srchinf, false);
701 (FILE_ALL_INFO *)srchinf->srch_entries_start;
703 cifs_dir_info_to_fattr(&fattr,
704 (FILE_DIRECTORY_INFO *)data, cifs_sb);
705 fattr.cf_uniqueid = le64_to_cpu(
706 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
709 cifs_buf_release(srchinf->ntwrk_buf_start);
716 * If an inode wasn't passed in, then get the inode number
718 * Is an i_ino of zero legal? Can we use that to check if the server
719 * supports returning inode numbers? Are there other sanity checks we
720 * can use to ensure that the server is really filling in that field?
722 if (*inode == NULL) {
723 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
724 if (validinum == false) {
725 if (server->ops->get_srv_inum)
726 tmprc = server->ops->get_srv_inum(xid,
727 tcon, cifs_sb, full_path,
728 &fattr.cf_uniqueid, data);
730 cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
732 fattr.cf_uniqueid = iunique(sb, ROOT_I);
733 cifs_autodisable_serverino(cifs_sb);
737 fattr.cf_uniqueid = iunique(sb, ROOT_I);
739 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
741 /* query for SFU type info if supported and needed */
742 if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
743 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
744 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
746 cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
749 #ifdef CONFIG_CIFS_ACL
750 /* fill in 0777 bits from ACL */
751 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
752 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
754 cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
759 #endif /* CONFIG_CIFS_ACL */
761 /* fill in remaining high mode bits e.g. SUID, VTX */
762 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
763 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
765 /* check for Minshall+French symlinks */
766 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
767 tmprc = CIFSCheckMFSymlink(&fattr, full_path, cifs_sb, xid);
769 cifs_dbg(FYI, "CIFSCheckMFSymlink: %d\n", tmprc);
773 *inode = cifs_iget(sb, &fattr);
777 cifs_fattr_to_inode(*inode, &fattr);
782 cifs_put_tlink(tlink);
786 static const struct inode_operations cifs_ipc_inode_ops = {
787 .lookup = cifs_lookup,
791 cifs_find_inode(struct inode *inode, void *opaque)
793 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
795 /* don't match inode with different uniqueid */
796 if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
799 /* use createtime like an i_generation field */
800 if (CIFS_I(inode)->createtime != fattr->cf_createtime)
803 /* don't match inode of different type */
804 if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
807 /* if it's not a directory or has no dentries, then flag it */
808 if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
809 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
815 cifs_init_inode(struct inode *inode, void *opaque)
817 struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
819 CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
820 CIFS_I(inode)->createtime = fattr->cf_createtime;
825 * walk dentry list for an inode and report whether it has aliases that
826 * are hashed. We use this to determine if a directory inode can actually
830 inode_has_hashed_dentries(struct inode *inode)
832 struct dentry *dentry;
834 spin_lock(&inode->i_lock);
835 hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
836 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
837 spin_unlock(&inode->i_lock);
841 spin_unlock(&inode->i_lock);
845 /* Given fattrs, get a corresponding inode */
847 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
853 cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
855 /* hash down to 32-bits on 32-bit arch */
856 hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
858 inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
860 /* was there a potentially problematic inode collision? */
861 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
862 fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
864 if (inode_has_hashed_dentries(inode)) {
865 cifs_autodisable_serverino(CIFS_SB(sb));
867 fattr->cf_uniqueid = iunique(sb, ROOT_I);
868 goto retry_iget5_locked;
872 cifs_fattr_to_inode(inode, fattr);
873 if (sb->s_flags & MS_NOATIME)
874 inode->i_flags |= S_NOATIME | S_NOCMTIME;
875 if (inode->i_state & I_NEW) {
877 if (S_ISREG(inode->i_mode))
878 inode->i_data.backing_dev_info = sb->s_bdi;
879 #ifdef CONFIG_CIFS_FSCACHE
880 /* initialize per-inode cache cookie pointer */
881 CIFS_I(inode)->fscache = NULL;
883 unlock_new_inode(inode);
890 /* gets root inode */
891 struct inode *cifs_root_iget(struct super_block *sb)
894 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
895 struct inode *inode = NULL;
897 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
901 rc = cifs_get_inode_info_unix(&inode, "", sb, xid);
903 rc = cifs_get_inode_info(&inode, "", NULL, sb, xid, NULL);
910 #ifdef CONFIG_CIFS_FSCACHE
911 /* populate tcon->resource_id */
912 tcon->resource_id = CIFS_I(inode)->uniqueid;
915 if (rc && tcon->ipc) {
916 cifs_dbg(FYI, "ipc connection - fake read inode\n");
917 spin_lock(&inode->i_lock);
918 inode->i_mode |= S_IFDIR;
920 inode->i_op = &cifs_ipc_inode_ops;
921 inode->i_fop = &simple_dir_operations;
922 inode->i_uid = cifs_sb->mnt_uid;
923 inode->i_gid = cifs_sb->mnt_gid;
924 spin_unlock(&inode->i_lock);
931 /* can not call macro free_xid here since in a void func
932 * TODO: This is no longer true
939 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
940 char *full_path, __u32 dosattr)
942 bool set_time = false;
943 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
944 struct TCP_Server_Info *server;
945 FILE_BASIC_INFO info_buf;
950 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
951 if (!server->ops->set_file_info)
954 if (attrs->ia_valid & ATTR_ATIME) {
956 info_buf.LastAccessTime =
957 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
959 info_buf.LastAccessTime = 0;
961 if (attrs->ia_valid & ATTR_MTIME) {
963 info_buf.LastWriteTime =
964 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
966 info_buf.LastWriteTime = 0;
969 * Samba throws this field away, but windows may actually use it.
970 * Do not set ctime unless other time stamps are changed explicitly
971 * (i.e. by utimes()) since we would then have a mix of client and
974 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
975 cifs_dbg(FYI, "CIFS - CTIME changed\n");
976 info_buf.ChangeTime =
977 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
979 info_buf.ChangeTime = 0;
981 info_buf.CreationTime = 0; /* don't change */
982 info_buf.Attributes = cpu_to_le32(dosattr);
984 return server->ops->set_file_info(inode, full_path, &info_buf, xid);
988 * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
989 * and rename it to a random name that hopefully won't conflict with
993 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
994 const unsigned int xid)
999 struct inode *inode = dentry->d_inode;
1000 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1001 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1002 struct tcon_link *tlink;
1003 struct cifs_tcon *tcon;
1004 __u32 dosattr, origattr;
1005 FILE_BASIC_INFO *info_buf = NULL;
1007 tlink = cifs_sb_tlink(cifs_sb);
1009 return PTR_ERR(tlink);
1010 tcon = tlink_tcon(tlink);
1013 * We cannot rename the file if the server doesn't support
1014 * CAP_INFOLEVEL_PASSTHRU
1016 if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1021 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
1022 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
1023 &netfid, &oplock, NULL, cifs_sb->local_nls,
1024 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1028 origattr = cifsInode->cifsAttrs;
1030 origattr |= ATTR_NORMAL;
1032 dosattr = origattr & ~ATTR_READONLY;
1034 dosattr |= ATTR_NORMAL;
1035 dosattr |= ATTR_HIDDEN;
1037 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1038 if (dosattr != origattr) {
1039 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1040 if (info_buf == NULL) {
1044 info_buf->Attributes = cpu_to_le32(dosattr);
1045 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1047 /* although we would like to mark the file hidden
1048 if that fails we will still try to rename it */
1050 cifsInode->cifsAttrs = dosattr;
1052 dosattr = origattr; /* since not able to change them */
1055 /* rename the file */
1056 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
1057 cifs_sb->mnt_cifs_flags &
1058 CIFS_MOUNT_MAP_SPECIAL_CHR);
1064 /* try to set DELETE_ON_CLOSE */
1065 if (!cifsInode->delete_pending) {
1066 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
1069 * some samba versions return -ENOENT when we try to set the
1070 * file disposition here. Likely a samba bug, but work around
1071 * it for now. This means that some cifsXXX files may hang
1072 * around after they shouldn't.
1074 * BB: remove this hack after more servers have the fix
1082 cifsInode->delete_pending = true;
1086 CIFSSMBClose(xid, tcon, netfid);
1089 cifs_put_tlink(tlink);
1093 * reset everything back to the original state. Don't bother
1094 * dealing with errors here since we can't do anything about
1098 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
1099 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1100 CIFS_MOUNT_MAP_SPECIAL_CHR);
1102 if (dosattr != origattr) {
1103 info_buf->Attributes = cpu_to_le32(origattr);
1104 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
1106 cifsInode->cifsAttrs = origattr;
1112 /* copied from fs/nfs/dir.c with small changes */
1114 cifs_drop_nlink(struct inode *inode)
1116 spin_lock(&inode->i_lock);
1117 if (inode->i_nlink > 0)
1119 spin_unlock(&inode->i_lock);
1123 * If dentry->d_inode is null (usually meaning the cached dentry
1124 * is a negative dentry) then we would attempt a standard SMB delete, but
1125 * if that fails we can not attempt the fall back mechanisms on EACCESS
1126 * but will return the EACCESS to the caller. Note that the VFS does not call
1127 * unlink on negative dentries currently.
1129 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1133 char *full_path = NULL;
1134 struct inode *inode = dentry->d_inode;
1135 struct cifsInodeInfo *cifs_inode;
1136 struct super_block *sb = dir->i_sb;
1137 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1138 struct tcon_link *tlink;
1139 struct cifs_tcon *tcon;
1140 struct TCP_Server_Info *server;
1141 struct iattr *attrs = NULL;
1142 __u32 dosattr = 0, origattr = 0;
1144 cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1146 tlink = cifs_sb_tlink(cifs_sb);
1148 return PTR_ERR(tlink);
1149 tcon = tlink_tcon(tlink);
1150 server = tcon->ses->server;
1154 /* Unlink can be called from rename so we can not take the
1155 * sb->s_vfs_rename_mutex here */
1156 full_path = build_path_from_dentry(dentry);
1157 if (full_path == NULL) {
1162 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1163 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1164 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1165 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1166 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1167 cifs_dbg(FYI, "posix del rc %d\n", rc);
1168 if ((rc == 0) || (rc == -ENOENT))
1169 goto psx_del_no_retry;
1173 if (!server->ops->unlink) {
1175 goto psx_del_no_retry;
1178 rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1183 cifs_drop_nlink(inode);
1184 } else if (rc == -ENOENT) {
1186 } else if (rc == -EBUSY) {
1187 if (server->ops->rename_pending_delete) {
1188 rc = server->ops->rename_pending_delete(full_path,
1191 cifs_drop_nlink(inode);
1193 } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1194 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1195 if (attrs == NULL) {
1200 /* try to reset dos attributes */
1201 cifs_inode = CIFS_I(inode);
1202 origattr = cifs_inode->cifsAttrs;
1204 origattr |= ATTR_NORMAL;
1205 dosattr = origattr & ~ATTR_READONLY;
1207 dosattr |= ATTR_NORMAL;
1208 dosattr |= ATTR_HIDDEN;
1210 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1214 goto retry_std_delete;
1217 /* undo the setattr if we errored out and it's needed */
1218 if (rc != 0 && dosattr != 0)
1219 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1223 cifs_inode = CIFS_I(inode);
1224 cifs_inode->time = 0; /* will force revalidate to get info
1226 inode->i_ctime = current_fs_time(sb);
1228 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1229 cifs_inode = CIFS_I(dir);
1230 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
1235 cifs_put_tlink(tlink);
1240 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1241 const char *full_path, struct cifs_sb_info *cifs_sb,
1242 struct cifs_tcon *tcon, const unsigned int xid)
1245 struct inode *inode = NULL;
1248 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1251 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1258 * setting nlink not necessary except in cases where we failed to get it
1259 * from the server or was set bogus. Also, since this is a brand new
1260 * inode, no need to grab the i_lock before setting the i_nlink.
1262 if (inode->i_nlink < 2)
1263 set_nlink(inode, 2);
1264 mode &= ~current_umask();
1265 /* must turn on setgid bit if parent dir has it */
1266 if (parent->i_mode & S_ISGID)
1269 if (tcon->unix_ext) {
1270 struct cifs_unix_set_info_args args = {
1272 .ctime = NO_CHANGE_64,
1273 .atime = NO_CHANGE_64,
1274 .mtime = NO_CHANGE_64,
1277 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1278 args.uid = current_fsuid();
1279 if (parent->i_mode & S_ISGID)
1280 args.gid = parent->i_gid;
1282 args.gid = current_fsgid();
1284 args.uid = INVALID_UID; /* no change */
1285 args.gid = INVALID_GID; /* no change */
1287 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1289 cifs_sb->mnt_cifs_flags &
1290 CIFS_MOUNT_MAP_SPECIAL_CHR);
1292 struct TCP_Server_Info *server = tcon->ses->server;
1293 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1294 (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1295 server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1297 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1298 inode->i_mode = (mode | S_IFDIR);
1300 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1301 inode->i_uid = current_fsuid();
1302 if (inode->i_mode & S_ISGID)
1303 inode->i_gid = parent->i_gid;
1305 inode->i_gid = current_fsgid();
1308 d_instantiate(dentry, inode);
1313 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1314 const char *full_path, struct cifs_sb_info *cifs_sb,
1315 struct cifs_tcon *tcon, const unsigned int xid)
1319 FILE_UNIX_BASIC_INFO *info = NULL;
1320 struct inode *newinode = NULL;
1321 struct cifs_fattr fattr;
1323 info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1326 goto posix_mkdir_out;
1329 mode &= ~current_umask();
1330 rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1331 NULL /* netfid */, info, &oplock, full_path,
1332 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1333 CIFS_MOUNT_MAP_SPECIAL_CHR);
1334 if (rc == -EOPNOTSUPP)
1335 goto posix_mkdir_out;
1337 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1339 goto posix_mkdir_out;
1342 if (info->Type == cpu_to_le32(-1))
1343 /* no return info, go query for it */
1344 goto posix_mkdir_get_info;
1346 * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1347 * need to set uid/gid.
1350 cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1351 cifs_fill_uniqueid(inode->i_sb, &fattr);
1352 newinode = cifs_iget(inode->i_sb, &fattr);
1354 goto posix_mkdir_get_info;
1356 d_instantiate(dentry, newinode);
1358 #ifdef CONFIG_CIFS_DEBUG2
1359 cifs_dbg(FYI, "instantiated dentry %p %s to inode %p\n",
1360 dentry, dentry->d_name.name, newinode);
1362 if (newinode->i_nlink != 2)
1363 cifs_dbg(FYI, "unexpected number of links %d\n",
1370 posix_mkdir_get_info:
1371 rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1373 goto posix_mkdir_out;
1376 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1380 struct cifs_sb_info *cifs_sb;
1381 struct tcon_link *tlink;
1382 struct cifs_tcon *tcon;
1383 struct TCP_Server_Info *server;
1386 cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1389 cifs_sb = CIFS_SB(inode->i_sb);
1390 tlink = cifs_sb_tlink(cifs_sb);
1392 return PTR_ERR(tlink);
1393 tcon = tlink_tcon(tlink);
1397 full_path = build_path_from_dentry(direntry);
1398 if (full_path == NULL) {
1403 if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1404 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1405 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1407 if (rc != -EOPNOTSUPP)
1411 server = tcon->ses->server;
1413 if (!server->ops->mkdir) {
1418 /* BB add setting the equivalent of mode via CreateX w/ACLs */
1419 rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1421 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1426 rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1430 * Force revalidate to get parent dir info when needed since cached
1431 * attributes are invalid now.
1433 CIFS_I(inode)->time = 0;
1436 cifs_put_tlink(tlink);
1440 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1444 struct cifs_sb_info *cifs_sb;
1445 struct tcon_link *tlink;
1446 struct cifs_tcon *tcon;
1447 struct TCP_Server_Info *server;
1448 char *full_path = NULL;
1449 struct cifsInodeInfo *cifsInode;
1451 cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1455 full_path = build_path_from_dentry(direntry);
1456 if (full_path == NULL) {
1461 cifs_sb = CIFS_SB(inode->i_sb);
1462 tlink = cifs_sb_tlink(cifs_sb);
1463 if (IS_ERR(tlink)) {
1464 rc = PTR_ERR(tlink);
1467 tcon = tlink_tcon(tlink);
1468 server = tcon->ses->server;
1470 if (!server->ops->rmdir) {
1472 cifs_put_tlink(tlink);
1476 rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1477 cifs_put_tlink(tlink);
1480 spin_lock(&direntry->d_inode->i_lock);
1481 i_size_write(direntry->d_inode, 0);
1482 clear_nlink(direntry->d_inode);
1483 spin_unlock(&direntry->d_inode->i_lock);
1486 cifsInode = CIFS_I(direntry->d_inode);
1487 /* force revalidate to go get info when needed */
1488 cifsInode->time = 0;
1490 cifsInode = CIFS_I(inode);
1492 * Force revalidate to get parent dir info when needed since cached
1493 * attributes are invalid now.
1495 cifsInode->time = 0;
1497 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1498 current_fs_time(inode->i_sb);
1507 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1508 const char *from_path, struct dentry *to_dentry,
1509 const char *to_path)
1511 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1512 struct tcon_link *tlink;
1513 struct cifs_tcon *tcon;
1514 struct TCP_Server_Info *server;
1518 tlink = cifs_sb_tlink(cifs_sb);
1520 return PTR_ERR(tlink);
1521 tcon = tlink_tcon(tlink);
1522 server = tcon->ses->server;
1524 if (!server->ops->rename)
1527 /* try path-based rename first */
1528 rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1531 * Don't bother with rename by filehandle unless file is busy and
1532 * source. Note that cross directory moves do not work with
1533 * rename by filehandle to various Windows servers.
1535 if (rc == 0 || rc != -EBUSY)
1536 goto do_rename_exit;
1538 /* open-file renames don't work across directories */
1539 if (to_dentry->d_parent != from_dentry->d_parent)
1540 goto do_rename_exit;
1542 /* open the file to be renamed -- we need DELETE perms */
1543 rc = CIFSSMBOpen(xid, tcon, from_path, FILE_OPEN, DELETE,
1544 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1545 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1546 CIFS_MOUNT_MAP_SPECIAL_CHR);
1548 rc = CIFSSMBRenameOpenFile(xid, tcon, srcfid,
1549 (const char *) to_dentry->d_name.name,
1550 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1551 CIFS_MOUNT_MAP_SPECIAL_CHR);
1552 CIFSSMBClose(xid, tcon, srcfid);
1555 cifs_put_tlink(tlink);
1560 cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1561 struct inode *target_dir, struct dentry *target_dentry)
1563 char *from_name = NULL;
1564 char *to_name = NULL;
1565 struct cifs_sb_info *cifs_sb;
1566 struct tcon_link *tlink;
1567 struct cifs_tcon *tcon;
1568 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1569 FILE_UNIX_BASIC_INFO *info_buf_target;
1573 cifs_sb = CIFS_SB(source_dir->i_sb);
1574 tlink = cifs_sb_tlink(cifs_sb);
1576 return PTR_ERR(tlink);
1577 tcon = tlink_tcon(tlink);
1582 * we already have the rename sem so we do not need to
1583 * grab it again here to protect the path integrity
1585 from_name = build_path_from_dentry(source_dentry);
1586 if (from_name == NULL) {
1588 goto cifs_rename_exit;
1591 to_name = build_path_from_dentry(target_dentry);
1592 if (to_name == NULL) {
1594 goto cifs_rename_exit;
1597 rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1600 if (rc == -EEXIST && tcon->unix_ext) {
1602 * Are src and dst hardlinks of same inode? We can only tell
1603 * with unix extensions enabled.
1606 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1608 if (info_buf_source == NULL) {
1610 goto cifs_rename_exit;
1613 info_buf_target = info_buf_source + 1;
1614 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1617 cifs_sb->mnt_cifs_flags &
1618 CIFS_MOUNT_MAP_SPECIAL_CHR);
1622 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1625 cifs_sb->mnt_cifs_flags &
1626 CIFS_MOUNT_MAP_SPECIAL_CHR);
1628 if (tmprc == 0 && (info_buf_source->UniqueId ==
1629 info_buf_target->UniqueId)) {
1630 /* same file, POSIX says that this is a noop */
1632 goto cifs_rename_exit;
1636 * else ... BB we could add the same check for Windows by
1637 * checking the UniqueId via FILE_INTERNAL_INFO
1641 /* Try unlinking the target dentry if it's not negative */
1642 if (target_dentry->d_inode && (rc == -EACCES || rc == -EEXIST)) {
1643 if (S_ISDIR(target_dentry->d_inode->i_mode))
1644 tmprc = cifs_rmdir(target_dir, target_dentry);
1646 tmprc = cifs_unlink(target_dir, target_dentry);
1648 goto cifs_rename_exit;
1649 rc = cifs_do_rename(xid, source_dentry, from_name,
1650 target_dentry, to_name);
1653 /* force revalidate to go get info when needed */
1654 CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1656 source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1657 target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1660 kfree(info_buf_source);
1664 cifs_put_tlink(tlink);
1669 cifs_inode_needs_reval(struct inode *inode)
1671 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1672 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1674 if (cifs_i->clientCanCacheRead)
1677 if (!lookupCacheEnabled)
1680 if (cifs_i->time == 0)
1683 if (!time_in_range(jiffies, cifs_i->time,
1684 cifs_i->time + cifs_sb->actimeo))
1687 /* hardlinked files w/ noserverino get "special" treatment */
1688 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1689 S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1696 * Zap the cache. Called when invalid_mapping flag is set.
1699 cifs_invalidate_mapping(struct inode *inode)
1702 struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1704 cifs_i->invalid_mapping = false;
1706 if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1707 rc = invalidate_inode_pages2(inode->i_mapping);
1709 cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1711 cifs_i->invalid_mapping = true;
1715 cifs_fscache_reset_inode_cookie(inode);
1719 int cifs_revalidate_file_attr(struct file *filp)
1722 struct inode *inode = file_inode(filp);
1723 struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1725 if (!cifs_inode_needs_reval(inode))
1728 if (tlink_tcon(cfile->tlink)->unix_ext)
1729 rc = cifs_get_file_info_unix(filp);
1731 rc = cifs_get_file_info(filp);
1736 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1740 struct inode *inode = dentry->d_inode;
1741 struct super_block *sb = dentry->d_sb;
1742 char *full_path = NULL;
1747 if (!cifs_inode_needs_reval(inode))
1752 /* can not safely grab the rename sem here if rename calls revalidate
1753 since that would deadlock */
1754 full_path = build_path_from_dentry(dentry);
1755 if (full_path == NULL) {
1760 cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1761 full_path, inode, inode->i_count.counter,
1762 dentry, dentry->d_time, jiffies);
1764 if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1765 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1767 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1776 int cifs_revalidate_file(struct file *filp)
1779 struct inode *inode = file_inode(filp);
1781 rc = cifs_revalidate_file_attr(filp);
1785 if (CIFS_I(inode)->invalid_mapping)
1786 rc = cifs_invalidate_mapping(inode);
1790 /* revalidate a dentry's inode attributes */
1791 int cifs_revalidate_dentry(struct dentry *dentry)
1794 struct inode *inode = dentry->d_inode;
1796 rc = cifs_revalidate_dentry_attr(dentry);
1800 if (CIFS_I(inode)->invalid_mapping)
1801 rc = cifs_invalidate_mapping(inode);
1805 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1808 struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1809 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1810 struct inode *inode = dentry->d_inode;
1814 * We need to be sure that all dirty pages are written and the server
1815 * has actual ctime, mtime and file length.
1817 if (!CIFS_I(inode)->clientCanCacheRead && inode->i_mapping &&
1818 inode->i_mapping->nrpages != 0) {
1819 rc = filemap_fdatawait(inode->i_mapping);
1821 mapping_set_error(inode->i_mapping, rc);
1826 rc = cifs_revalidate_dentry_attr(dentry);
1830 generic_fillattr(inode, stat);
1831 stat->blksize = CIFS_MAX_MSGSIZE;
1832 stat->ino = CIFS_I(inode)->uniqueid;
1835 * If on a multiuser mount without unix extensions or cifsacl being
1836 * enabled, and the admin hasn't overridden them, set the ownership
1837 * to the fsuid/fsgid of the current process.
1839 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
1840 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1842 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
1843 stat->uid = current_fsuid();
1844 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
1845 stat->gid = current_fsgid();
1850 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1852 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1853 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1857 page = grab_cache_page(mapping, index);
1861 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1863 page_cache_release(page);
1867 static void cifs_setsize(struct inode *inode, loff_t offset)
1871 spin_lock(&inode->i_lock);
1872 oldsize = inode->i_size;
1873 i_size_write(inode, offset);
1874 spin_unlock(&inode->i_lock);
1876 truncate_pagecache(inode, oldsize, offset);
1880 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1881 unsigned int xid, char *full_path)
1884 struct cifsFileInfo *open_file;
1885 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1886 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1887 struct tcon_link *tlink = NULL;
1888 struct cifs_tcon *tcon = NULL;
1889 struct TCP_Server_Info *server;
1890 struct cifs_io_parms io_parms;
1893 * To avoid spurious oplock breaks from server, in the case of
1894 * inodes that we already have open, avoid doing path based
1895 * setting of file size if we can do it by handle.
1896 * This keeps our caching token (oplock) and avoids timeouts
1897 * when the local oplock break takes longer to flush
1898 * writebehind data than the SMB timeout for the SetPathInfo
1899 * request would allow
1901 open_file = find_writable_file(cifsInode, true);
1903 tcon = tlink_tcon(open_file->tlink);
1904 server = tcon->ses->server;
1905 if (server->ops->set_file_size)
1906 rc = server->ops->set_file_size(xid, tcon, open_file,
1907 attrs->ia_size, false);
1910 cifsFileInfo_put(open_file);
1911 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
1912 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1913 unsigned int bytes_written;
1915 io_parms.netfid = open_file->fid.netfid;
1916 io_parms.pid = open_file->pid;
1917 io_parms.tcon = tcon;
1918 io_parms.offset = 0;
1919 io_parms.length = attrs->ia_size;
1920 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written,
1922 cifs_dbg(FYI, "Wrt seteof rc %d\n", rc);
1931 tlink = cifs_sb_tlink(cifs_sb);
1933 return PTR_ERR(tlink);
1934 tcon = tlink_tcon(tlink);
1935 server = tcon->ses->server;
1939 * Set file size by pathname rather than by handle either because no
1940 * valid, writeable file handle for it was found or because there was
1941 * an error setting it by handle.
1943 if (server->ops->set_path_size)
1944 rc = server->ops->set_path_size(xid, tcon, full_path,
1945 attrs->ia_size, cifs_sb, false);
1948 cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
1949 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1953 rc = SMBLegacyOpen(xid, tcon, full_path, FILE_OPEN,
1954 GENERIC_WRITE, CREATE_NOT_DIR, &netfid,
1955 &oplock, NULL, cifs_sb->local_nls,
1956 cifs_sb->mnt_cifs_flags &
1957 CIFS_MOUNT_MAP_SPECIAL_CHR);
1959 unsigned int bytes_written;
1961 io_parms.netfid = netfid;
1962 io_parms.pid = current->tgid;
1963 io_parms.tcon = tcon;
1964 io_parms.offset = 0;
1965 io_parms.length = attrs->ia_size;
1966 rc = CIFSSMBWrite(xid, &io_parms, &bytes_written, NULL,
1968 cifs_dbg(FYI, "wrt seteof rc %d\n", rc);
1969 CIFSSMBClose(xid, tcon, netfid);
1973 cifs_put_tlink(tlink);
1977 cifsInode->server_eof = attrs->ia_size;
1978 cifs_setsize(inode, attrs->ia_size);
1979 cifs_truncate_page(inode->i_mapping, inode->i_size);
1986 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1990 char *full_path = NULL;
1991 struct inode *inode = direntry->d_inode;
1992 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1993 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1994 struct tcon_link *tlink;
1995 struct cifs_tcon *pTcon;
1996 struct cifs_unix_set_info_args *args = NULL;
1997 struct cifsFileInfo *open_file;
1999 cifs_dbg(FYI, "setattr_unix on file %s attrs->ia_valid=0x%x\n",
2000 direntry->d_name.name, attrs->ia_valid);
2004 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2005 attrs->ia_valid |= ATTR_FORCE;
2007 rc = inode_change_ok(inode, attrs);
2011 full_path = build_path_from_dentry(direntry);
2012 if (full_path == NULL) {
2018 * Attempt to flush data before changing attributes. We need to do
2019 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2020 * ownership or mode then we may also need to do this. Here, we take
2021 * the safe way out and just do the flush on all setattr requests. If
2022 * the flush returns error, store it to report later and continue.
2024 * BB: This should be smarter. Why bother flushing pages that
2025 * will be truncated anyway? Also, should we error out here if
2026 * the flush returns error?
2028 rc = filemap_write_and_wait(inode->i_mapping);
2029 mapping_set_error(inode->i_mapping, rc);
2032 if (attrs->ia_valid & ATTR_SIZE) {
2033 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2038 /* skip mode change if it's just for clearing setuid/setgid */
2039 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2040 attrs->ia_valid &= ~ATTR_MODE;
2042 args = kmalloc(sizeof(*args), GFP_KERNEL);
2048 /* set up the struct */
2049 if (attrs->ia_valid & ATTR_MODE)
2050 args->mode = attrs->ia_mode;
2052 args->mode = NO_CHANGE_64;
2054 if (attrs->ia_valid & ATTR_UID)
2055 args->uid = attrs->ia_uid;
2057 args->uid = INVALID_UID; /* no change */
2059 if (attrs->ia_valid & ATTR_GID)
2060 args->gid = attrs->ia_gid;
2062 args->gid = INVALID_GID; /* no change */
2064 if (attrs->ia_valid & ATTR_ATIME)
2065 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2067 args->atime = NO_CHANGE_64;
2069 if (attrs->ia_valid & ATTR_MTIME)
2070 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2072 args->mtime = NO_CHANGE_64;
2074 if (attrs->ia_valid & ATTR_CTIME)
2075 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2077 args->ctime = NO_CHANGE_64;
2080 open_file = find_writable_file(cifsInode, true);
2082 u16 nfid = open_file->fid.netfid;
2083 u32 npid = open_file->pid;
2084 pTcon = tlink_tcon(open_file->tlink);
2085 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2086 cifsFileInfo_put(open_file);
2088 tlink = cifs_sb_tlink(cifs_sb);
2089 if (IS_ERR(tlink)) {
2090 rc = PTR_ERR(tlink);
2093 pTcon = tlink_tcon(tlink);
2094 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2096 cifs_sb->mnt_cifs_flags &
2097 CIFS_MOUNT_MAP_SPECIAL_CHR);
2098 cifs_put_tlink(tlink);
2104 if ((attrs->ia_valid & ATTR_SIZE) &&
2105 attrs->ia_size != i_size_read(inode))
2106 truncate_setsize(inode, attrs->ia_size);
2108 setattr_copy(inode, attrs);
2109 mark_inode_dirty(inode);
2111 /* force revalidate when any of these times are set since some
2112 of the fs types (eg ext3, fat) do not have fine enough
2113 time granularity to match protocol, and we do not have a
2114 a way (yet) to query the server fs's time granularity (and
2115 whether it rounds times down).
2117 if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2118 cifsInode->time = 0;
2127 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2130 kuid_t uid = INVALID_UID;
2131 kgid_t gid = INVALID_GID;
2132 struct inode *inode = direntry->d_inode;
2133 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2134 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2135 char *full_path = NULL;
2138 __u64 mode = NO_CHANGE_64;
2142 cifs_dbg(FYI, "setattr on file %s attrs->iavalid 0x%x\n",
2143 direntry->d_name.name, attrs->ia_valid);
2145 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2146 attrs->ia_valid |= ATTR_FORCE;
2148 rc = inode_change_ok(inode, attrs);
2154 full_path = build_path_from_dentry(direntry);
2155 if (full_path == NULL) {
2162 * Attempt to flush data before changing attributes. We need to do
2163 * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2164 * ownership or mode then we may also need to do this. Here, we take
2165 * the safe way out and just do the flush on all setattr requests. If
2166 * the flush returns error, store it to report later and continue.
2168 * BB: This should be smarter. Why bother flushing pages that
2169 * will be truncated anyway? Also, should we error out here if
2170 * the flush returns error?
2172 rc = filemap_write_and_wait(inode->i_mapping);
2173 mapping_set_error(inode->i_mapping, rc);
2176 if (attrs->ia_valid & ATTR_SIZE) {
2177 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2179 goto cifs_setattr_exit;
2182 if (attrs->ia_valid & ATTR_UID)
2183 uid = attrs->ia_uid;
2185 if (attrs->ia_valid & ATTR_GID)
2186 gid = attrs->ia_gid;
2188 #ifdef CONFIG_CIFS_ACL
2189 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2190 if (uid_valid(uid) || gid_valid(gid)) {
2191 rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2194 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2196 goto cifs_setattr_exit;
2200 #endif /* CONFIG_CIFS_ACL */
2201 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2202 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2204 /* skip mode change if it's just for clearing setuid/setgid */
2205 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2206 attrs->ia_valid &= ~ATTR_MODE;
2208 if (attrs->ia_valid & ATTR_MODE) {
2209 mode = attrs->ia_mode;
2211 #ifdef CONFIG_CIFS_ACL
2212 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2213 rc = id_mode_to_cifs_acl(inode, full_path, mode,
2214 INVALID_UID, INVALID_GID);
2216 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2218 goto cifs_setattr_exit;
2221 #endif /* CONFIG_CIFS_ACL */
2222 if (((mode & S_IWUGO) == 0) &&
2223 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2225 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2227 /* fix up mode if we're not using dynperm */
2228 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2229 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2230 } else if ((mode & S_IWUGO) &&
2231 (cifsInode->cifsAttrs & ATTR_READONLY)) {
2233 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2234 /* Attributes of 0 are ignored */
2236 dosattr |= ATTR_NORMAL;
2238 /* reset local inode permissions to normal */
2239 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2240 attrs->ia_mode &= ~(S_IALLUGO);
2241 if (S_ISDIR(inode->i_mode))
2243 cifs_sb->mnt_dir_mode;
2246 cifs_sb->mnt_file_mode;
2248 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2249 /* ignore mode change - ATTR_READONLY hasn't changed */
2250 attrs->ia_valid &= ~ATTR_MODE;
2254 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2255 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2256 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2257 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2259 /* Even if error on time set, no sense failing the call if
2260 the server would set the time to a reasonable value anyway,
2261 and this check ensures that we are not being called from
2262 sys_utimes in which case we ought to fail the call back to
2263 the user when the server rejects the call */
2264 if ((rc) && (attrs->ia_valid &
2265 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2269 /* do not need local check to inode_check_ok since the server does
2272 goto cifs_setattr_exit;
2274 if ((attrs->ia_valid & ATTR_SIZE) &&
2275 attrs->ia_size != i_size_read(inode))
2276 truncate_setsize(inode, attrs->ia_size);
2278 setattr_copy(inode, attrs);
2279 mark_inode_dirty(inode);
2288 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2290 struct inode *inode = direntry->d_inode;
2291 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2292 struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2294 if (pTcon->unix_ext)
2295 return cifs_setattr_unix(direntry, attrs);
2297 return cifs_setattr_nounix(direntry, attrs);
2299 /* BB: add cifs_setattr_legacy for really old servers */
2303 void cifs_delete_inode(struct inode *inode)
2305 cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2306 /* may have to add back in if and when safe distributed caching of
2307 directories added e.g. via FindNotify */