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