~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/cifs/inode.c

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  *   fs/cifs/inode.c
  3  *
  4  *   Copyright (C) International Business Machines  Corp., 2002,2010
  5  *   Author(s): Steve French (sfrench@us.ibm.com)
  6  *
  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.
 11  *
 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.
 16  *
 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
 20  */
 21 #include <linux/fs.h>
 22 #include <linux/stat.h>
 23 #include <linux/slab.h>
 24 #include <linux/pagemap.h>
 25 #include <linux/freezer.h>
 26 #include <asm/div64.h>
 27 #include "cifsfs.h"
 28 #include "cifspdu.h"
 29 #include "cifsglob.h"
 30 #include "cifsproto.h"
 31 #include "cifs_debug.h"
 32 #include "cifs_fs_sb.h"
 33 #include "cifs_unicode.h"
 34 #include "fscache.h"
 35 
 36 
 37 static void cifs_set_ops(struct inode *inode)
 38 {
 39         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 40 
 41         switch (inode->i_mode & S_IFMT) {
 42         case S_IFREG:
 43                 inode->i_op = &cifs_file_inode_ops;
 44                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
 45                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 46                                 inode->i_fop = &cifs_file_direct_nobrl_ops;
 47                         else
 48                                 inode->i_fop = &cifs_file_direct_ops;
 49                 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
 50                         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 51                                 inode->i_fop = &cifs_file_strict_nobrl_ops;
 52                         else
 53                                 inode->i_fop = &cifs_file_strict_ops;
 54                 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 55                         inode->i_fop = &cifs_file_nobrl_ops;
 56                 else { /* not direct, send byte range locks */
 57                         inode->i_fop = &cifs_file_ops;
 58                 }
 59 
 60                 /* check if server can support readpages */
 61                 if (cifs_sb_master_tcon(cifs_sb)->ses->server->maxBuf <
 62                                 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
 63                         inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
 64                 else
 65                         inode->i_data.a_ops = &cifs_addr_ops;
 66                 break;
 67         case S_IFDIR:
 68 #ifdef CONFIG_CIFS_DFS_UPCALL
 69                 if (IS_AUTOMOUNT(inode)) {
 70                         inode->i_op = &cifs_dfs_referral_inode_operations;
 71                 } else {
 72 #else /* NO DFS support, treat as a directory */
 73                 {
 74 #endif
 75                         inode->i_op = &cifs_dir_inode_ops;
 76                         inode->i_fop = &cifs_dir_ops;
 77                 }
 78                 break;
 79         case S_IFLNK:
 80                 inode->i_op = &cifs_symlink_inode_ops;
 81                 break;
 82         default:
 83                 init_special_inode(inode, inode->i_mode, inode->i_rdev);
 84                 break;
 85         }
 86 }
 87 
 88 /* check inode attributes against fattr. If they don't match, tag the
 89  * inode for cache invalidation
 90  */
 91 static void
 92 cifs_revalidate_cache(struct inode *inode, struct cifs_fattr *fattr)
 93 {
 94         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
 95 
 96         cifs_dbg(FYI, "%s: revalidating inode %llu\n",
 97                  __func__, cifs_i->uniqueid);
 98 
 99         if (inode->i_state & I_NEW) {
100                 cifs_dbg(FYI, "%s: inode %llu is new\n",
101                          __func__, cifs_i->uniqueid);
102                 return;
103         }
104 
105         /* don't bother with revalidation if we have an oplock */
106         if (CIFS_CACHE_READ(cifs_i)) {
107                 cifs_dbg(FYI, "%s: inode %llu is oplocked\n",
108                          __func__, cifs_i->uniqueid);
109                 return;
110         }
111 
112          /* revalidate if mtime or size have changed */
113         if (timespec_equal(&inode->i_mtime, &fattr->cf_mtime) &&
114             cifs_i->server_eof == fattr->cf_eof) {
115                 cifs_dbg(FYI, "%s: inode %llu is unchanged\n",
116                          __func__, cifs_i->uniqueid);
117                 return;
118         }
119 
120         cifs_dbg(FYI, "%s: invalidating inode %llu mapping\n",
121                  __func__, cifs_i->uniqueid);
122         set_bit(CIFS_INO_INVALID_MAPPING, &cifs_i->flags);
123 }
124 
125 /*
126  * copy nlink to the inode, unless it wasn't provided.  Provide
127  * sane values if we don't have an existing one and none was provided
128  */
129 static void
130 cifs_nlink_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
131 {
132         /*
133          * if we're in a situation where we can't trust what we
134          * got from the server (readdir, some non-unix cases)
135          * fake reasonable values
136          */
137         if (fattr->cf_flags & CIFS_FATTR_UNKNOWN_NLINK) {
138                 /* only provide fake values on a new inode */
139                 if (inode->i_state & I_NEW) {
140                         if (fattr->cf_cifsattrs & ATTR_DIRECTORY)
141                                 set_nlink(inode, 2);
142                         else
143                                 set_nlink(inode, 1);
144                 }
145                 return;
146         }
147 
148         /* we trust the server, so update it */
149         set_nlink(inode, fattr->cf_nlink);
150 }
151 
152 /* populate an inode with info from a cifs_fattr struct */
153 void
154 cifs_fattr_to_inode(struct inode *inode, struct cifs_fattr *fattr)
155 {
156         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
157         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
158 
159         cifs_revalidate_cache(inode, fattr);
160 
161         spin_lock(&inode->i_lock);
162         inode->i_atime = fattr->cf_atime;
163         inode->i_mtime = fattr->cf_mtime;
164         inode->i_ctime = fattr->cf_ctime;
165         inode->i_rdev = fattr->cf_rdev;
166         cifs_nlink_fattr_to_inode(inode, fattr);
167         inode->i_uid = fattr->cf_uid;
168         inode->i_gid = fattr->cf_gid;
169 
170         /* if dynperm is set, don't clobber existing mode */
171         if (inode->i_state & I_NEW ||
172             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM))
173                 inode->i_mode = fattr->cf_mode;
174 
175         cifs_i->cifsAttrs = fattr->cf_cifsattrs;
176 
177         if (fattr->cf_flags & CIFS_FATTR_NEED_REVAL)
178                 cifs_i->time = 0;
179         else
180                 cifs_i->time = jiffies;
181 
182         if (fattr->cf_flags & CIFS_FATTR_DELETE_PENDING)
183                 set_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
184         else
185                 clear_bit(CIFS_INO_DELETE_PENDING, &cifs_i->flags);
186 
187         cifs_i->server_eof = fattr->cf_eof;
188         /*
189          * Can't safely change the file size here if the client is writing to
190          * it due to potential races.
191          */
192         if (is_size_safe_to_change(cifs_i, fattr->cf_eof)) {
193                 i_size_write(inode, fattr->cf_eof);
194 
195                 /*
196                  * i_blocks is not related to (i_size / i_blksize),
197                  * but instead 512 byte (2**9) size is required for
198                  * calculating num blocks.
199                  */
200                 inode->i_blocks = (512 - 1 + fattr->cf_bytes) >> 9;
201         }
202         spin_unlock(&inode->i_lock);
203 
204         if (fattr->cf_flags & CIFS_FATTR_DFS_REFERRAL)
205                 inode->i_flags |= S_AUTOMOUNT;
206         if (inode->i_state & I_NEW)
207                 cifs_set_ops(inode);
208 }
209 
210 void
211 cifs_fill_uniqueid(struct super_block *sb, struct cifs_fattr *fattr)
212 {
213         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
214 
215         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
216                 return;
217 
218         fattr->cf_uniqueid = iunique(sb, ROOT_I);
219 }
220 
221 /* Fill a cifs_fattr struct with info from FILE_UNIX_BASIC_INFO. */
222 void
223 cifs_unix_basic_to_fattr(struct cifs_fattr *fattr, FILE_UNIX_BASIC_INFO *info,
224                          struct cifs_sb_info *cifs_sb)
225 {
226         memset(fattr, 0, sizeof(*fattr));
227         fattr->cf_uniqueid = le64_to_cpu(info->UniqueId);
228         fattr->cf_bytes = le64_to_cpu(info->NumOfBytes);
229         fattr->cf_eof = le64_to_cpu(info->EndOfFile);
230 
231         fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
232         fattr->cf_mtime = cifs_NTtimeToUnix(info->LastModificationTime);
233         fattr->cf_ctime = cifs_NTtimeToUnix(info->LastStatusChange);
234         fattr->cf_mode = le64_to_cpu(info->Permissions);
235 
236         /*
237          * Since we set the inode type below we need to mask off
238          * to avoid strange results if bits set above.
239          */
240         fattr->cf_mode &= ~S_IFMT;
241         switch (le32_to_cpu(info->Type)) {
242         case UNIX_FILE:
243                 fattr->cf_mode |= S_IFREG;
244                 fattr->cf_dtype = DT_REG;
245                 break;
246         case UNIX_SYMLINK:
247                 fattr->cf_mode |= S_IFLNK;
248                 fattr->cf_dtype = DT_LNK;
249                 break;
250         case UNIX_DIR:
251                 fattr->cf_mode |= S_IFDIR;
252                 fattr->cf_dtype = DT_DIR;
253                 break;
254         case UNIX_CHARDEV:
255                 fattr->cf_mode |= S_IFCHR;
256                 fattr->cf_dtype = DT_CHR;
257                 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
258                                        le64_to_cpu(info->DevMinor) & MINORMASK);
259                 break;
260         case UNIX_BLOCKDEV:
261                 fattr->cf_mode |= S_IFBLK;
262                 fattr->cf_dtype = DT_BLK;
263                 fattr->cf_rdev = MKDEV(le64_to_cpu(info->DevMajor),
264                                        le64_to_cpu(info->DevMinor) & MINORMASK);
265                 break;
266         case UNIX_FIFO:
267                 fattr->cf_mode |= S_IFIFO;
268                 fattr->cf_dtype = DT_FIFO;
269                 break;
270         case UNIX_SOCKET:
271                 fattr->cf_mode |= S_IFSOCK;
272                 fattr->cf_dtype = DT_SOCK;
273                 break;
274         default:
275                 /* safest to call it a file if we do not know */
276                 fattr->cf_mode |= S_IFREG;
277                 fattr->cf_dtype = DT_REG;
278                 cifs_dbg(FYI, "unknown type %d\n", le32_to_cpu(info->Type));
279                 break;
280         }
281 
282         fattr->cf_uid = cifs_sb->mnt_uid;
283         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)) {
284                 u64 id = le64_to_cpu(info->Uid);
285                 if (id < ((uid_t)-1)) {
286                         kuid_t uid = make_kuid(&init_user_ns, id);
287                         if (uid_valid(uid))
288                                 fattr->cf_uid = uid;
289                 }
290         }
291         
292         fattr->cf_gid = cifs_sb->mnt_gid;
293         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)) {
294                 u64 id = le64_to_cpu(info->Gid);
295                 if (id < ((gid_t)-1)) {
296                         kgid_t gid = make_kgid(&init_user_ns, id);
297                         if (gid_valid(gid))
298                                 fattr->cf_gid = gid;
299                 }
300         }
301 
302         fattr->cf_nlink = le64_to_cpu(info->Nlinks);
303 }
304 
305 /*
306  * Fill a cifs_fattr struct with fake inode info.
307  *
308  * Needed to setup cifs_fattr data for the directory which is the
309  * junction to the new submount (ie to setup the fake directory
310  * which represents a DFS referral).
311  */
312 static void
313 cifs_create_dfs_fattr(struct cifs_fattr *fattr, struct super_block *sb)
314 {
315         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
316 
317         cifs_dbg(FYI, "creating fake fattr for DFS referral\n");
318 
319         memset(fattr, 0, sizeof(*fattr));
320         fattr->cf_mode = S_IFDIR | S_IXUGO | S_IRWXU;
321         fattr->cf_uid = cifs_sb->mnt_uid;
322         fattr->cf_gid = cifs_sb->mnt_gid;
323         fattr->cf_atime = CURRENT_TIME;
324         fattr->cf_ctime = CURRENT_TIME;
325         fattr->cf_mtime = CURRENT_TIME;
326         fattr->cf_nlink = 2;
327         fattr->cf_flags |= CIFS_FATTR_DFS_REFERRAL;
328 }
329 
330 static int
331 cifs_get_file_info_unix(struct file *filp)
332 {
333         int rc;
334         unsigned int xid;
335         FILE_UNIX_BASIC_INFO find_data;
336         struct cifs_fattr fattr;
337         struct inode *inode = file_inode(filp);
338         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
339         struct cifsFileInfo *cfile = filp->private_data;
340         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
341 
342         xid = get_xid();
343         rc = CIFSSMBUnixQFileInfo(xid, tcon, cfile->fid.netfid, &find_data);
344         if (!rc) {
345                 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
346         } else if (rc == -EREMOTE) {
347                 cifs_create_dfs_fattr(&fattr, inode->i_sb);
348                 rc = 0;
349         }
350 
351         cifs_fattr_to_inode(inode, &fattr);
352         free_xid(xid);
353         return rc;
354 }
355 
356 int cifs_get_inode_info_unix(struct inode **pinode,
357                              const unsigned char *full_path,
358                              struct super_block *sb, unsigned int xid)
359 {
360         int rc;
361         FILE_UNIX_BASIC_INFO find_data;
362         struct cifs_fattr fattr;
363         struct cifs_tcon *tcon;
364         struct tcon_link *tlink;
365         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
366 
367         cifs_dbg(FYI, "Getting info on %s\n", full_path);
368 
369         tlink = cifs_sb_tlink(cifs_sb);
370         if (IS_ERR(tlink))
371                 return PTR_ERR(tlink);
372         tcon = tlink_tcon(tlink);
373 
374         /* could have done a find first instead but this returns more info */
375         rc = CIFSSMBUnixQPathInfo(xid, tcon, full_path, &find_data,
376                                   cifs_sb->local_nls, cifs_remap(cifs_sb));
377         cifs_put_tlink(tlink);
378 
379         if (!rc) {
380                 cifs_unix_basic_to_fattr(&fattr, &find_data, cifs_sb);
381         } else if (rc == -EREMOTE) {
382                 cifs_create_dfs_fattr(&fattr, sb);
383                 rc = 0;
384         } else {
385                 return rc;
386         }
387 
388         /* check for Minshall+French symlinks */
389         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
390                 int tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
391                                              full_path);
392                 if (tmprc)
393                         cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
394         }
395 
396         if (*pinode == NULL) {
397                 /* get new inode */
398                 cifs_fill_uniqueid(sb, &fattr);
399                 *pinode = cifs_iget(sb, &fattr);
400                 if (!*pinode)
401                         rc = -ENOMEM;
402         } else {
403                 /* we already have inode, update it */
404 
405                 /* if uniqueid is different, return error */
406                 if (unlikely(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM &&
407                     CIFS_I(*pinode)->uniqueid != fattr.cf_uniqueid)) {
408                         rc = -ESTALE;
409                         goto cgiiu_exit;
410                 }
411 
412                 /* if filetype is different, return error */
413                 if (unlikely(((*pinode)->i_mode & S_IFMT) !=
414                     (fattr.cf_mode & S_IFMT))) {
415                         rc = -ESTALE;
416                         goto cgiiu_exit;
417                 }
418 
419                 cifs_fattr_to_inode(*pinode, &fattr);
420         }
421 
422 cgiiu_exit:
423         return rc;
424 }
425 
426 static int
427 cifs_sfu_type(struct cifs_fattr *fattr, const char *path,
428               struct cifs_sb_info *cifs_sb, unsigned int xid)
429 {
430         int rc;
431         __u32 oplock;
432         struct tcon_link *tlink;
433         struct cifs_tcon *tcon;
434         struct cifs_fid fid;
435         struct cifs_open_parms oparms;
436         struct cifs_io_parms io_parms;
437         char buf[24];
438         unsigned int bytes_read;
439         char *pbuf;
440         int buf_type = CIFS_NO_BUFFER;
441 
442         pbuf = buf;
443 
444         fattr->cf_mode &= ~S_IFMT;
445 
446         if (fattr->cf_eof == 0) {
447                 fattr->cf_mode |= S_IFIFO;
448                 fattr->cf_dtype = DT_FIFO;
449                 return 0;
450         } else if (fattr->cf_eof < 8) {
451                 fattr->cf_mode |= S_IFREG;
452                 fattr->cf_dtype = DT_REG;
453                 return -EINVAL;  /* EOPNOTSUPP? */
454         }
455 
456         tlink = cifs_sb_tlink(cifs_sb);
457         if (IS_ERR(tlink))
458                 return PTR_ERR(tlink);
459         tcon = tlink_tcon(tlink);
460 
461         oparms.tcon = tcon;
462         oparms.cifs_sb = cifs_sb;
463         oparms.desired_access = GENERIC_READ;
464         oparms.create_options = CREATE_NOT_DIR;
465         oparms.disposition = FILE_OPEN;
466         oparms.path = path;
467         oparms.fid = &fid;
468         oparms.reconnect = false;
469 
470         if (tcon->ses->server->oplocks)
471                 oplock = REQ_OPLOCK;
472         else
473                 oplock = 0;
474         rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, NULL);
475         if (rc) {
476                 cifs_dbg(FYI, "check sfu type of %s, open rc = %d\n", path, rc);
477                 cifs_put_tlink(tlink);
478                 return rc;
479         }
480 
481         /* Read header */
482         io_parms.netfid = fid.netfid;
483         io_parms.pid = current->tgid;
484         io_parms.tcon = tcon;
485         io_parms.offset = 0;
486         io_parms.length = 24;
487 
488         rc = tcon->ses->server->ops->sync_read(xid, &fid, &io_parms,
489                                         &bytes_read, &pbuf, &buf_type);
490         if ((rc == 0) && (bytes_read >= 8)) {
491                 if (memcmp("IntxBLK", pbuf, 8) == 0) {
492                         cifs_dbg(FYI, "Block device\n");
493                         fattr->cf_mode |= S_IFBLK;
494                         fattr->cf_dtype = DT_BLK;
495                         if (bytes_read == 24) {
496                                 /* we have enough to decode dev num */
497                                 __u64 mjr; /* major */
498                                 __u64 mnr; /* minor */
499                                 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
500                                 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
501                                 fattr->cf_rdev = MKDEV(mjr, mnr);
502                         }
503                 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
504                         cifs_dbg(FYI, "Char device\n");
505                         fattr->cf_mode |= S_IFCHR;
506                         fattr->cf_dtype = DT_CHR;
507                         if (bytes_read == 24) {
508                                 /* we have enough to decode dev num */
509                                 __u64 mjr; /* major */
510                                 __u64 mnr; /* minor */
511                                 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
512                                 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
513                                 fattr->cf_rdev = MKDEV(mjr, mnr);
514                         }
515                 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
516                         cifs_dbg(FYI, "Symlink\n");
517                         fattr->cf_mode |= S_IFLNK;
518                         fattr->cf_dtype = DT_LNK;
519                 } else {
520                         fattr->cf_mode |= S_IFREG; /* file? */
521                         fattr->cf_dtype = DT_REG;
522                         rc = -EOPNOTSUPP;
523                 }
524         } else {
525                 fattr->cf_mode |= S_IFREG; /* then it is a file */
526                 fattr->cf_dtype = DT_REG;
527                 rc = -EOPNOTSUPP; /* or some unknown SFU type */
528         }
529 
530         tcon->ses->server->ops->close(xid, tcon, &fid);
531         cifs_put_tlink(tlink);
532         return rc;
533 }
534 
535 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID)  /* SETFILEBITS valid bits */
536 
537 /*
538  * Fetch mode bits as provided by SFU.
539  *
540  * FIXME: Doesn't this clobber the type bit we got from cifs_sfu_type ?
541  */
542 static int cifs_sfu_mode(struct cifs_fattr *fattr, const unsigned char *path,
543                          struct cifs_sb_info *cifs_sb, unsigned int xid)
544 {
545 #ifdef CONFIG_CIFS_XATTR
546         ssize_t rc;
547         char ea_value[4];
548         __u32 mode;
549         struct tcon_link *tlink;
550         struct cifs_tcon *tcon;
551 
552         tlink = cifs_sb_tlink(cifs_sb);
553         if (IS_ERR(tlink))
554                 return PTR_ERR(tlink);
555         tcon = tlink_tcon(tlink);
556 
557         if (tcon->ses->server->ops->query_all_EAs == NULL) {
558                 cifs_put_tlink(tlink);
559                 return -EOPNOTSUPP;
560         }
561 
562         rc = tcon->ses->server->ops->query_all_EAs(xid, tcon, path,
563                         "SETFILEBITS", ea_value, 4 /* size of buf */,
564                         cifs_sb->local_nls,
565                         cifs_remap(cifs_sb));
566         cifs_put_tlink(tlink);
567         if (rc < 0)
568                 return (int)rc;
569         else if (rc > 3) {
570                 mode = le32_to_cpu(*((__le32 *)ea_value));
571                 fattr->cf_mode &= ~SFBITS_MASK;
572                 cifs_dbg(FYI, "special bits 0%o org mode 0%o\n",
573                          mode, fattr->cf_mode);
574                 fattr->cf_mode = (mode & SFBITS_MASK) | fattr->cf_mode;
575                 cifs_dbg(FYI, "special mode bits 0%o\n", mode);
576         }
577 
578         return 0;
579 #else
580         return -EOPNOTSUPP;
581 #endif
582 }
583 
584 /* Fill a cifs_fattr struct with info from FILE_ALL_INFO */
585 static void
586 cifs_all_info_to_fattr(struct cifs_fattr *fattr, FILE_ALL_INFO *info,
587                        struct cifs_sb_info *cifs_sb, bool adjust_tz,
588                        bool symlink)
589 {
590         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
591 
592         memset(fattr, 0, sizeof(*fattr));
593         fattr->cf_cifsattrs = le32_to_cpu(info->Attributes);
594         if (info->DeletePending)
595                 fattr->cf_flags |= CIFS_FATTR_DELETE_PENDING;
596 
597         if (info->LastAccessTime)
598                 fattr->cf_atime = cifs_NTtimeToUnix(info->LastAccessTime);
599         else
600                 fattr->cf_atime = CURRENT_TIME;
601 
602         fattr->cf_ctime = cifs_NTtimeToUnix(info->ChangeTime);
603         fattr->cf_mtime = cifs_NTtimeToUnix(info->LastWriteTime);
604 
605         if (adjust_tz) {
606                 fattr->cf_ctime.tv_sec += tcon->ses->server->timeAdj;
607                 fattr->cf_mtime.tv_sec += tcon->ses->server->timeAdj;
608         }
609 
610         fattr->cf_eof = le64_to_cpu(info->EndOfFile);
611         fattr->cf_bytes = le64_to_cpu(info->AllocationSize);
612         fattr->cf_createtime = le64_to_cpu(info->CreationTime);
613 
614         fattr->cf_nlink = le32_to_cpu(info->NumberOfLinks);
615 
616         if (symlink) {
617                 fattr->cf_mode = S_IFLNK;
618                 fattr->cf_dtype = DT_LNK;
619         } else if (fattr->cf_cifsattrs & ATTR_DIRECTORY) {
620                 fattr->cf_mode = S_IFDIR | cifs_sb->mnt_dir_mode;
621                 fattr->cf_dtype = DT_DIR;
622                 /*
623                  * Server can return wrong NumberOfLinks value for directories
624                  * when Unix extensions are disabled - fake it.
625                  */
626                 if (!tcon->unix_ext)
627                         fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
628         } else {
629                 fattr->cf_mode = S_IFREG | cifs_sb->mnt_file_mode;
630                 fattr->cf_dtype = DT_REG;
631 
632                 /* clear write bits if ATTR_READONLY is set */
633                 if (fattr->cf_cifsattrs & ATTR_READONLY)
634                         fattr->cf_mode &= ~(S_IWUGO);
635 
636                 /*
637                  * Don't accept zero nlink from non-unix servers unless
638                  * delete is pending.  Instead mark it as unknown.
639                  */
640                 if ((fattr->cf_nlink < 1) && !tcon->unix_ext &&
641                     !info->DeletePending) {
642                         cifs_dbg(1, "bogus file nlink value %u\n",
643                                 fattr->cf_nlink);
644                         fattr->cf_flags |= CIFS_FATTR_UNKNOWN_NLINK;
645                 }
646         }
647 
648         fattr->cf_uid = cifs_sb->mnt_uid;
649         fattr->cf_gid = cifs_sb->mnt_gid;
650 }
651 
652 static int
653 cifs_get_file_info(struct file *filp)
654 {
655         int rc;
656         unsigned int xid;
657         FILE_ALL_INFO find_data;
658         struct cifs_fattr fattr;
659         struct inode *inode = file_inode(filp);
660         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
661         struct cifsFileInfo *cfile = filp->private_data;
662         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
663         struct TCP_Server_Info *server = tcon->ses->server;
664 
665         if (!server->ops->query_file_info)
666                 return -ENOSYS;
667 
668         xid = get_xid();
669         rc = server->ops->query_file_info(xid, tcon, &cfile->fid, &find_data);
670         switch (rc) {
671         case 0:
672                 cifs_all_info_to_fattr(&fattr, &find_data, cifs_sb, false,
673                                        false);
674                 break;
675         case -EREMOTE:
676                 cifs_create_dfs_fattr(&fattr, inode->i_sb);
677                 rc = 0;
678                 break;
679         case -EOPNOTSUPP:
680         case -EINVAL:
681                 /*
682                  * FIXME: legacy server -- fall back to path-based call?
683                  * for now, just skip revalidating and mark inode for
684                  * immediate reval.
685                  */
686                 rc = 0;
687                 CIFS_I(inode)->time = 0;
688         default:
689                 goto cgfi_exit;
690         }
691 
692         /*
693          * don't bother with SFU junk here -- just mark inode as needing
694          * revalidation.
695          */
696         fattr.cf_uniqueid = CIFS_I(inode)->uniqueid;
697         fattr.cf_flags |= CIFS_FATTR_NEED_REVAL;
698         cifs_fattr_to_inode(inode, &fattr);
699 cgfi_exit:
700         free_xid(xid);
701         return rc;
702 }
703 
704 int
705 cifs_get_inode_info(struct inode **inode, const char *full_path,
706                     FILE_ALL_INFO *data, struct super_block *sb, int xid,
707                     const struct cifs_fid *fid)
708 {
709         bool validinum = false;
710         __u16 srchflgs;
711         int rc = 0, tmprc = ENOSYS;
712         struct cifs_tcon *tcon;
713         struct TCP_Server_Info *server;
714         struct tcon_link *tlink;
715         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
716         char *buf = NULL;
717         bool adjust_tz = false;
718         struct cifs_fattr fattr;
719         struct cifs_search_info *srchinf = NULL;
720         bool symlink = false;
721 
722         tlink = cifs_sb_tlink(cifs_sb);
723         if (IS_ERR(tlink))
724                 return PTR_ERR(tlink);
725         tcon = tlink_tcon(tlink);
726         server = tcon->ses->server;
727 
728         cifs_dbg(FYI, "Getting info on %s\n", full_path);
729 
730         if ((data == NULL) && (*inode != NULL)) {
731                 if (CIFS_CACHE_READ(CIFS_I(*inode))) {
732                         cifs_dbg(FYI, "No need to revalidate cached inode sizes\n");
733                         goto cgii_exit;
734                 }
735         }
736 
737         /* if inode info is not passed, get it from server */
738         if (data == NULL) {
739                 if (!server->ops->query_path_info) {
740                         rc = -ENOSYS;
741                         goto cgii_exit;
742                 }
743                 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
744                 if (buf == NULL) {
745                         rc = -ENOMEM;
746                         goto cgii_exit;
747                 }
748                 data = (FILE_ALL_INFO *)buf;
749                 rc = server->ops->query_path_info(xid, tcon, cifs_sb, full_path,
750                                                   data, &adjust_tz, &symlink);
751         }
752 
753         if (!rc) {
754                 cifs_all_info_to_fattr(&fattr, data, cifs_sb, adjust_tz,
755                                        symlink);
756         } else if (rc == -EREMOTE) {
757                 cifs_create_dfs_fattr(&fattr, sb);
758                 rc = 0;
759         } else if (rc == -EACCES && backup_cred(cifs_sb)) {
760                         srchinf = kzalloc(sizeof(struct cifs_search_info),
761                                                 GFP_KERNEL);
762                         if (srchinf == NULL) {
763                                 rc = -ENOMEM;
764                                 goto cgii_exit;
765                         }
766 
767                         srchinf->endOfSearch = false;
768                         srchinf->info_level = SMB_FIND_FILE_ID_FULL_DIR_INFO;
769 
770                         srchflgs = CIFS_SEARCH_CLOSE_ALWAYS |
771                                         CIFS_SEARCH_CLOSE_AT_END |
772                                         CIFS_SEARCH_BACKUP_SEARCH;
773 
774                         rc = CIFSFindFirst(xid, tcon, full_path,
775                                 cifs_sb, NULL, srchflgs, srchinf, false);
776                         if (!rc) {
777                                 data =
778                                 (FILE_ALL_INFO *)srchinf->srch_entries_start;
779 
780                                 cifs_dir_info_to_fattr(&fattr,
781                                 (FILE_DIRECTORY_INFO *)data, cifs_sb);
782                                 fattr.cf_uniqueid = le64_to_cpu(
783                                 ((SEARCH_ID_FULL_DIR_INFO *)data)->UniqueId);
784                                 validinum = true;
785 
786                                 cifs_buf_release(srchinf->ntwrk_buf_start);
787                         }
788                         kfree(srchinf);
789                         if (rc)
790                                 goto cgii_exit;
791         } else
792                 goto cgii_exit;
793 
794         /*
795          * If an inode wasn't passed in, then get the inode number
796          *
797          * Is an i_ino of zero legal? Can we use that to check if the server
798          * supports returning inode numbers?  Are there other sanity checks we
799          * can use to ensure that the server is really filling in that field?
800          */
801         if (*inode == NULL) {
802                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
803                         if (validinum == false) {
804                                 if (server->ops->get_srv_inum)
805                                         tmprc = server->ops->get_srv_inum(xid,
806                                                 tcon, cifs_sb, full_path,
807                                                 &fattr.cf_uniqueid, data);
808                                 if (tmprc) {
809                                         cifs_dbg(FYI, "GetSrvInodeNum rc %d\n",
810                                                  tmprc);
811                                         fattr.cf_uniqueid = iunique(sb, ROOT_I);
812                                         cifs_autodisable_serverino(cifs_sb);
813                                 }
814                         }
815                 } else
816                         fattr.cf_uniqueid = iunique(sb, ROOT_I);
817         } else
818                 fattr.cf_uniqueid = CIFS_I(*inode)->uniqueid;
819 
820         /* query for SFU type info if supported and needed */
821         if (fattr.cf_cifsattrs & ATTR_SYSTEM &&
822             cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
823                 tmprc = cifs_sfu_type(&fattr, full_path, cifs_sb, xid);
824                 if (tmprc)
825                         cifs_dbg(FYI, "cifs_sfu_type failed: %d\n", tmprc);
826         }
827 
828 #ifdef CONFIG_CIFS_ACL
829         /* fill in 0777 bits from ACL */
830         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
831                 rc = cifs_acl_to_fattr(cifs_sb, &fattr, *inode, full_path, fid);
832                 if (rc) {
833                         cifs_dbg(FYI, "%s: Getting ACL failed with error: %d\n",
834                                  __func__, rc);
835                         goto cgii_exit;
836                 }
837         }
838 #endif /* CONFIG_CIFS_ACL */
839 
840         /* fill in remaining high mode bits e.g. SUID, VTX */
841         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
842                 cifs_sfu_mode(&fattr, full_path, cifs_sb, xid);
843 
844         /* check for Minshall+French symlinks */
845         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MF_SYMLINKS) {
846                 tmprc = check_mf_symlink(xid, tcon, cifs_sb, &fattr,
847                                          full_path);
848                 if (tmprc)
849                         cifs_dbg(FYI, "check_mf_symlink: %d\n", tmprc);
850         }
851 
852         if (!*inode) {
853                 *inode = cifs_iget(sb, &fattr);
854                 if (!*inode)
855                         rc = -ENOMEM;
856         } else {
857                 /* we already have inode, update it */
858 
859                 /* if filetype is different, return error */
860                 if (unlikely(((*inode)->i_mode & S_IFMT) !=
861                     (fattr.cf_mode & S_IFMT))) {
862                         rc = -ESTALE;
863                         goto cgii_exit;
864                 }
865 
866                 cifs_fattr_to_inode(*inode, &fattr);
867         }
868 
869 cgii_exit:
870         kfree(buf);
871         cifs_put_tlink(tlink);
872         return rc;
873 }
874 
875 static const struct inode_operations cifs_ipc_inode_ops = {
876         .lookup = cifs_lookup,
877 };
878 
879 static int
880 cifs_find_inode(struct inode *inode, void *opaque)
881 {
882         struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
883 
884         /* don't match inode with different uniqueid */
885         if (CIFS_I(inode)->uniqueid != fattr->cf_uniqueid)
886                 return 0;
887 
888         /* use createtime like an i_generation field */
889         if (CIFS_I(inode)->createtime != fattr->cf_createtime)
890                 return 0;
891 
892         /* don't match inode of different type */
893         if ((inode->i_mode & S_IFMT) != (fattr->cf_mode & S_IFMT))
894                 return 0;
895 
896         /* if it's not a directory or has no dentries, then flag it */
897         if (S_ISDIR(inode->i_mode) && !hlist_empty(&inode->i_dentry))
898                 fattr->cf_flags |= CIFS_FATTR_INO_COLLISION;
899 
900         return 1;
901 }
902 
903 static int
904 cifs_init_inode(struct inode *inode, void *opaque)
905 {
906         struct cifs_fattr *fattr = (struct cifs_fattr *) opaque;
907 
908         CIFS_I(inode)->uniqueid = fattr->cf_uniqueid;
909         CIFS_I(inode)->createtime = fattr->cf_createtime;
910         return 0;
911 }
912 
913 /*
914  * walk dentry list for an inode and report whether it has aliases that
915  * are hashed. We use this to determine if a directory inode can actually
916  * be used.
917  */
918 static bool
919 inode_has_hashed_dentries(struct inode *inode)
920 {
921         struct dentry *dentry;
922 
923         spin_lock(&inode->i_lock);
924         hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
925                 if (!d_unhashed(dentry) || IS_ROOT(dentry)) {
926                         spin_unlock(&inode->i_lock);
927                         return true;
928                 }
929         }
930         spin_unlock(&inode->i_lock);
931         return false;
932 }
933 
934 /* Given fattrs, get a corresponding inode */
935 struct inode *
936 cifs_iget(struct super_block *sb, struct cifs_fattr *fattr)
937 {
938         unsigned long hash;
939         struct inode *inode;
940 
941 retry_iget5_locked:
942         cifs_dbg(FYI, "looking for uniqueid=%llu\n", fattr->cf_uniqueid);
943 
944         /* hash down to 32-bits on 32-bit arch */
945         hash = cifs_uniqueid_to_ino_t(fattr->cf_uniqueid);
946 
947         inode = iget5_locked(sb, hash, cifs_find_inode, cifs_init_inode, fattr);
948         if (inode) {
949                 /* was there a potentially problematic inode collision? */
950                 if (fattr->cf_flags & CIFS_FATTR_INO_COLLISION) {
951                         fattr->cf_flags &= ~CIFS_FATTR_INO_COLLISION;
952 
953                         if (inode_has_hashed_dentries(inode)) {
954                                 cifs_autodisable_serverino(CIFS_SB(sb));
955                                 iput(inode);
956                                 fattr->cf_uniqueid = iunique(sb, ROOT_I);
957                                 goto retry_iget5_locked;
958                         }
959                 }
960 
961                 cifs_fattr_to_inode(inode, fattr);
962                 if (sb->s_flags & MS_NOATIME)
963                         inode->i_flags |= S_NOATIME | S_NOCMTIME;
964                 if (inode->i_state & I_NEW) {
965                         inode->i_ino = hash;
966 #ifdef CONFIG_CIFS_FSCACHE
967                         /* initialize per-inode cache cookie pointer */
968                         CIFS_I(inode)->fscache = NULL;
969 #endif
970                         unlock_new_inode(inode);
971                 }
972         }
973 
974         return inode;
975 }
976 
977 /* gets root inode */
978 struct inode *cifs_root_iget(struct super_block *sb)
979 {
980         unsigned int xid;
981         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
982         struct inode *inode = NULL;
983         long rc;
984         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
985         char *path = NULL;
986         int len;
987 
988         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
989             && cifs_sb->prepath) {
990                 len = strlen(cifs_sb->prepath);
991                 path = kzalloc(len + 2 /* leading sep + null */, GFP_KERNEL);
992                 if (path == NULL)
993                         return ERR_PTR(-ENOMEM);
994                 path[0] = '/';
995                 memcpy(path+1, cifs_sb->prepath, len);
996         } else {
997                 path = kstrdup("", GFP_KERNEL);
998                 if (path == NULL)
999                         return ERR_PTR(-ENOMEM);
1000         }
1001 
1002         xid = get_xid();
1003         if (tcon->unix_ext) {
1004                 rc = cifs_get_inode_info_unix(&inode, path, sb, xid);
1005                 /* some servers mistakenly claim POSIX support */
1006                 if (rc != -EOPNOTSUPP)
1007                         goto iget_no_retry;
1008                 cifs_dbg(VFS, "server does not support POSIX extensions");
1009                 tcon->unix_ext = false;
1010         }
1011 
1012         convert_delimiter(path, CIFS_DIR_SEP(cifs_sb));
1013         rc = cifs_get_inode_info(&inode, path, NULL, sb, xid, NULL);
1014 
1015 iget_no_retry:
1016         if (!inode) {
1017                 inode = ERR_PTR(rc);
1018                 goto out;
1019         }
1020 
1021 #ifdef CONFIG_CIFS_FSCACHE
1022         /* populate tcon->resource_id */
1023         tcon->resource_id = CIFS_I(inode)->uniqueid;
1024 #endif
1025 
1026         if (rc && tcon->ipc) {
1027                 cifs_dbg(FYI, "ipc connection - fake read inode\n");
1028                 spin_lock(&inode->i_lock);
1029                 inode->i_mode |= S_IFDIR;
1030                 set_nlink(inode, 2);
1031                 inode->i_op = &cifs_ipc_inode_ops;
1032                 inode->i_fop = &simple_dir_operations;
1033                 inode->i_uid = cifs_sb->mnt_uid;
1034                 inode->i_gid = cifs_sb->mnt_gid;
1035                 spin_unlock(&inode->i_lock);
1036         } else if (rc) {
1037                 iget_failed(inode);
1038                 inode = ERR_PTR(rc);
1039         }
1040 
1041 out:
1042         kfree(path);
1043         /* can not call macro free_xid here since in a void func
1044          * TODO: This is no longer true
1045          */
1046         _free_xid(xid);
1047         return inode;
1048 }
1049 
1050 int
1051 cifs_set_file_info(struct inode *inode, struct iattr *attrs, unsigned int xid,
1052                    char *full_path, __u32 dosattr)
1053 {
1054         bool set_time = false;
1055         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1056         struct TCP_Server_Info *server;
1057         FILE_BASIC_INFO info_buf;
1058 
1059         if (attrs == NULL)
1060                 return -EINVAL;
1061 
1062         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
1063         if (!server->ops->set_file_info)
1064                 return -ENOSYS;
1065 
1066         if (attrs->ia_valid & ATTR_ATIME) {
1067                 set_time = true;
1068                 info_buf.LastAccessTime =
1069                         cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1070         } else
1071                 info_buf.LastAccessTime = 0;
1072 
1073         if (attrs->ia_valid & ATTR_MTIME) {
1074                 set_time = true;
1075                 info_buf.LastWriteTime =
1076                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1077         } else
1078                 info_buf.LastWriteTime = 0;
1079 
1080         /*
1081          * Samba throws this field away, but windows may actually use it.
1082          * Do not set ctime unless other time stamps are changed explicitly
1083          * (i.e. by utimes()) since we would then have a mix of client and
1084          * server times.
1085          */
1086         if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1087                 cifs_dbg(FYI, "CIFS - CTIME changed\n");
1088                 info_buf.ChangeTime =
1089                     cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1090         } else
1091                 info_buf.ChangeTime = 0;
1092 
1093         info_buf.CreationTime = 0;      /* don't change */
1094         info_buf.Attributes = cpu_to_le32(dosattr);
1095 
1096         return server->ops->set_file_info(inode, full_path, &info_buf, xid);
1097 }
1098 
1099 /*
1100  * Open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
1101  * and rename it to a random name that hopefully won't conflict with
1102  * anything else.
1103  */
1104 int
1105 cifs_rename_pending_delete(const char *full_path, struct dentry *dentry,
1106                            const unsigned int xid)
1107 {
1108         int oplock = 0;
1109         int rc;
1110         struct cifs_fid fid;
1111         struct cifs_open_parms oparms;
1112         struct inode *inode = d_inode(dentry);
1113         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1114         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1115         struct tcon_link *tlink;
1116         struct cifs_tcon *tcon;
1117         __u32 dosattr, origattr;
1118         FILE_BASIC_INFO *info_buf = NULL;
1119 
1120         tlink = cifs_sb_tlink(cifs_sb);
1121         if (IS_ERR(tlink))
1122                 return PTR_ERR(tlink);
1123         tcon = tlink_tcon(tlink);
1124 
1125         /*
1126          * We cannot rename the file if the server doesn't support
1127          * CAP_INFOLEVEL_PASSTHRU
1128          */
1129         if (!(tcon->ses->capabilities & CAP_INFOLEVEL_PASSTHRU)) {
1130                 rc = -EBUSY;
1131                 goto out;
1132         }
1133 
1134         oparms.tcon = tcon;
1135         oparms.cifs_sb = cifs_sb;
1136         oparms.desired_access = DELETE | FILE_WRITE_ATTRIBUTES;
1137         oparms.create_options = CREATE_NOT_DIR;
1138         oparms.disposition = FILE_OPEN;
1139         oparms.path = full_path;
1140         oparms.fid = &fid;
1141         oparms.reconnect = false;
1142 
1143         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1144         if (rc != 0)
1145                 goto out;
1146 
1147         origattr = cifsInode->cifsAttrs;
1148         if (origattr == 0)
1149                 origattr |= ATTR_NORMAL;
1150 
1151         dosattr = origattr & ~ATTR_READONLY;
1152         if (dosattr == 0)
1153                 dosattr |= ATTR_NORMAL;
1154         dosattr |= ATTR_HIDDEN;
1155 
1156         /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
1157         if (dosattr != origattr) {
1158                 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
1159                 if (info_buf == NULL) {
1160                         rc = -ENOMEM;
1161                         goto out_close;
1162                 }
1163                 info_buf->Attributes = cpu_to_le32(dosattr);
1164                 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1165                                         current->tgid);
1166                 /* although we would like to mark the file hidden
1167                    if that fails we will still try to rename it */
1168                 if (!rc)
1169                         cifsInode->cifsAttrs = dosattr;
1170                 else
1171                         dosattr = origattr; /* since not able to change them */
1172         }
1173 
1174         /* rename the file */
1175         rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, NULL,
1176                                    cifs_sb->local_nls,
1177                                    cifs_remap(cifs_sb));
1178         if (rc != 0) {
1179                 rc = -EBUSY;
1180                 goto undo_setattr;
1181         }
1182 
1183         /* try to set DELETE_ON_CLOSE */
1184         if (!test_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags)) {
1185                 rc = CIFSSMBSetFileDisposition(xid, tcon, true, fid.netfid,
1186                                                current->tgid);
1187                 /*
1188                  * some samba versions return -ENOENT when we try to set the
1189                  * file disposition here. Likely a samba bug, but work around
1190                  * it for now. This means that some cifsXXX files may hang
1191                  * around after they shouldn't.
1192                  *
1193                  * BB: remove this hack after more servers have the fix
1194                  */
1195                 if (rc == -ENOENT)
1196                         rc = 0;
1197                 else if (rc != 0) {
1198                         rc = -EBUSY;
1199                         goto undo_rename;
1200                 }
1201                 set_bit(CIFS_INO_DELETE_PENDING, &cifsInode->flags);
1202         }
1203 
1204 out_close:
1205         CIFSSMBClose(xid, tcon, fid.netfid);
1206 out:
1207         kfree(info_buf);
1208         cifs_put_tlink(tlink);
1209         return rc;
1210 
1211         /*
1212          * reset everything back to the original state. Don't bother
1213          * dealing with errors here since we can't do anything about
1214          * them anyway.
1215          */
1216 undo_rename:
1217         CIFSSMBRenameOpenFile(xid, tcon, fid.netfid, dentry->d_name.name,
1218                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1219 undo_setattr:
1220         if (dosattr != origattr) {
1221                 info_buf->Attributes = cpu_to_le32(origattr);
1222                 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, fid.netfid,
1223                                         current->tgid))
1224                         cifsInode->cifsAttrs = origattr;
1225         }
1226 
1227         goto out_close;
1228 }
1229 
1230 /* copied from fs/nfs/dir.c with small changes */
1231 static void
1232 cifs_drop_nlink(struct inode *inode)
1233 {
1234         spin_lock(&inode->i_lock);
1235         if (inode->i_nlink > 0)
1236                 drop_nlink(inode);
1237         spin_unlock(&inode->i_lock);
1238 }
1239 
1240 /*
1241  * If d_inode(dentry) is null (usually meaning the cached dentry
1242  * is a negative dentry) then we would attempt a standard SMB delete, but
1243  * if that fails we can not attempt the fall back mechanisms on EACCESS
1244  * but will return the EACCESS to the caller. Note that the VFS does not call
1245  * unlink on negative dentries currently.
1246  */
1247 int cifs_unlink(struct inode *dir, struct dentry *dentry)
1248 {
1249         int rc = 0;
1250         unsigned int xid;
1251         char *full_path = NULL;
1252         struct inode *inode = d_inode(dentry);
1253         struct cifsInodeInfo *cifs_inode;
1254         struct super_block *sb = dir->i_sb;
1255         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
1256         struct tcon_link *tlink;
1257         struct cifs_tcon *tcon;
1258         struct TCP_Server_Info *server;
1259         struct iattr *attrs = NULL;
1260         __u32 dosattr = 0, origattr = 0;
1261 
1262         cifs_dbg(FYI, "cifs_unlink, dir=0x%p, dentry=0x%p\n", dir, dentry);
1263 
1264         tlink = cifs_sb_tlink(cifs_sb);
1265         if (IS_ERR(tlink))
1266                 return PTR_ERR(tlink);
1267         tcon = tlink_tcon(tlink);
1268         server = tcon->ses->server;
1269 
1270         xid = get_xid();
1271 
1272         /* Unlink can be called from rename so we can not take the
1273          * sb->s_vfs_rename_mutex here */
1274         full_path = build_path_from_dentry(dentry);
1275         if (full_path == NULL) {
1276                 rc = -ENOMEM;
1277                 goto unlink_out;
1278         }
1279 
1280         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1281                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1282                 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
1283                         SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
1284                         cifs_remap(cifs_sb));
1285                 cifs_dbg(FYI, "posix del rc %d\n", rc);
1286                 if ((rc == 0) || (rc == -ENOENT))
1287                         goto psx_del_no_retry;
1288         }
1289 
1290 retry_std_delete:
1291         if (!server->ops->unlink) {
1292                 rc = -ENOSYS;
1293                 goto psx_del_no_retry;
1294         }
1295 
1296         rc = server->ops->unlink(xid, tcon, full_path, cifs_sb);
1297 
1298 psx_del_no_retry:
1299         if (!rc) {
1300                 if (inode)
1301                         cifs_drop_nlink(inode);
1302         } else if (rc == -ENOENT) {
1303                 d_drop(dentry);
1304         } else if (rc == -EBUSY) {
1305                 if (server->ops->rename_pending_delete) {
1306                         rc = server->ops->rename_pending_delete(full_path,
1307                                                                 dentry, xid);
1308                         if (rc == 0)
1309                                 cifs_drop_nlink(inode);
1310                 }
1311         } else if ((rc == -EACCES) && (dosattr == 0) && inode) {
1312                 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
1313                 if (attrs == NULL) {
1314                         rc = -ENOMEM;
1315                         goto out_reval;
1316                 }
1317 
1318                 /* try to reset dos attributes */
1319                 cifs_inode = CIFS_I(inode);
1320                 origattr = cifs_inode->cifsAttrs;
1321                 if (origattr == 0)
1322                         origattr |= ATTR_NORMAL;
1323                 dosattr = origattr & ~ATTR_READONLY;
1324                 if (dosattr == 0)
1325                         dosattr |= ATTR_NORMAL;
1326                 dosattr |= ATTR_HIDDEN;
1327 
1328                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1329                 if (rc != 0)
1330                         goto out_reval;
1331 
1332                 goto retry_std_delete;
1333         }
1334 
1335         /* undo the setattr if we errored out and it's needed */
1336         if (rc != 0 && dosattr != 0)
1337                 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1338 
1339 out_reval:
1340         if (inode) {
1341                 cifs_inode = CIFS_I(inode);
1342                 cifs_inode->time = 0;   /* will force revalidate to get info
1343                                            when needed */
1344                 inode->i_ctime = current_fs_time(sb);
1345         }
1346         dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1347         cifs_inode = CIFS_I(dir);
1348         CIFS_I(dir)->time = 0;  /* force revalidate of dir as well */
1349 unlink_out:
1350         kfree(full_path);
1351         kfree(attrs);
1352         free_xid(xid);
1353         cifs_put_tlink(tlink);
1354         return rc;
1355 }
1356 
1357 static int
1358 cifs_mkdir_qinfo(struct inode *parent, struct dentry *dentry, umode_t mode,
1359                  const char *full_path, struct cifs_sb_info *cifs_sb,
1360                  struct cifs_tcon *tcon, const unsigned int xid)
1361 {
1362         int rc = 0;
1363         struct inode *inode = NULL;
1364 
1365         if (tcon->unix_ext)
1366                 rc = cifs_get_inode_info_unix(&inode, full_path, parent->i_sb,
1367                                               xid);
1368         else
1369                 rc = cifs_get_inode_info(&inode, full_path, NULL, parent->i_sb,
1370                                          xid, NULL);
1371 
1372         if (rc)
1373                 return rc;
1374 
1375         /*
1376          * setting nlink not necessary except in cases where we failed to get it
1377          * from the server or was set bogus. Also, since this is a brand new
1378          * inode, no need to grab the i_lock before setting the i_nlink.
1379          */
1380         if (inode->i_nlink < 2)
1381                 set_nlink(inode, 2);
1382         mode &= ~current_umask();
1383         /* must turn on setgid bit if parent dir has it */
1384         if (parent->i_mode & S_ISGID)
1385                 mode |= S_ISGID;
1386 
1387         if (tcon->unix_ext) {
1388                 struct cifs_unix_set_info_args args = {
1389                         .mode   = mode,
1390                         .ctime  = NO_CHANGE_64,
1391                         .atime  = NO_CHANGE_64,
1392                         .mtime  = NO_CHANGE_64,
1393                         .device = 0,
1394                 };
1395                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1396                         args.uid = current_fsuid();
1397                         if (parent->i_mode & S_ISGID)
1398                                 args.gid = parent->i_gid;
1399                         else
1400                                 args.gid = current_fsgid();
1401                 } else {
1402                         args.uid = INVALID_UID; /* no change */
1403                         args.gid = INVALID_GID; /* no change */
1404                 }
1405                 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
1406                                        cifs_sb->local_nls,
1407                                        cifs_remap(cifs_sb));
1408         } else {
1409                 struct TCP_Server_Info *server = tcon->ses->server;
1410                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1411                     (mode & S_IWUGO) == 0 && server->ops->mkdir_setinfo)
1412                         server->ops->mkdir_setinfo(inode, full_path, cifs_sb,
1413                                                    tcon, xid);
1414                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
1415                         inode->i_mode = (mode | S_IFDIR);
1416 
1417                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
1418                         inode->i_uid = current_fsuid();
1419                         if (inode->i_mode & S_ISGID)
1420                                 inode->i_gid = parent->i_gid;
1421                         else
1422                                 inode->i_gid = current_fsgid();
1423                 }
1424         }
1425         d_instantiate(dentry, inode);
1426         return rc;
1427 }
1428 
1429 static int
1430 cifs_posix_mkdir(struct inode *inode, struct dentry *dentry, umode_t mode,
1431                  const char *full_path, struct cifs_sb_info *cifs_sb,
1432                  struct cifs_tcon *tcon, const unsigned int xid)
1433 {
1434         int rc = 0;
1435         u32 oplock = 0;
1436         FILE_UNIX_BASIC_INFO *info = NULL;
1437         struct inode *newinode = NULL;
1438         struct cifs_fattr fattr;
1439 
1440         info = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1441         if (info == NULL) {
1442                 rc = -ENOMEM;
1443                 goto posix_mkdir_out;
1444         }
1445 
1446         mode &= ~current_umask();
1447         rc = CIFSPOSIXCreate(xid, tcon, SMB_O_DIRECTORY | SMB_O_CREAT, mode,
1448                              NULL /* netfid */, info, &oplock, full_path,
1449                              cifs_sb->local_nls, cifs_remap(cifs_sb));
1450         if (rc == -EOPNOTSUPP)
1451                 goto posix_mkdir_out;
1452         else if (rc) {
1453                 cifs_dbg(FYI, "posix mkdir returned 0x%x\n", rc);
1454                 d_drop(dentry);
1455                 goto posix_mkdir_out;
1456         }
1457 
1458         if (info->Type == cpu_to_le32(-1))
1459                 /* no return info, go query for it */
1460                 goto posix_mkdir_get_info;
1461         /*
1462          * BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if
1463          * need to set uid/gid.
1464          */
1465 
1466         cifs_unix_basic_to_fattr(&fattr, info, cifs_sb);
1467         cifs_fill_uniqueid(inode->i_sb, &fattr);
1468         newinode = cifs_iget(inode->i_sb, &fattr);
1469         if (!newinode)
1470                 goto posix_mkdir_get_info;
1471 
1472         d_instantiate(dentry, newinode);
1473 
1474 #ifdef CONFIG_CIFS_DEBUG2
1475         cifs_dbg(FYI, "instantiated dentry %p %pd to inode %p\n",
1476                  dentry, dentry, newinode);
1477 
1478         if (newinode->i_nlink != 2)
1479                 cifs_dbg(FYI, "unexpected number of links %d\n",
1480                          newinode->i_nlink);
1481 #endif
1482 
1483 posix_mkdir_out:
1484         kfree(info);
1485         return rc;
1486 posix_mkdir_get_info:
1487         rc = cifs_mkdir_qinfo(inode, dentry, mode, full_path, cifs_sb, tcon,
1488                               xid);
1489         goto posix_mkdir_out;
1490 }
1491 
1492 int cifs_mkdir(struct inode *inode, struct dentry *direntry, umode_t mode)
1493 {
1494         int rc = 0;
1495         unsigned int xid;
1496         struct cifs_sb_info *cifs_sb;
1497         struct tcon_link *tlink;
1498         struct cifs_tcon *tcon;
1499         struct TCP_Server_Info *server;
1500         char *full_path;
1501 
1502         cifs_dbg(FYI, "In cifs_mkdir, mode = 0x%hx inode = 0x%p\n",
1503                  mode, inode);
1504 
1505         cifs_sb = CIFS_SB(inode->i_sb);
1506         tlink = cifs_sb_tlink(cifs_sb);
1507         if (IS_ERR(tlink))
1508                 return PTR_ERR(tlink);
1509         tcon = tlink_tcon(tlink);
1510 
1511         xid = get_xid();
1512 
1513         full_path = build_path_from_dentry(direntry);
1514         if (full_path == NULL) {
1515                 rc = -ENOMEM;
1516                 goto mkdir_out;
1517         }
1518 
1519         if (cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1520                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1521                 rc = cifs_posix_mkdir(inode, direntry, mode, full_path, cifs_sb,
1522                                       tcon, xid);
1523                 if (rc != -EOPNOTSUPP)
1524                         goto mkdir_out;
1525         }
1526 
1527         server = tcon->ses->server;
1528 
1529         if (!server->ops->mkdir) {
1530                 rc = -ENOSYS;
1531                 goto mkdir_out;
1532         }
1533 
1534         /* BB add setting the equivalent of mode via CreateX w/ACLs */
1535         rc = server->ops->mkdir(xid, tcon, full_path, cifs_sb);
1536         if (rc) {
1537                 cifs_dbg(FYI, "cifs_mkdir returned 0x%x\n", rc);
1538                 d_drop(direntry);
1539                 goto mkdir_out;
1540         }
1541 
1542         rc = cifs_mkdir_qinfo(inode, direntry, mode, full_path, cifs_sb, tcon,
1543                               xid);
1544 mkdir_out:
1545         /*
1546          * Force revalidate to get parent dir info when needed since cached
1547          * attributes are invalid now.
1548          */
1549         CIFS_I(inode)->time = 0;
1550         kfree(full_path);
1551         free_xid(xid);
1552         cifs_put_tlink(tlink);
1553         return rc;
1554 }
1555 
1556 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1557 {
1558         int rc = 0;
1559         unsigned int xid;
1560         struct cifs_sb_info *cifs_sb;
1561         struct tcon_link *tlink;
1562         struct cifs_tcon *tcon;
1563         struct TCP_Server_Info *server;
1564         char *full_path = NULL;
1565         struct cifsInodeInfo *cifsInode;
1566 
1567         cifs_dbg(FYI, "cifs_rmdir, inode = 0x%p\n", inode);
1568 
1569         xid = get_xid();
1570 
1571         full_path = build_path_from_dentry(direntry);
1572         if (full_path == NULL) {
1573                 rc = -ENOMEM;
1574                 goto rmdir_exit;
1575         }
1576 
1577         cifs_sb = CIFS_SB(inode->i_sb);
1578         tlink = cifs_sb_tlink(cifs_sb);
1579         if (IS_ERR(tlink)) {
1580                 rc = PTR_ERR(tlink);
1581                 goto rmdir_exit;
1582         }
1583         tcon = tlink_tcon(tlink);
1584         server = tcon->ses->server;
1585 
1586         if (!server->ops->rmdir) {
1587                 rc = -ENOSYS;
1588                 cifs_put_tlink(tlink);
1589                 goto rmdir_exit;
1590         }
1591 
1592         rc = server->ops->rmdir(xid, tcon, full_path, cifs_sb);
1593         cifs_put_tlink(tlink);
1594 
1595         if (!rc) {
1596                 spin_lock(&d_inode(direntry)->i_lock);
1597                 i_size_write(d_inode(direntry), 0);
1598                 clear_nlink(d_inode(direntry));
1599                 spin_unlock(&d_inode(direntry)->i_lock);
1600         }
1601 
1602         cifsInode = CIFS_I(d_inode(direntry));
1603         /* force revalidate to go get info when needed */
1604         cifsInode->time = 0;
1605 
1606         cifsInode = CIFS_I(inode);
1607         /*
1608          * Force revalidate to get parent dir info when needed since cached
1609          * attributes are invalid now.
1610          */
1611         cifsInode->time = 0;
1612 
1613         d_inode(direntry)->i_ctime = inode->i_ctime = inode->i_mtime =
1614                 current_fs_time(inode->i_sb);
1615 
1616 rmdir_exit:
1617         kfree(full_path);
1618         free_xid(xid);
1619         return rc;
1620 }
1621 
1622 static int
1623 cifs_do_rename(const unsigned int xid, struct dentry *from_dentry,
1624                const char *from_path, struct dentry *to_dentry,
1625                const char *to_path)
1626 {
1627         struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1628         struct tcon_link *tlink;
1629         struct cifs_tcon *tcon;
1630         struct TCP_Server_Info *server;
1631         struct cifs_fid fid;
1632         struct cifs_open_parms oparms;
1633         int oplock, rc;
1634 
1635         tlink = cifs_sb_tlink(cifs_sb);
1636         if (IS_ERR(tlink))
1637                 return PTR_ERR(tlink);
1638         tcon = tlink_tcon(tlink);
1639         server = tcon->ses->server;
1640 
1641         if (!server->ops->rename)
1642                 return -ENOSYS;
1643 
1644         /* try path-based rename first */
1645         rc = server->ops->rename(xid, tcon, from_path, to_path, cifs_sb);
1646 
1647         /*
1648          * Don't bother with rename by filehandle unless file is busy and
1649          * source. Note that cross directory moves do not work with
1650          * rename by filehandle to various Windows servers.
1651          */
1652         if (rc == 0 || rc != -EBUSY)
1653                 goto do_rename_exit;
1654 
1655         /* open-file renames don't work across directories */
1656         if (to_dentry->d_parent != from_dentry->d_parent)
1657                 goto do_rename_exit;
1658 
1659         oparms.tcon = tcon;
1660         oparms.cifs_sb = cifs_sb;
1661         /* open the file to be renamed -- we need DELETE perms */
1662         oparms.desired_access = DELETE;
1663         oparms.create_options = CREATE_NOT_DIR;
1664         oparms.disposition = FILE_OPEN;
1665         oparms.path = from_path;
1666         oparms.fid = &fid;
1667         oparms.reconnect = false;
1668 
1669         rc = CIFS_open(xid, &oparms, &oplock, NULL);
1670         if (rc == 0) {
1671                 rc = CIFSSMBRenameOpenFile(xid, tcon, fid.netfid,
1672                                 (const char *) to_dentry->d_name.name,
1673                                 cifs_sb->local_nls, cifs_remap(cifs_sb));
1674                 CIFSSMBClose(xid, tcon, fid.netfid);
1675         }
1676 do_rename_exit:
1677         cifs_put_tlink(tlink);
1678         return rc;
1679 }
1680 
1681 int
1682 cifs_rename2(struct inode *source_dir, struct dentry *source_dentry,
1683              struct inode *target_dir, struct dentry *target_dentry,
1684              unsigned int flags)
1685 {
1686         char *from_name = NULL;
1687         char *to_name = NULL;
1688         struct cifs_sb_info *cifs_sb;
1689         struct tcon_link *tlink;
1690         struct cifs_tcon *tcon;
1691         FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1692         FILE_UNIX_BASIC_INFO *info_buf_target;
1693         unsigned int xid;
1694         int rc, tmprc;
1695 
1696         if (flags & ~RENAME_NOREPLACE)
1697                 return -EINVAL;
1698 
1699         cifs_sb = CIFS_SB(source_dir->i_sb);
1700         tlink = cifs_sb_tlink(cifs_sb);
1701         if (IS_ERR(tlink))
1702                 return PTR_ERR(tlink);
1703         tcon = tlink_tcon(tlink);
1704 
1705         xid = get_xid();
1706 
1707         /*
1708          * we already have the rename sem so we do not need to
1709          * grab it again here to protect the path integrity
1710          */
1711         from_name = build_path_from_dentry(source_dentry);
1712         if (from_name == NULL) {
1713                 rc = -ENOMEM;
1714                 goto cifs_rename_exit;
1715         }
1716 
1717         to_name = build_path_from_dentry(target_dentry);
1718         if (to_name == NULL) {
1719                 rc = -ENOMEM;
1720                 goto cifs_rename_exit;
1721         }
1722 
1723         rc = cifs_do_rename(xid, source_dentry, from_name, target_dentry,
1724                             to_name);
1725 
1726         /*
1727          * No-replace is the natural behavior for CIFS, so skip unlink hacks.
1728          */
1729         if (flags & RENAME_NOREPLACE)
1730                 goto cifs_rename_exit;
1731 
1732         if (rc == -EEXIST && tcon->unix_ext) {
1733                 /*
1734                  * Are src and dst hardlinks of same inode? We can only tell
1735                  * with unix extensions enabled.
1736                  */
1737                 info_buf_source =
1738                         kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1739                                         GFP_KERNEL);
1740                 if (info_buf_source == NULL) {
1741                         rc = -ENOMEM;
1742                         goto cifs_rename_exit;
1743                 }
1744 
1745                 info_buf_target = info_buf_source + 1;
1746                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, from_name,
1747                                              info_buf_source,
1748                                              cifs_sb->local_nls,
1749                                              cifs_remap(cifs_sb));
1750                 if (tmprc != 0)
1751                         goto unlink_target;
1752 
1753                 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, to_name,
1754                                              info_buf_target,
1755                                              cifs_sb->local_nls,
1756                                              cifs_remap(cifs_sb));
1757 
1758                 if (tmprc == 0 && (info_buf_source->UniqueId ==
1759                                    info_buf_target->UniqueId)) {
1760                         /* same file, POSIX says that this is a noop */
1761                         rc = 0;
1762                         goto cifs_rename_exit;
1763                 }
1764         }
1765         /*
1766          * else ... BB we could add the same check for Windows by
1767          * checking the UniqueId via FILE_INTERNAL_INFO
1768          */
1769 
1770 unlink_target:
1771         /* Try unlinking the target dentry if it's not negative */
1772         if (d_really_is_positive(target_dentry) && (rc == -EACCES || rc == -EEXIST)) {
1773                 if (d_is_dir(target_dentry))
1774                         tmprc = cifs_rmdir(target_dir, target_dentry);
1775                 else
1776                         tmprc = cifs_unlink(target_dir, target_dentry);
1777                 if (tmprc)
1778                         goto cifs_rename_exit;
1779                 rc = cifs_do_rename(xid, source_dentry, from_name,
1780                                     target_dentry, to_name);
1781         }
1782 
1783         /* force revalidate to go get info when needed */
1784         CIFS_I(source_dir)->time = CIFS_I(target_dir)->time = 0;
1785 
1786         source_dir->i_ctime = source_dir->i_mtime = target_dir->i_ctime =
1787                 target_dir->i_mtime = current_fs_time(source_dir->i_sb);
1788 
1789 cifs_rename_exit:
1790         kfree(info_buf_source);
1791         kfree(from_name);
1792         kfree(to_name);
1793         free_xid(xid);
1794         cifs_put_tlink(tlink);
1795         return rc;
1796 }
1797 
1798 static bool
1799 cifs_inode_needs_reval(struct inode *inode)
1800 {
1801         struct cifsInodeInfo *cifs_i = CIFS_I(inode);
1802         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1803 
1804         if (CIFS_CACHE_READ(cifs_i))
1805                 return false;
1806 
1807         if (!lookupCacheEnabled)
1808                 return true;
1809 
1810         if (cifs_i->time == 0)
1811                 return true;
1812 
1813         if (!cifs_sb->actimeo)
1814                 return true;
1815 
1816         if (!time_in_range(jiffies, cifs_i->time,
1817                                 cifs_i->time + cifs_sb->actimeo))
1818                 return true;
1819 
1820         /* hardlinked files w/ noserverino get "special" treatment */
1821         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) &&
1822             S_ISREG(inode->i_mode) && inode->i_nlink != 1)
1823                 return true;
1824 
1825         return false;
1826 }
1827 
1828 /*
1829  * Zap the cache. Called when invalid_mapping flag is set.
1830  */
1831 int
1832 cifs_invalidate_mapping(struct inode *inode)
1833 {
1834         int rc = 0;
1835 
1836         if (inode->i_mapping && inode->i_mapping->nrpages != 0) {
1837                 rc = invalidate_inode_pages2(inode->i_mapping);
1838                 if (rc)
1839                         cifs_dbg(VFS, "%s: could not invalidate inode %p\n",
1840                                  __func__, inode);
1841         }
1842 
1843         cifs_fscache_reset_inode_cookie(inode);
1844         return rc;
1845 }
1846 
1847 /**
1848  * cifs_wait_bit_killable - helper for functions that are sleeping on bit locks
1849  * @word: long word containing the bit lock
1850  */
1851 static int
1852 cifs_wait_bit_killable(struct wait_bit_key *key)
1853 {
1854         if (fatal_signal_pending(current))
1855                 return -ERESTARTSYS;
1856         freezable_schedule_unsafe();
1857         return 0;
1858 }
1859 
1860 int
1861 cifs_revalidate_mapping(struct inode *inode)
1862 {
1863         int rc;
1864         unsigned long *flags = &CIFS_I(inode)->flags;
1865 
1866         rc = wait_on_bit_lock_action(flags, CIFS_INO_LOCK, cifs_wait_bit_killable,
1867                                      TASK_KILLABLE);
1868         if (rc)
1869                 return rc;
1870 
1871         if (test_and_clear_bit(CIFS_INO_INVALID_MAPPING, flags)) {
1872                 rc = cifs_invalidate_mapping(inode);
1873                 if (rc)
1874                         set_bit(CIFS_INO_INVALID_MAPPING, flags);
1875         }
1876 
1877         clear_bit_unlock(CIFS_INO_LOCK, flags);
1878         smp_mb__after_atomic();
1879         wake_up_bit(flags, CIFS_INO_LOCK);
1880 
1881         return rc;
1882 }
1883 
1884 int
1885 cifs_zap_mapping(struct inode *inode)
1886 {
1887         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
1888         return cifs_revalidate_mapping(inode);
1889 }
1890 
1891 int cifs_revalidate_file_attr(struct file *filp)
1892 {
1893         int rc = 0;
1894         struct inode *inode = file_inode(filp);
1895         struct cifsFileInfo *cfile = (struct cifsFileInfo *) filp->private_data;
1896 
1897         if (!cifs_inode_needs_reval(inode))
1898                 return rc;
1899 
1900         if (tlink_tcon(cfile->tlink)->unix_ext)
1901                 rc = cifs_get_file_info_unix(filp);
1902         else
1903                 rc = cifs_get_file_info(filp);
1904 
1905         return rc;
1906 }
1907 
1908 int cifs_revalidate_dentry_attr(struct dentry *dentry)
1909 {
1910         unsigned int xid;
1911         int rc = 0;
1912         struct inode *inode = d_inode(dentry);
1913         struct super_block *sb = dentry->d_sb;
1914         char *full_path = NULL;
1915 
1916         if (inode == NULL)
1917                 return -ENOENT;
1918 
1919         if (!cifs_inode_needs_reval(inode))
1920                 return rc;
1921 
1922         xid = get_xid();
1923 
1924         /* can not safely grab the rename sem here if rename calls revalidate
1925            since that would deadlock */
1926         full_path = build_path_from_dentry(dentry);
1927         if (full_path == NULL) {
1928                 rc = -ENOMEM;
1929                 goto out;
1930         }
1931 
1932         cifs_dbg(FYI, "Update attributes: %s inode 0x%p count %d dentry: 0x%p d_time %ld jiffies %ld\n",
1933                  full_path, inode, inode->i_count.counter,
1934                  dentry, dentry->d_time, jiffies);
1935 
1936         if (cifs_sb_master_tcon(CIFS_SB(sb))->unix_ext)
1937                 rc = cifs_get_inode_info_unix(&inode, full_path, sb, xid);
1938         else
1939                 rc = cifs_get_inode_info(&inode, full_path, NULL, sb,
1940                                          xid, NULL);
1941 
1942 out:
1943         kfree(full_path);
1944         free_xid(xid);
1945         return rc;
1946 }
1947 
1948 int cifs_revalidate_file(struct file *filp)
1949 {
1950         int rc;
1951         struct inode *inode = file_inode(filp);
1952 
1953         rc = cifs_revalidate_file_attr(filp);
1954         if (rc)
1955                 return rc;
1956 
1957         return cifs_revalidate_mapping(inode);
1958 }
1959 
1960 /* revalidate a dentry's inode attributes */
1961 int cifs_revalidate_dentry(struct dentry *dentry)
1962 {
1963         int rc;
1964         struct inode *inode = d_inode(dentry);
1965 
1966         rc = cifs_revalidate_dentry_attr(dentry);
1967         if (rc)
1968                 return rc;
1969 
1970         return cifs_revalidate_mapping(inode);
1971 }
1972 
1973 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1974                  struct kstat *stat)
1975 {
1976         struct cifs_sb_info *cifs_sb = CIFS_SB(dentry->d_sb);
1977         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1978         struct inode *inode = d_inode(dentry);
1979         int rc;
1980 
1981         /*
1982          * We need to be sure that all dirty pages are written and the server
1983          * has actual ctime, mtime and file length.
1984          */
1985         if (!CIFS_CACHE_READ(CIFS_I(inode)) && inode->i_mapping &&
1986             inode->i_mapping->nrpages != 0) {
1987                 rc = filemap_fdatawait(inode->i_mapping);
1988                 if (rc) {
1989                         mapping_set_error(inode->i_mapping, rc);
1990                         return rc;
1991                 }
1992         }
1993 
1994         rc = cifs_revalidate_dentry_attr(dentry);
1995         if (rc)
1996                 return rc;
1997 
1998         generic_fillattr(inode, stat);
1999         stat->blksize = CIFS_MAX_MSGSIZE;
2000         stat->ino = CIFS_I(inode)->uniqueid;
2001 
2002         /*
2003          * If on a multiuser mount without unix extensions or cifsacl being
2004          * enabled, and the admin hasn't overridden them, set the ownership
2005          * to the fsuid/fsgid of the current process.
2006          */
2007         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER) &&
2008             !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
2009             !tcon->unix_ext) {
2010                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID))
2011                         stat->uid = current_fsuid();
2012                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID))
2013                         stat->gid = current_fsgid();
2014         }
2015         return rc;
2016 }
2017 
2018 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
2019 {
2020         pgoff_t index = from >> PAGE_CACHE_SHIFT;
2021         unsigned offset = from & (PAGE_CACHE_SIZE - 1);
2022         struct page *page;
2023         int rc = 0;
2024 
2025         page = grab_cache_page(mapping, index);
2026         if (!page)
2027                 return -ENOMEM;
2028 
2029         zero_user_segment(page, offset, PAGE_CACHE_SIZE);
2030         unlock_page(page);
2031         page_cache_release(page);
2032         return rc;
2033 }
2034 
2035 static void cifs_setsize(struct inode *inode, loff_t offset)
2036 {
2037         spin_lock(&inode->i_lock);
2038         i_size_write(inode, offset);
2039         spin_unlock(&inode->i_lock);
2040 
2041         truncate_pagecache(inode, offset);
2042 }
2043 
2044 static int
2045 cifs_set_file_size(struct inode *inode, struct iattr *attrs,
2046                    unsigned int xid, char *full_path)
2047 {
2048         int rc;
2049         struct cifsFileInfo *open_file;
2050         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2051         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2052         struct tcon_link *tlink = NULL;
2053         struct cifs_tcon *tcon = NULL;
2054         struct TCP_Server_Info *server;
2055 
2056         /*
2057          * To avoid spurious oplock breaks from server, in the case of
2058          * inodes that we already have open, avoid doing path based
2059          * setting of file size if we can do it by handle.
2060          * This keeps our caching token (oplock) and avoids timeouts
2061          * when the local oplock break takes longer to flush
2062          * writebehind data than the SMB timeout for the SetPathInfo
2063          * request would allow
2064          */
2065         open_file = find_writable_file(cifsInode, true);
2066         if (open_file) {
2067                 tcon = tlink_tcon(open_file->tlink);
2068                 server = tcon->ses->server;
2069                 if (server->ops->set_file_size)
2070                         rc = server->ops->set_file_size(xid, tcon, open_file,
2071                                                         attrs->ia_size, false);
2072                 else
2073                         rc = -ENOSYS;
2074                 cifsFileInfo_put(open_file);
2075                 cifs_dbg(FYI, "SetFSize for attrs rc = %d\n", rc);
2076         } else
2077                 rc = -EINVAL;
2078 
2079         if (!rc)
2080                 goto set_size_out;
2081 
2082         if (tcon == NULL) {
2083                 tlink = cifs_sb_tlink(cifs_sb);
2084                 if (IS_ERR(tlink))
2085                         return PTR_ERR(tlink);
2086                 tcon = tlink_tcon(tlink);
2087                 server = tcon->ses->server;
2088         }
2089 
2090         /*
2091          * Set file size by pathname rather than by handle either because no
2092          * valid, writeable file handle for it was found or because there was
2093          * an error setting it by handle.
2094          */
2095         if (server->ops->set_path_size)
2096                 rc = server->ops->set_path_size(xid, tcon, full_path,
2097                                                 attrs->ia_size, cifs_sb, false);
2098         else
2099                 rc = -ENOSYS;
2100         cifs_dbg(FYI, "SetEOF by path (setattrs) rc = %d\n", rc);
2101 
2102         if (tlink)
2103                 cifs_put_tlink(tlink);
2104 
2105 set_size_out:
2106         if (rc == 0) {
2107                 cifsInode->server_eof = attrs->ia_size;
2108                 cifs_setsize(inode, attrs->ia_size);
2109                 cifs_truncate_page(inode->i_mapping, inode->i_size);
2110         }
2111 
2112         return rc;
2113 }
2114 
2115 static int
2116 cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
2117 {
2118         int rc;
2119         unsigned int xid;
2120         char *full_path = NULL;
2121         struct inode *inode = d_inode(direntry);
2122         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2123         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2124         struct tcon_link *tlink;
2125         struct cifs_tcon *pTcon;
2126         struct cifs_unix_set_info_args *args = NULL;
2127         struct cifsFileInfo *open_file;
2128 
2129         cifs_dbg(FYI, "setattr_unix on file %pd attrs->ia_valid=0x%x\n",
2130                  direntry, attrs->ia_valid);
2131 
2132         xid = get_xid();
2133 
2134         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2135                 attrs->ia_valid |= ATTR_FORCE;
2136 
2137         rc = setattr_prepare(direntry, attrs);
2138         if (rc < 0)
2139                 goto out;
2140 
2141         full_path = build_path_from_dentry(direntry);
2142         if (full_path == NULL) {
2143                 rc = -ENOMEM;
2144                 goto out;
2145         }
2146 
2147         /*
2148          * Attempt to flush data before changing attributes. We need to do
2149          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2150          * ownership or mode then we may also need to do this. Here, we take
2151          * the safe way out and just do the flush on all setattr requests. If
2152          * the flush returns error, store it to report later and continue.
2153          *
2154          * BB: This should be smarter. Why bother flushing pages that
2155          * will be truncated anyway? Also, should we error out here if
2156          * the flush returns error?
2157          */
2158         rc = filemap_write_and_wait(inode->i_mapping);
2159         mapping_set_error(inode->i_mapping, rc);
2160         rc = 0;
2161 
2162         if (attrs->ia_valid & ATTR_SIZE) {
2163                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2164                 if (rc != 0)
2165                         goto out;
2166         }
2167 
2168         /* skip mode change if it's just for clearing setuid/setgid */
2169         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2170                 attrs->ia_valid &= ~ATTR_MODE;
2171 
2172         args = kmalloc(sizeof(*args), GFP_KERNEL);
2173         if (args == NULL) {
2174                 rc = -ENOMEM;
2175                 goto out;
2176         }
2177 
2178         /* set up the struct */
2179         if (attrs->ia_valid & ATTR_MODE)
2180                 args->mode = attrs->ia_mode;
2181         else
2182                 args->mode = NO_CHANGE_64;
2183 
2184         if (attrs->ia_valid & ATTR_UID)
2185                 args->uid = attrs->ia_uid;
2186         else
2187                 args->uid = INVALID_UID; /* no change */
2188 
2189         if (attrs->ia_valid & ATTR_GID)
2190                 args->gid = attrs->ia_gid;
2191         else
2192                 args->gid = INVALID_GID; /* no change */
2193 
2194         if (attrs->ia_valid & ATTR_ATIME)
2195                 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
2196         else
2197                 args->atime = NO_CHANGE_64;
2198 
2199         if (attrs->ia_valid & ATTR_MTIME)
2200                 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
2201         else
2202                 args->mtime = NO_CHANGE_64;
2203 
2204         if (attrs->ia_valid & ATTR_CTIME)
2205                 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
2206         else
2207                 args->ctime = NO_CHANGE_64;
2208 
2209         args->device = 0;
2210         open_file = find_writable_file(cifsInode, true);
2211         if (open_file) {
2212                 u16 nfid = open_file->fid.netfid;
2213                 u32 npid = open_file->pid;
2214                 pTcon = tlink_tcon(open_file->tlink);
2215                 rc = CIFSSMBUnixSetFileInfo(xid, pTcon, args, nfid, npid);
2216                 cifsFileInfo_put(open_file);
2217         } else {
2218                 tlink = cifs_sb_tlink(cifs_sb);
2219                 if (IS_ERR(tlink)) {
2220                         rc = PTR_ERR(tlink);
2221                         goto out;
2222                 }
2223                 pTcon = tlink_tcon(tlink);
2224                 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, args,
2225                                     cifs_sb->local_nls,
2226                                     cifs_remap(cifs_sb));
2227                 cifs_put_tlink(tlink);
2228         }
2229 
2230         if (rc)
2231                 goto out;
2232 
2233         if ((attrs->ia_valid & ATTR_SIZE) &&
2234             attrs->ia_size != i_size_read(inode))
2235                 truncate_setsize(inode, attrs->ia_size);
2236 
2237         setattr_copy(inode, attrs);
2238         mark_inode_dirty(inode);
2239 
2240         /* force revalidate when any of these times are set since some
2241            of the fs types (eg ext3, fat) do not have fine enough
2242            time granularity to match protocol, and we do not have a
2243            a way (yet) to query the server fs's time granularity (and
2244            whether it rounds times down).
2245         */
2246         if (attrs->ia_valid & (ATTR_MTIME | ATTR_CTIME))
2247                 cifsInode->time = 0;
2248 out:
2249         kfree(args);
2250         kfree(full_path);
2251         free_xid(xid);
2252         return rc;
2253 }
2254 
2255 static int
2256 cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
2257 {
2258         unsigned int xid;
2259         kuid_t uid = INVALID_UID;
2260         kgid_t gid = INVALID_GID;
2261         struct inode *inode = d_inode(direntry);
2262         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2263         struct cifsInodeInfo *cifsInode = CIFS_I(inode);
2264         char *full_path = NULL;
2265         int rc = -EACCES;
2266         __u32 dosattr = 0;
2267         __u64 mode = NO_CHANGE_64;
2268 
2269         xid = get_xid();
2270 
2271         cifs_dbg(FYI, "setattr on file %pd attrs->iavalid 0x%x\n",
2272                  direntry, attrs->ia_valid);
2273 
2274         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM)
2275                 attrs->ia_valid |= ATTR_FORCE;
2276 
2277         rc = setattr_prepare(direntry, attrs);
2278         if (rc < 0) {
2279                 free_xid(xid);
2280                 return rc;
2281         }
2282 
2283         full_path = build_path_from_dentry(direntry);
2284         if (full_path == NULL) {
2285                 rc = -ENOMEM;
2286                 free_xid(xid);
2287                 return rc;
2288         }
2289 
2290         /*
2291          * Attempt to flush data before changing attributes. We need to do
2292          * this for ATTR_SIZE and ATTR_MTIME for sure, and if we change the
2293          * ownership or mode then we may also need to do this. Here, we take
2294          * the safe way out and just do the flush on all setattr requests. If
2295          * the flush returns error, store it to report later and continue.
2296          *
2297          * BB: This should be smarter. Why bother flushing pages that
2298          * will be truncated anyway? Also, should we error out here if
2299          * the flush returns error?
2300          */
2301         rc = filemap_write_and_wait(inode->i_mapping);
2302         mapping_set_error(inode->i_mapping, rc);
2303         rc = 0;
2304 
2305         if (attrs->ia_valid & ATTR_SIZE) {
2306                 rc = cifs_set_file_size(inode, attrs, xid, full_path);
2307                 if (rc != 0)
2308                         goto cifs_setattr_exit;
2309         }
2310 
2311         if (attrs->ia_valid & ATTR_UID)
2312                 uid = attrs->ia_uid;
2313 
2314         if (attrs->ia_valid & ATTR_GID)
2315                 gid = attrs->ia_gid;
2316 
2317 #ifdef CONFIG_CIFS_ACL
2318         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2319                 if (uid_valid(uid) || gid_valid(gid)) {
2320                         rc = id_mode_to_cifs_acl(inode, full_path, NO_CHANGE_64,
2321                                                         uid, gid);
2322                         if (rc) {
2323                                 cifs_dbg(FYI, "%s: Setting id failed with error: %d\n",
2324                                          __func__, rc);
2325                                 goto cifs_setattr_exit;
2326                         }
2327                 }
2328         } else
2329 #endif /* CONFIG_CIFS_ACL */
2330         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
2331                 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
2332 
2333         /* skip mode change if it's just for clearing setuid/setgid */
2334         if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
2335                 attrs->ia_valid &= ~ATTR_MODE;
2336 
2337         if (attrs->ia_valid & ATTR_MODE) {
2338                 mode = attrs->ia_mode;
2339                 rc = 0;
2340 #ifdef CONFIG_CIFS_ACL
2341                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
2342                         rc = id_mode_to_cifs_acl(inode, full_path, mode,
2343                                                 INVALID_UID, INVALID_GID);
2344                         if (rc) {
2345                                 cifs_dbg(FYI, "%s: Setting ACL failed with error: %d\n",
2346                                          __func__, rc);
2347                                 goto cifs_setattr_exit;
2348                         }
2349                 } else
2350 #endif /* CONFIG_CIFS_ACL */
2351                 if (((mode & S_IWUGO) == 0) &&
2352                     (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
2353 
2354                         dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
2355 
2356                         /* fix up mode if we're not using dynperm */
2357                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
2358                                 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
2359                 } else if ((mode & S_IWUGO) &&
2360                            (cifsInode->cifsAttrs & ATTR_READONLY)) {
2361 
2362                         dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
2363                         /* Attributes of 0 are ignored */
2364                         if (dosattr == 0)
2365                                 dosattr |= ATTR_NORMAL;
2366 
2367                         /* reset local inode permissions to normal */
2368                         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2369                                 attrs->ia_mode &= ~(S_IALLUGO);
2370                                 if (S_ISDIR(inode->i_mode))
2371                                         attrs->ia_mode |=
2372                                                 cifs_sb->mnt_dir_mode;
2373                                 else
2374                                         attrs->ia_mode |=
2375                                                 cifs_sb->mnt_file_mode;
2376                         }
2377                 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
2378                         /* ignore mode change - ATTR_READONLY hasn't changed */
2379                         attrs->ia_valid &= ~ATTR_MODE;
2380                 }
2381         }
2382 
2383         if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
2384             ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
2385                 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
2386                 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
2387 
2388                 /* Even if error on time set, no sense failing the call if
2389                 the server would set the time to a reasonable value anyway,
2390                 and this check ensures that we are not being called from
2391                 sys_utimes in which case we ought to fail the call back to
2392                 the user when the server rejects the call */
2393                 if ((rc) && (attrs->ia_valid &
2394                                 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
2395                         rc = 0;
2396         }
2397 
2398         /* do not need local check to inode_check_ok since the server does
2399            that */
2400         if (rc)
2401                 goto cifs_setattr_exit;
2402 
2403         if ((attrs->ia_valid & ATTR_SIZE) &&
2404             attrs->ia_size != i_size_read(inode))
2405                 truncate_setsize(inode, attrs->ia_size);
2406 
2407         setattr_copy(inode, attrs);
2408         mark_inode_dirty(inode);
2409 
2410 cifs_setattr_exit:
2411         kfree(full_path);
2412         free_xid(xid);
2413         return rc;
2414 }
2415 
2416 int
2417 cifs_setattr(struct dentry *direntry, struct iattr *attrs)
2418 {
2419         struct inode *inode = d_inode(direntry);
2420         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2421         struct cifs_tcon *pTcon = cifs_sb_master_tcon(cifs_sb);
2422 
2423         if (pTcon->unix_ext)
2424                 return cifs_setattr_unix(direntry, attrs);
2425 
2426         return cifs_setattr_nounix(direntry, attrs);
2427 
2428         /* BB: add cifs_setattr_legacy for really old servers */
2429 }
2430 
2431 #if 0
2432 void cifs_delete_inode(struct inode *inode)
2433 {
2434         cifs_dbg(FYI, "In cifs_delete_inode, inode = 0x%p\n", inode);
2435         /* may have to add back in if and when safe distributed caching of
2436            directories added e.g. via FindNotify */
2437 }
2438 #endif
2439 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp