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

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

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

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