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