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

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

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

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