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

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

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

~ [ 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