blob: ff8c68de4a9205a9d0cd592d8a0c58872b0e8e65 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/inode.c
3 *
Steve French2dd29d32007-04-23 22:07:35 +00004 * Copyright (C) International Business Machines Corp., 2002,2007
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * 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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/stat.h>
23#include <linux/pagemap.h>
24#include <asm/div64.h>
25#include "cifsfs.h"
26#include "cifspdu.h"
27#include "cifsglob.h"
28#include "cifsproto.h"
29#include "cifs_debug.h"
30#include "cifs_fs_sb.h"
31
Christoph Hellwig70eff552008-02-15 20:55:05 +000032
Igor Mammedov79626702008-03-09 03:44:18 +000033static void cifs_set_ops(struct inode *inode, const bool is_dfs_referral)
Christoph Hellwig70eff552008-02-15 20:55:05 +000034{
35 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
36
37 switch (inode->i_mode & S_IFMT) {
38 case S_IFREG:
39 inode->i_op = &cifs_file_inode_ops;
40 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
41 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
42 inode->i_fop = &cifs_file_direct_nobrl_ops;
43 else
44 inode->i_fop = &cifs_file_direct_ops;
45 } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
46 inode->i_fop = &cifs_file_nobrl_ops;
47 else { /* not direct, send byte range locks */
48 inode->i_fop = &cifs_file_ops;
49 }
50
51
52 /* check if server can support readpages */
53 if (cifs_sb->tcon->ses->server->maxBuf <
54 PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
55 inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
56 else
57 inode->i_data.a_ops = &cifs_addr_ops;
58 break;
59 case S_IFDIR:
Steve Frenchbc5b6e22008-03-11 21:07:48 +000060#ifdef CONFIG_CIFS_DFS_UPCALL
Igor Mammedov79626702008-03-09 03:44:18 +000061 if (is_dfs_referral) {
62 inode->i_op = &cifs_dfs_referral_inode_operations;
63 } else {
Steve Frenchbc5b6e22008-03-11 21:07:48 +000064#else /* NO DFS support, treat as a directory */
65 {
66#endif
Igor Mammedov79626702008-03-09 03:44:18 +000067 inode->i_op = &cifs_dir_inode_ops;
68 inode->i_fop = &cifs_dir_ops;
69 }
Christoph Hellwig70eff552008-02-15 20:55:05 +000070 break;
71 case S_IFLNK:
72 inode->i_op = &cifs_symlink_inode_ops;
73 break;
74 default:
75 init_special_inode(inode, inode->i_mode, inode->i_rdev);
76 break;
77 }
78}
79
Christoph Hellwig75f12982008-02-25 20:25:21 +000080static void cifs_unix_info_to_inode(struct inode *inode,
81 FILE_UNIX_BASIC_INFO *info, int force_uid_gid)
82{
83 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
84 struct cifsInodeInfo *cifsInfo = CIFS_I(inode);
85 __u64 num_of_bytes = le64_to_cpu(info->NumOfBytes);
86 __u64 end_of_file = le64_to_cpu(info->EndOfFile);
87
88 inode->i_atime = cifs_NTtimeToUnix(le64_to_cpu(info->LastAccessTime));
89 inode->i_mtime =
90 cifs_NTtimeToUnix(le64_to_cpu(info->LastModificationTime));
91 inode->i_ctime = cifs_NTtimeToUnix(le64_to_cpu(info->LastStatusChange));
92 inode->i_mode = le64_to_cpu(info->Permissions);
93
94 /*
95 * Since we set the inode type below we need to mask off
96 * to avoid strange results if bits set above.
97 */
98 inode->i_mode &= ~S_IFMT;
99 switch (le32_to_cpu(info->Type)) {
100 case UNIX_FILE:
101 inode->i_mode |= S_IFREG;
102 break;
103 case UNIX_SYMLINK:
104 inode->i_mode |= S_IFLNK;
105 break;
106 case UNIX_DIR:
107 inode->i_mode |= S_IFDIR;
108 break;
109 case UNIX_CHARDEV:
110 inode->i_mode |= S_IFCHR;
111 inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
112 le64_to_cpu(info->DevMinor) & MINORMASK);
113 break;
114 case UNIX_BLOCKDEV:
115 inode->i_mode |= S_IFBLK;
116 inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
117 le64_to_cpu(info->DevMinor) & MINORMASK);
118 break;
119 case UNIX_FIFO:
120 inode->i_mode |= S_IFIFO;
121 break;
122 case UNIX_SOCKET:
123 inode->i_mode |= S_IFSOCK;
124 break;
125 default:
126 /* safest to call it a file if we do not know */
127 inode->i_mode |= S_IFREG;
128 cFYI(1, ("unknown type %d", le32_to_cpu(info->Type)));
129 break;
130 }
131
132 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) &&
133 !force_uid_gid)
134 inode->i_uid = cifs_sb->mnt_uid;
135 else
136 inode->i_uid = le64_to_cpu(info->Uid);
137
138 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) &&
139 !force_uid_gid)
140 inode->i_gid = cifs_sb->mnt_gid;
141 else
142 inode->i_gid = le64_to_cpu(info->Gid);
143
144 inode->i_nlink = le64_to_cpu(info->Nlinks);
145
146 spin_lock(&inode->i_lock);
147 if (is_size_safe_to_change(cifsInfo, end_of_file)) {
148 /*
149 * We can not safely change the file size here if the client
150 * is writing to it due to potential races.
151 */
152 i_size_write(inode, end_of_file);
153
154 /*
155 * i_blocks is not related to (i_size / i_blksize),
156 * but instead 512 byte (2**9) size is required for
157 * calculating num blocks.
158 */
159 inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
160 }
161 spin_unlock(&inode->i_lock);
162}
163
Steve Frenchb9a32602008-05-20 21:52:32 +0000164
165/*
166 * Needed to setup inode data for the directory which is the
167 * junction to the new submount (ie to setup the fake directory
168 * which represents a DFS referral)
169 */
Steve French0e4bbde2008-05-20 19:50:46 +0000170static void fill_fake_finddataunix(FILE_UNIX_BASIC_INFO *pfnd_dat,
171 struct super_block *sb)
172{
173 struct inode *pinode = NULL;
174
Dave Jones0a891ad2008-05-22 14:20:21 +0000175 memset(pfnd_dat, 0, sizeof(FILE_UNIX_BASIC_INFO));
Steve French0e4bbde2008-05-20 19:50:46 +0000176
177/* __le64 pfnd_dat->EndOfFile = cpu_to_le64(0);
178 __le64 pfnd_dat->NumOfBytes = cpu_to_le64(0);
179 __u64 UniqueId = 0; */
180 pfnd_dat->LastStatusChange =
181 cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
182 pfnd_dat->LastAccessTime =
183 cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
184 pfnd_dat->LastModificationTime =
185 cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
186 pfnd_dat->Type = cpu_to_le32(UNIX_DIR);
187 pfnd_dat->Permissions = cpu_to_le64(S_IXUGO | S_IRWXU);
188 pfnd_dat->Nlinks = cpu_to_le64(2);
189 if (sb->s_root)
190 pinode = sb->s_root->d_inode;
191 if (pinode == NULL)
192 return;
193
194 /* fill in default values for the remaining based on root
195 inode since we can not query the server for this inode info */
196 pfnd_dat->DevMajor = cpu_to_le64(MAJOR(pinode->i_rdev));
197 pfnd_dat->DevMinor = cpu_to_le64(MINOR(pinode->i_rdev));
198 pfnd_dat->Uid = cpu_to_le64(pinode->i_uid);
199 pfnd_dat->Gid = cpu_to_le64(pinode->i_gid);
200}
201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202int cifs_get_inode_info_unix(struct inode **pinode,
Steve French646dd532008-05-15 01:50:56 +0000203 const unsigned char *full_path, struct super_block *sb, int xid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204{
205 int rc = 0;
Steve French0e4bbde2008-05-20 19:50:46 +0000206 FILE_UNIX_BASIC_INFO find_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 struct cifsTconInfo *pTcon;
208 struct inode *inode;
209 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Igor Mammedov79626702008-03-09 03:44:18 +0000210 bool is_dfs_referral = false;
Steve French0e4bbde2008-05-20 19:50:46 +0000211 struct cifsInodeInfo *cifsInfo;
212 __u64 num_of_bytes;
213 __u64 end_of_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214
215 pTcon = cifs_sb->tcon;
Steve French646dd532008-05-15 01:50:56 +0000216 cFYI(1, ("Getting info on %s", full_path));
Igor Mammedov79626702008-03-09 03:44:18 +0000217
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 /* could have done a find first instead but this returns more info */
Steve French0e4bbde2008-05-20 19:50:46 +0000219 rc = CIFSSMBUnixQPathInfo(xid, pTcon, full_path, &find_data,
Steve French737b7582005-04-28 22:41:06 -0700220 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
221 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Laytone911d0c2008-07-12 13:47:59 -0700222 if (rc == -EREMOTE && !is_dfs_referral) {
223 is_dfs_referral = true;
224 cFYI(DBG2, ("DFS ref"));
225 /* for DFS, server does not give us real inode data */
226 fill_fake_finddataunix(&find_data, sb);
227 rc = 0;
228 } else if (rc)
229 goto cgiiu_exit;
230
Steve French0e4bbde2008-05-20 19:50:46 +0000231 num_of_bytes = le64_to_cpu(find_data.NumOfBytes);
232 end_of_file = le64_to_cpu(find_data.EndOfFile);
233
234 /* get new inode */
235 if (*pinode == NULL) {
236 *pinode = new_inode(sb);
237 if (*pinode == NULL) {
238 rc = -ENOMEM;
Jeff Laytone911d0c2008-07-12 13:47:59 -0700239 goto cgiiu_exit;
Steve French0e4bbde2008-05-20 19:50:46 +0000240 }
241 /* Is an i_ino of zero legal? */
242 /* note ino incremented to unique num in new_inode */
243 /* Are there sanity checks we can use to ensure that
244 the server is really filling in that field? */
245 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
246 (*pinode)->i_ino = (unsigned long)find_data.UniqueId;
247
248 if (sb->s_flags & MS_NOATIME)
249 (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
250
251 insert_inode_hash(*pinode);
252 }
253
254 inode = *pinode;
255 cifsInfo = CIFS_I(inode);
256
257 cFYI(1, ("Old time %ld", cifsInfo->time));
258 cifsInfo->time = jiffies;
259 cFYI(1, ("New time %ld", cifsInfo->time));
260 /* this is ok to set on every inode revalidate */
261 atomic_set(&cifsInfo->inUse, 1);
262
263 cifs_unix_info_to_inode(inode, &find_data, 0);
264
265 if (num_of_bytes < end_of_file)
266 cFYI(1, ("allocation size less than end of file"));
267 cFYI(1, ("Size %ld and blocks %llu",
268 (unsigned long) inode->i_size,
269 (unsigned long long)inode->i_blocks));
270
271 cifs_set_ops(inode, is_dfs_referral);
Igor Mammedov79626702008-03-09 03:44:18 +0000272cgiiu_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 return rc;
274}
275
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000276static int decode_sfu_inode(struct inode *inode, __u64 size,
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800277 const unsigned char *path,
278 struct cifs_sb_info *cifs_sb, int xid)
279{
280 int rc;
Steve French4b18f2a2008-04-29 00:06:05 +0000281 int oplock = 0;
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800282 __u16 netfid;
283 struct cifsTconInfo *pTcon = cifs_sb->tcon;
Steve French86c96b42005-11-18 20:25:31 -0800284 char buf[24];
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800285 unsigned int bytes_read;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000286 char *pbuf;
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800287
288 pbuf = buf;
289
Steve French4523cc32007-04-30 20:13:06 +0000290 if (size == 0) {
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800291 inode->i_mode |= S_IFIFO;
292 return 0;
293 } else if (size < 8) {
294 return -EINVAL; /* EOPNOTSUPP? */
295 }
Steve French50c2f752007-07-13 00:33:32 +0000296
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800297 rc = CIFSSMBOpen(xid, pTcon, path, FILE_OPEN, GENERIC_READ,
298 CREATE_NOT_DIR, &netfid, &oplock, NULL,
299 cifs_sb->local_nls,
300 cifs_sb->mnt_cifs_flags &
301 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000302 if (rc == 0) {
Steve Frenchec637e32005-12-12 20:53:18 -0800303 int buf_type = CIFS_NO_BUFFER;
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800304 /* Read header */
305 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000306 netfid,
Steve French86c96b42005-11-18 20:25:31 -0800307 24 /* length */, 0 /* offset */,
Steve Frenchec637e32005-12-12 20:53:18 -0800308 &bytes_read, &pbuf, &buf_type);
Steve French4523cc32007-04-30 20:13:06 +0000309 if ((rc == 0) && (bytes_read >= 8)) {
310 if (memcmp("IntxBLK", pbuf, 8) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000311 cFYI(1, ("Block device"));
Steve French3020a1f2005-11-18 11:31:10 -0800312 inode->i_mode |= S_IFBLK;
Steve French4523cc32007-04-30 20:13:06 +0000313 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800314 /* we have enough to decode dev num */
315 __u64 mjr; /* major */
316 __u64 mnr; /* minor */
317 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
318 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
319 inode->i_rdev = MKDEV(mjr, mnr);
320 }
Steve French4523cc32007-04-30 20:13:06 +0000321 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000322 cFYI(1, ("Char device"));
Steve French3020a1f2005-11-18 11:31:10 -0800323 inode->i_mode |= S_IFCHR;
Steve French4523cc32007-04-30 20:13:06 +0000324 if (bytes_read == 24) {
Steve French86c96b42005-11-18 20:25:31 -0800325 /* we have enough to decode dev num */
326 __u64 mjr; /* major */
327 __u64 mnr; /* minor */
328 mjr = le64_to_cpu(*(__le64 *)(pbuf+8));
329 mnr = le64_to_cpu(*(__le64 *)(pbuf+16));
330 inode->i_rdev = MKDEV(mjr, mnr);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000331 }
Steve French4523cc32007-04-30 20:13:06 +0000332 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000333 cFYI(1, ("Symlink"));
Steve French3020a1f2005-11-18 11:31:10 -0800334 inode->i_mode |= S_IFLNK;
Steve French86c96b42005-11-18 20:25:31 -0800335 } else {
336 inode->i_mode |= S_IFREG; /* file? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000337 rc = -EOPNOTSUPP;
Steve French86c96b42005-11-18 20:25:31 -0800338 }
Steve French3020a1f2005-11-18 11:31:10 -0800339 } else {
340 inode->i_mode |= S_IFREG; /* then it is a file */
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000341 rc = -EOPNOTSUPP; /* or some unknown SFU type */
342 }
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800343 CIFSSMBClose(xid, pTcon, netfid);
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800344 }
345 return rc;
Steve Frenchd6e2f2a2005-11-15 16:43:39 -0800346}
347
Steve French9e294f12005-11-17 16:59:21 -0800348#define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
349
Steve French953f8682007-10-31 04:54:42 +0000350static int get_sfu_mode(struct inode *inode,
Steve French9e294f12005-11-17 16:59:21 -0800351 const unsigned char *path,
352 struct cifs_sb_info *cifs_sb, int xid)
353{
Steve French3020a1f2005-11-18 11:31:10 -0800354#ifdef CONFIG_CIFS_XATTR
Steve French9e294f12005-11-17 16:59:21 -0800355 ssize_t rc;
356 char ea_value[4];
357 __u32 mode;
358
359 rc = CIFSSMBQueryEA(xid, cifs_sb->tcon, path, "SETFILEBITS",
360 ea_value, 4 /* size of buf */, cifs_sb->local_nls,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000361 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French4523cc32007-04-30 20:13:06 +0000362 if (rc < 0)
Steve French9e294f12005-11-17 16:59:21 -0800363 return (int)rc;
364 else if (rc > 3) {
365 mode = le32_to_cpu(*((__le32 *)ea_value));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000366 inode->i_mode &= ~SFBITS_MASK;
367 cFYI(1, ("special bits 0%o org mode 0%o", mode, inode->i_mode));
Steve French9e294f12005-11-17 16:59:21 -0800368 inode->i_mode = (mode & SFBITS_MASK) | inode->i_mode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000369 cFYI(1, ("special mode bits 0%o", mode));
Steve French9e294f12005-11-17 16:59:21 -0800370 return 0;
371 } else {
372 return 0;
373 }
Steve French3020a1f2005-11-18 11:31:10 -0800374#else
375 return -EOPNOTSUPP;
376#endif
Steve French9e294f12005-11-17 16:59:21 -0800377}
378
Steve Frenchb9a32602008-05-20 21:52:32 +0000379/*
380 * Needed to setup inode data for the directory which is the
381 * junction to the new submount (ie to setup the fake directory
382 * which represents a DFS referral)
383 */
384static void fill_fake_finddata(FILE_ALL_INFO *pfnd_dat,
385 struct super_block *sb)
386{
Dave Jones0a891ad2008-05-22 14:20:21 +0000387 memset(pfnd_dat, 0, sizeof(FILE_ALL_INFO));
Steve Frenchb9a32602008-05-20 21:52:32 +0000388
389/* __le64 pfnd_dat->AllocationSize = cpu_to_le64(0);
390 __le64 pfnd_dat->EndOfFile = cpu_to_le64(0);
391 __u8 pfnd_dat->DeletePending = 0;
392 __u8 pfnd_data->Directory = 0;
393 __le32 pfnd_dat->EASize = 0;
394 __u64 pfnd_dat->IndexNumber = 0;
395 __u64 pfnd_dat->IndexNumber1 = 0; */
396 pfnd_dat->CreationTime =
397 cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
398 pfnd_dat->LastAccessTime =
399 cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
400 pfnd_dat->LastWriteTime =
401 cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
402 pfnd_dat->ChangeTime =
403 cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
404 pfnd_dat->Attributes = cpu_to_le32(ATTR_DIRECTORY);
405 pfnd_dat->NumberOfLinks = cpu_to_le32(2);
406}
407
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408int cifs_get_inode_info(struct inode **pinode,
Steve French646dd532008-05-15 01:50:56 +0000409 const unsigned char *full_path, FILE_ALL_INFO *pfindData,
Steve French8b1327f2008-03-14 22:37:16 +0000410 struct super_block *sb, int xid, const __u16 *pfid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411{
412 int rc = 0;
Steve Frenchb9a32602008-05-20 21:52:32 +0000413 __u32 attr;
414 struct cifsInodeInfo *cifsInfo;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 struct cifsTconInfo *pTcon;
416 struct inode *inode;
417 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 char *buf = NULL;
Steve French5ade9de2008-05-02 20:56:23 +0000419 bool adjustTZ = false;
Igor Mammedov79626702008-03-09 03:44:18 +0000420 bool is_dfs_referral = false;
Jeff Layton4468eb32008-05-22 09:31:40 -0400421 umode_t default_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422
423 pTcon = cifs_sb->tcon;
Steve French646dd532008-05-15 01:50:56 +0000424 cFYI(1, ("Getting info on %s", full_path));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700426 if ((pfindData == NULL) && (*pinode != NULL)) {
427 if (CIFS_I(*pinode)->clientCanCacheRead) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000428 cFYI(1, ("No need to revalidate cached inode sizes"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 return rc;
430 }
431 }
432
433 /* if file info not passed in then get it from server */
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700434 if (pfindData == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
Steve Frenchd0d2f2d2005-06-02 15:12:36 -0700436 if (buf == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 return -ENOMEM;
438 pfindData = (FILE_ALL_INFO *)buf;
Igor Mammedov79626702008-03-09 03:44:18 +0000439
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 /* could do find first instead but this returns more info */
Igor Mammedov79626702008-03-09 03:44:18 +0000441 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
Steve Frenchacf1a1b2006-10-12 03:28:28 +0000442 0 /* not legacy */,
Steve French6b8edfe2005-08-23 20:26:03 -0700443 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700444 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French6b8edfe2005-08-23 20:26:03 -0700445 /* BB optimize code so we do not make the above call
446 when server claims no NT SMB support and the above call
447 failed at least once - set flag in tcon or mount */
Steve French4523cc32007-04-30 20:13:06 +0000448 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
Igor Mammedov79626702008-03-09 03:44:18 +0000449 rc = SMBQueryInformation(xid, pTcon, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000450 pfindData, cifs_sb->local_nls,
Steve French6b8edfe2005-08-23 20:26:03 -0700451 cifs_sb->mnt_cifs_flags &
452 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French4b18f2a2008-04-29 00:06:05 +0000453 adjustTZ = true;
Steve French6b8edfe2005-08-23 20:26:03 -0700454 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 }
456 /* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
Steve Frenchb9a32602008-05-20 21:52:32 +0000457 if (rc == -EREMOTE) {
458 is_dfs_referral = true;
459 fill_fake_finddata(pfindData, sb);
460 rc = 0;
461 } else if (rc)
Igor Mammedov79626702008-03-09 03:44:18 +0000462 goto cgii_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
Steve Frenchb9a32602008-05-20 21:52:32 +0000464 attr = le32_to_cpu(pfindData->Attributes);
465
466 /* get new inode */
467 if (*pinode == NULL) {
468 *pinode = new_inode(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 if (*pinode == NULL) {
Steve Frenchb9a32602008-05-20 21:52:32 +0000470 rc = -ENOMEM;
471 goto cgii_exit;
472 }
473 /* Is an i_ino of zero legal? Can we use that to check
474 if the server supports returning inode numbers? Are
475 there other sanity checks we can use to ensure that
476 the server is really filling in that field? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
Steve Frenchb9a32602008-05-20 21:52:32 +0000478 /* We can not use the IndexNumber field by default from
479 Windows or Samba (in ALL_INFO buf) but we can request
480 it explicitly. It may not be unique presumably if
481 the server has multiple devices mounted under one share */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482
Steve Frenchb9a32602008-05-20 21:52:32 +0000483 /* There may be higher info levels that work but are
484 there Windows server or network appliances for which
485 IndexNumber field is not guaranteed unique? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486
Steve Frenchb9a32602008-05-20 21:52:32 +0000487 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
488 int rc1 = 0;
489 __u64 inode_num;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Steve Frenchb9a32602008-05-20 21:52:32 +0000491 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
Steve French646dd532008-05-15 01:50:56 +0000492 full_path, &inode_num,
Steve French737b7582005-04-28 22:41:06 -0700493 cifs_sb->local_nls,
494 cifs_sb->mnt_cifs_flags &
495 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchb9a32602008-05-20 21:52:32 +0000496 if (rc1) {
497 cFYI(1, ("GetSrvInodeNum rc %d", rc1));
498 /* BB EOPNOSUPP disable SERVER_INUM? */
499 } else /* do we need cast or hash to ino? */
500 (*pinode)->i_ino = inode_num;
501 } /* else ino incremented to unique num in new_inode*/
502 if (sb->s_flags & MS_NOATIME)
503 (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
504 insert_inode_hash(*pinode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 }
Steve Frenchb9a32602008-05-20 21:52:32 +0000506 inode = *pinode;
507 cifsInfo = CIFS_I(inode);
508 cifsInfo->cifsAttrs = attr;
Jeff Layton9a8165f2008-10-17 21:03:20 -0400509 cifsInfo->delete_pending = pfindData->DeletePending ? true : false;
Steve Frenchb9a32602008-05-20 21:52:32 +0000510 cFYI(1, ("Old time %ld", cifsInfo->time));
511 cifsInfo->time = jiffies;
512 cFYI(1, ("New time %ld", cifsInfo->time));
513
514 /* blksize needs to be multiple of two. So safer to default to
515 blksize and blkbits set in superblock so 2**blkbits and blksize
516 will match rather than setting to:
517 (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
518
519 /* Linux can not store file creation time so ignore it */
520 if (pfindData->LastAccessTime)
521 inode->i_atime = cifs_NTtimeToUnix
522 (le64_to_cpu(pfindData->LastAccessTime));
523 else /* do not need to use current_fs_time - time not stored */
524 inode->i_atime = CURRENT_TIME;
525 inode->i_mtime =
526 cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
527 inode->i_ctime =
528 cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
529 cFYI(DBG2, ("Attributes came in as 0x%x", attr));
530 if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
531 inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
532 inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
533 }
534
Jeff Layton4468eb32008-05-22 09:31:40 -0400535 /* get default inode mode */
536 if (attr & ATTR_DIRECTORY)
537 default_mode = cifs_sb->mnt_dir_mode;
538 else
539 default_mode = cifs_sb->mnt_file_mode;
Steve Frenchb9a32602008-05-20 21:52:32 +0000540
Jeff Layton4468eb32008-05-22 09:31:40 -0400541 /* set permission bits */
542 if (atomic_read(&cifsInfo->inUse) == 0 ||
543 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
544 inode->i_mode = default_mode;
545 else {
546 /* just reenable write bits if !ATTR_READONLY */
547 if ((inode->i_mode & S_IWUGO) == 0 &&
548 (attr & ATTR_READONLY) == 0)
549 inode->i_mode |= (S_IWUGO & default_mode);
Ilpo Järvinenaab3a8c2008-08-19 14:23:37 +0000550
551 inode->i_mode &= ~S_IFMT;
Jeff Layton4468eb32008-05-22 09:31:40 -0400552 }
553 /* clear write bits if ATTR_READONLY is set */
554 if (attr & ATTR_READONLY)
555 inode->i_mode &= ~S_IWUGO;
556
557 /* set inode type */
558 if ((attr & ATTR_SYSTEM) &&
559 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)) {
560 /* no need to fix endianness on 0 */
561 if (pfindData->EndOfFile == 0)
562 inode->i_mode |= S_IFIFO;
563 else if (decode_sfu_inode(inode,
564 le64_to_cpu(pfindData->EndOfFile),
565 full_path, cifs_sb, xid))
566 cFYI(1, ("unknown SFU file type\n"));
Steve Frenchb9a32602008-05-20 21:52:32 +0000567 } else {
Jeff Layton4468eb32008-05-22 09:31:40 -0400568 if (attr & ATTR_DIRECTORY)
569 inode->i_mode |= S_IFDIR;
570 else
571 inode->i_mode |= S_IFREG;
Steve Frenchb9a32602008-05-20 21:52:32 +0000572 }
573
574 spin_lock(&inode->i_lock);
575 if (is_size_safe_to_change(cifsInfo,
576 le64_to_cpu(pfindData->EndOfFile))) {
577 /* can not safely shrink the file size here if the
578 client is writing to it due to potential races */
579 i_size_write(inode, le64_to_cpu(pfindData->EndOfFile));
580
581 /* 512 bytes (2**9) is the fake blocksize that must be
582 used for this calculation */
583 inode->i_blocks = (512 - 1 + le64_to_cpu(
584 pfindData->AllocationSize)) >> 9;
585 }
586 spin_unlock(&inode->i_lock);
587
588 inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
589
590 /* BB fill in uid and gid here? with help from winbind?
591 or retrieve from NTFS stream extended attribute */
592#ifdef CONFIG_CIFS_EXPERIMENTAL
593 /* fill in 0777 bits from ACL */
594 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
595 cFYI(1, ("Getting mode bits from ACL"));
596 acl_to_uid_mode(inode, full_path, pfid);
597 }
598#endif
599 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
600 /* fill in remaining high mode bits e.g. SUID, VTX */
601 get_sfu_mode(inode, full_path, cifs_sb, xid);
602 } else if (atomic_read(&cifsInfo->inUse) == 0) {
603 inode->i_uid = cifs_sb->mnt_uid;
604 inode->i_gid = cifs_sb->mnt_gid;
605 /* set so we do not keep refreshing these fields with
606 bad data after user has changed them in memory */
607 atomic_set(&cifsInfo->inUse, 1);
608 }
609
610 cifs_set_ops(inode, is_dfs_referral);
611
612
613
614
Igor Mammedov79626702008-03-09 03:44:18 +0000615cgii_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 kfree(buf);
617 return rc;
618}
619
Steve French7f8ed422007-09-28 22:28:55 +0000620static const struct inode_operations cifs_ipc_inode_ops = {
621 .lookup = cifs_lookup,
622};
623
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624/* gets root inode */
David Howellsce634ab2008-02-07 00:15:33 -0800625struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626{
David Howellsce634ab2008-02-07 00:15:33 -0800627 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 struct cifs_sb_info *cifs_sb;
David Howellsce634ab2008-02-07 00:15:33 -0800629 struct inode *inode;
630 long rc;
631
632 inode = iget_locked(sb, ino);
633 if (!inode)
634 return ERR_PTR(-ENOMEM);
635 if (!(inode->i_state & I_NEW))
636 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
638 cifs_sb = CIFS_SB(inode->i_sb);
639 xid = GetXid();
Steve Frenchc18c8422007-07-18 23:21:09 +0000640
641 if (cifs_sb->tcon->unix_ext)
Steve French7f8ed422007-09-28 22:28:55 +0000642 rc = cifs_get_inode_info_unix(&inode, "", inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 else
Steve French8b1327f2008-03-14 22:37:16 +0000644 rc = cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid,
645 NULL);
Steve French7f8ed422007-09-28 22:28:55 +0000646 if (rc && cifs_sb->tcon->ipc) {
647 cFYI(1, ("ipc connection - fake read inode"));
648 inode->i_mode |= S_IFDIR;
649 inode->i_nlink = 2;
650 inode->i_op = &cifs_ipc_inode_ops;
651 inode->i_fop = &simple_dir_operations;
652 inode->i_uid = cifs_sb->mnt_uid;
653 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchad661332008-08-12 14:14:40 +0000654 } else if (rc) {
David Howellsce634ab2008-02-07 00:15:33 -0800655 _FreeXid(xid);
656 iget_failed(inode);
657 return ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +0000658 }
659
David Howellsce634ab2008-02-07 00:15:33 -0800660 unlock_new_inode(inode);
661
662 /* can not call macro FreeXid here since in a void func
663 * TODO: This is no longer true
664 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 _FreeXid(xid);
David Howellsce634ab2008-02-07 00:15:33 -0800666 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667}
668
Steve French388e57b2008-09-16 23:50:58 +0000669static int
670cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
671 char *full_path, __u32 dosattr)
672{
673 int rc;
674 int oplock = 0;
675 __u16 netfid;
676 __u32 netpid;
677 bool set_time = false;
678 struct cifsFileInfo *open_file;
679 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
680 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
681 struct cifsTconInfo *pTcon = cifs_sb->tcon;
682 FILE_BASIC_INFO info_buf;
683
684 if (attrs->ia_valid & ATTR_ATIME) {
685 set_time = true;
686 info_buf.LastAccessTime =
687 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
688 } else
689 info_buf.LastAccessTime = 0;
690
691 if (attrs->ia_valid & ATTR_MTIME) {
692 set_time = true;
693 info_buf.LastWriteTime =
694 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
695 } else
696 info_buf.LastWriteTime = 0;
697
698 /*
699 * Samba throws this field away, but windows may actually use it.
700 * Do not set ctime unless other time stamps are changed explicitly
701 * (i.e. by utimes()) since we would then have a mix of client and
702 * server times.
703 */
704 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
705 cFYI(1, ("CIFS - CTIME changed"));
706 info_buf.ChangeTime =
707 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
708 } else
709 info_buf.ChangeTime = 0;
710
711 info_buf.CreationTime = 0; /* don't change */
712 info_buf.Attributes = cpu_to_le32(dosattr);
713
714 /*
715 * If the file is already open for write, just use that fileid
716 */
717 open_file = find_writable_file(cifsInode);
718 if (open_file) {
719 netfid = open_file->netfid;
720 netpid = open_file->pid;
721 goto set_via_filehandle;
722 }
723
724 /*
725 * NT4 apparently returns success on this call, but it doesn't
726 * really work.
727 */
728 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
729 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
730 &info_buf, cifs_sb->local_nls,
731 cifs_sb->mnt_cifs_flags &
732 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +0000733 if (rc == 0) {
734 cifsInode->cifsAttrs = dosattr;
735 goto out;
736 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
Steve French388e57b2008-09-16 23:50:58 +0000737 goto out;
738 }
739
740 cFYI(1, ("calling SetFileInfo since SetPathInfo for "
741 "times not supported by this server"));
742 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
743 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
744 CREATE_NOT_DIR, &netfid, &oplock,
745 NULL, cifs_sb->local_nls,
746 cifs_sb->mnt_cifs_flags &
747 CIFS_MOUNT_MAP_SPECIAL_CHR);
748
749 if (rc != 0) {
750 if (rc == -EIO)
751 rc = -EINVAL;
752 goto out;
753 }
754
755 netpid = current->tgid;
756
757set_via_filehandle:
758 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
Steve Frenchd3889082008-09-24 19:22:52 +0000759 if (!rc)
760 cifsInode->cifsAttrs = dosattr;
761
Steve French388e57b2008-09-16 23:50:58 +0000762 if (open_file == NULL)
763 CIFSSMBClose(xid, pTcon, netfid);
764 else
765 atomic_dec(&open_file->wrtPending);
766out:
767 return rc;
768}
769
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400770/*
771 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
772 * and rename it to a random name that hopefully won't conflict with
773 * anything else.
774 */
775static int
Steve French32709582008-10-20 00:44:19 +0000776cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400777{
778 int oplock = 0;
779 int rc;
780 __u16 netfid;
Steve French32709582008-10-20 00:44:19 +0000781 struct inode *inode = dentry->d_inode;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400782 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
783 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
784 struct cifsTconInfo *tcon = cifs_sb->tcon;
Steve French32709582008-10-20 00:44:19 +0000785 __u32 dosattr, origattr;
786 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400787
788 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
Jeff Laytondd1db2d2008-10-16 19:27:12 -0400789 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400790 &netfid, &oplock, NULL, cifs_sb->local_nls,
791 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
792 if (rc != 0)
793 goto out;
794
Steve French32709582008-10-20 00:44:19 +0000795 origattr = cifsInode->cifsAttrs;
796 if (origattr == 0)
797 origattr |= ATTR_NORMAL;
798
799 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400800 if (dosattr == 0)
801 dosattr |= ATTR_NORMAL;
802 dosattr |= ATTR_HIDDEN;
803
Steve French32709582008-10-20 00:44:19 +0000804 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
805 if (dosattr != origattr) {
806 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
807 if (info_buf == NULL) {
808 rc = -ENOMEM;
809 goto out_close;
810 }
811 info_buf->Attributes = cpu_to_le32(dosattr);
812 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
813 current->tgid);
814 /* although we would like to mark the file hidden
815 if that fails we will still try to rename it */
Steve French41346092008-10-20 18:24:42 +0000816 if (rc != 0)
Steve French32709582008-10-20 00:44:19 +0000817 cifsInode->cifsAttrs = dosattr;
818 else
819 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400820 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400821
Jeff Laytondd1db2d2008-10-16 19:27:12 -0400822 /* rename the file */
823 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400824 cifs_sb->mnt_cifs_flags &
825 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French32709582008-10-20 00:44:19 +0000826 if (rc != 0) {
827 rc = -ETXTBSY;
828 goto undo_setattr;
829 }
Jeff Layton6d22f092008-09-23 11:48:35 -0400830
Steve French32709582008-10-20 00:44:19 +0000831 /* try to set DELETE_ON_CLOSE */
832 if (!cifsInode->delete_pending) {
833 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
834 current->tgid);
835 /*
836 * some samba versions return -ENOENT when we try to set the
837 * file disposition here. Likely a samba bug, but work around
838 * it for now. This means that some cifsXXX files may hang
839 * around after they shouldn't.
840 *
841 * BB: remove this hack after more servers have the fix
842 */
843 if (rc == -ENOENT)
844 rc = 0;
845 else if (rc != 0) {
846 rc = -ETXTBSY;
847 goto undo_rename;
848 }
849 cifsInode->delete_pending = true;
850 }
Jeff Layton7ce86d52008-09-24 11:32:59 -0400851
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400852out_close:
853 CIFSSMBClose(xid, tcon, netfid);
854out:
Steve French32709582008-10-20 00:44:19 +0000855 kfree(info_buf);
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400856 return rc;
Steve French32709582008-10-20 00:44:19 +0000857
858 /*
859 * reset everything back to the original state. Don't bother
860 * dealing with errors here since we can't do anything about
861 * them anyway.
862 */
863undo_rename:
864 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
865 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
866 CIFS_MOUNT_MAP_SPECIAL_CHR);
867undo_setattr:
868 if (dosattr != origattr) {
869 info_buf->Attributes = cpu_to_le32(origattr);
870 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
871 current->tgid))
872 cifsInode->cifsAttrs = origattr;
873 }
874
875 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400876}
877
Jeff Layton5f0319a2008-09-16 14:05:16 -0400878int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879{
880 int rc = 0;
881 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 char *full_path = NULL;
Jeff Layton5f0319a2008-09-16 14:05:16 -0400883 struct inode *inode = dentry->d_inode;
Steve French60502472008-10-07 18:42:52 +0000884 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Jeff Layton5f0319a2008-09-16 14:05:16 -0400885 struct super_block *sb = dir->i_sb;
886 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
887 struct cifsTconInfo *tcon = cifs_sb->tcon;
Steve French60502472008-10-07 18:42:52 +0000888 struct iattr *attrs = NULL;
889 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890
Jeff Layton5f0319a2008-09-16 14:05:16 -0400891 cFYI(1, ("cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892
893 xid = GetXid();
894
Jeff Layton5f0319a2008-09-16 14:05:16 -0400895 /* Unlink can be called from rename so we can not take the
896 * sb->s_vfs_rename_mutex here */
897 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 if (full_path == NULL) {
899 FreeXid(xid);
900 return -ENOMEM;
901 }
Steve French2d785a52007-07-15 01:48:57 +0000902
Jeff Layton5f0319a2008-09-16 14:05:16 -0400903 if ((tcon->ses->capabilities & CAP_UNIX) &&
Steve French2d785a52007-07-15 01:48:57 +0000904 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Jeff Layton5f0319a2008-09-16 14:05:16 -0400905 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
906 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +0000907 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
908 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
909 cFYI(1, ("posix del rc %d", rc));
910 if ((rc == 0) || (rc == -ENOENT))
911 goto psx_del_no_retry;
912 }
913
Steve French60502472008-10-07 18:42:52 +0000914retry_std_delete:
Jeff Layton5f0319a2008-09-16 14:05:16 -0400915 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
Steve French737b7582005-04-28 22:41:06 -0700916 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French60502472008-10-07 18:42:52 +0000917
Steve French2d785a52007-07-15 01:48:57 +0000918psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -0400920 if (inode)
921 drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -0400923 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 } else if (rc == -ETXTBSY) {
Steve French32709582008-10-20 00:44:19 +0000925 rc = cifs_rename_pending_delete(full_path, dentry, xid);
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400926 if (rc == 0)
927 drop_nlink(inode);
Steve French60502472008-10-07 18:42:52 +0000928 } else if (rc == -EACCES && dosattr == 0) {
Steve French388e57b2008-09-16 23:50:58 +0000929 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
930 if (attrs == NULL) {
931 rc = -ENOMEM;
932 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 }
Steve French388e57b2008-09-16 23:50:58 +0000934
935 /* try to reset dos attributes */
Steve French60502472008-10-07 18:42:52 +0000936 origattr = cifsInode->cifsAttrs;
937 if (origattr == 0)
938 origattr |= ATTR_NORMAL;
939 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +0000940 if (dosattr == 0)
941 dosattr |= ATTR_NORMAL;
942 dosattr |= ATTR_HIDDEN;
943
944 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +0000945 if (rc != 0)
946 goto out_reval;
Steve French60502472008-10-07 18:42:52 +0000947
948 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700949 }
Steve French60502472008-10-07 18:42:52 +0000950
951 /* undo the setattr if we errored out and it's needed */
952 if (rc != 0 && dosattr != 0)
953 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
954
Steve French388e57b2008-09-16 23:50:58 +0000955out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -0400956 if (inode) {
957 cifsInode = CIFS_I(inode);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -0500958 cifsInode->time = 0; /* will force revalidate to get info
959 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -0400960 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -0500961 }
Jeff Layton5f0319a2008-09-16 14:05:16 -0400962 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
963 cifsInode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +0000964 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965
966 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +0000967 kfree(attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 FreeXid(xid);
969 return rc;
970}
971
Steve French2dd29d32007-04-23 22:07:35 +0000972static void posix_fill_in_inode(struct inode *tmp_inode,
Steve French0b442d22008-02-26 03:44:02 +0000973 FILE_UNIX_BASIC_INFO *pData, int isNewInode)
Steve French2dd29d32007-04-23 22:07:35 +0000974{
Christoph Hellwig75f12982008-02-25 20:25:21 +0000975 struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
Steve French2dd29d32007-04-23 22:07:35 +0000976 loff_t local_size;
977 struct timespec local_mtime;
978
Steve French2dd29d32007-04-23 22:07:35 +0000979 cifsInfo->time = jiffies;
980 atomic_inc(&cifsInfo->inUse);
981
982 /* save mtime and size */
983 local_mtime = tmp_inode->i_mtime;
984 local_size = tmp_inode->i_size;
985
Christoph Hellwig75f12982008-02-25 20:25:21 +0000986 cifs_unix_info_to_inode(tmp_inode, pData, 1);
Igor Mammedov79626702008-03-09 03:44:18 +0000987 cifs_set_ops(tmp_inode, false);
Steve French2dd29d32007-04-23 22:07:35 +0000988
Christoph Hellwig75f12982008-02-25 20:25:21 +0000989 if (!S_ISREG(tmp_inode->i_mode))
990 return;
991
992 /*
993 * No sense invalidating pages for new inode
994 * since we we have not started caching
995 * readahead file data yet.
996 */
997 if (isNewInode)
998 return;
999
1000 if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
1001 (local_size == tmp_inode->i_size)) {
1002 cFYI(1, ("inode exists but unchanged"));
Steve French2dd29d32007-04-23 22:07:35 +00001003 } else {
Christoph Hellwig75f12982008-02-25 20:25:21 +00001004 /* file may have changed on server */
1005 cFYI(1, ("invalidate inode, readdir detected change"));
1006 invalidate_remote_inode(tmp_inode);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001007 }
Steve French2dd29d32007-04-23 22:07:35 +00001008}
1009
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1011{
Jeff Layton6b37faa2008-10-06 21:54:41 +00001012 int rc = 0, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013 int xid;
1014 struct cifs_sb_info *cifs_sb;
1015 struct cifsTconInfo *pTcon;
1016 char *full_path = NULL;
1017 struct inode *newinode = NULL;
1018
Steve French6473a552005-11-29 20:20:10 -08001019 cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020
1021 xid = GetXid();
1022
1023 cifs_sb = CIFS_SB(inode->i_sb);
1024 pTcon = cifs_sb->tcon;
1025
Steve French7f573562005-08-30 11:32:14 -07001026 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 if (full_path == NULL) {
1028 FreeXid(xid);
1029 return -ENOMEM;
1030 }
Steve French50c2f752007-07-13 00:33:32 +00001031
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001032 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1033 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Steve French2dd29d32007-04-23 22:07:35 +00001034 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1035 u32 oplock = 0;
Steve Frenchf6d09982008-01-08 23:18:22 +00001036 FILE_UNIX_BASIC_INFO *pInfo =
Steve French2dd29d32007-04-23 22:07:35 +00001037 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001038 if (pInfo == NULL) {
Steve French2dd29d32007-04-23 22:07:35 +00001039 rc = -ENOMEM;
1040 goto mkdir_out;
1041 }
Steve French50c2f752007-07-13 00:33:32 +00001042
Jeffa8cd9252007-09-13 18:38:50 +00001043 mode &= ~current->fs->umask;
Steve French2dd29d32007-04-23 22:07:35 +00001044 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1045 mode, NULL /* netfid */, pInfo, &oplock,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001046 full_path, cifs_sb->local_nls,
1047 cifs_sb->mnt_cifs_flags &
Steve French2dd29d32007-04-23 22:07:35 +00001048 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchc45d7072007-09-17 02:04:21 +00001049 if (rc == -EOPNOTSUPP) {
1050 kfree(pInfo);
1051 goto mkdir_retry_old;
1052 } else if (rc) {
Steve French2dd29d32007-04-23 22:07:35 +00001053 cFYI(1, ("posix mkdir returned 0x%x", rc));
1054 d_drop(direntry);
1055 } else {
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001056 if (pInfo->Type == cpu_to_le32(-1)) {
1057 /* no return info, go query for it */
Steve French5a07cdf2007-09-16 23:12:47 +00001058 kfree(pInfo);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001059 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001060 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001061/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1062 to set uid/gid */
Steve French2dd29d32007-04-23 22:07:35 +00001063 inc_nlink(inode);
1064 if (pTcon->nocase)
1065 direntry->d_op = &cifs_ci_dentry_ops;
1066 else
1067 direntry->d_op = &cifs_dentry_ops;
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001068
1069 newinode = new_inode(inode->i_sb);
Steve French5a07cdf2007-09-16 23:12:47 +00001070 if (newinode == NULL) {
1071 kfree(pInfo);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001072 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001073 }
Jeff Layton6b37faa2008-10-06 21:54:41 +00001074
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001075 /* Is an i_ino of zero legal? */
1076 /* Are there sanity checks we can use to ensure that
1077 the server is really filling in that field? */
1078 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
1079 newinode->i_ino =
1080 (unsigned long)pInfo->UniqueId;
1081 } /* note ino incremented to unique num in new_inode */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001082 if (inode->i_sb->s_flags & MS_NOATIME)
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001083 newinode->i_flags |= S_NOATIME | S_NOCMTIME;
1084 newinode->i_nlink = 2;
1085
1086 insert_inode_hash(newinode);
Steve French2dd29d32007-04-23 22:07:35 +00001087 d_instantiate(direntry, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001088
1089 /* we already checked in POSIXCreate whether
1090 frame was long enough */
1091 posix_fill_in_inode(direntry->d_inode,
Steve French0b442d22008-02-26 03:44:02 +00001092 pInfo, 1 /* NewInode */);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001093#ifdef CONFIG_CIFS_DEBUG2
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001094 cFYI(1, ("instantiated dentry %p %s to inode %p",
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001095 direntry, direntry->d_name.name, newinode));
1096
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001097 if (newinode->i_nlink != 2)
1098 cFYI(1, ("unexpected number of links %d",
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001099 newinode->i_nlink));
1100#endif
Steve French2dd29d32007-04-23 22:07:35 +00001101 }
1102 kfree(pInfo);
1103 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001104 }
Steve Frenchc45d7072007-09-17 02:04:21 +00001105mkdir_retry_old:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Steve French737b7582005-04-28 22:41:06 -07001107 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1108 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 if (rc) {
Steve French26a21b92006-05-31 18:05:34 +00001110 cFYI(1, ("cifs_mkdir returned 0x%x", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 d_drop(direntry);
1112 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001113mkdir_get_info:
Dave Hansend8c76e62006-09-30 23:29:04 -07001114 inc_nlink(inode);
Steve Frenchc18c8422007-07-18 23:21:09 +00001115 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001117 inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118 else
1119 rc = cifs_get_inode_info(&newinode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +00001120 inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121
Steve Frenchb92327f2005-08-22 20:09:43 -07001122 if (pTcon->nocase)
1123 direntry->d_op = &cifs_ci_dentry_ops;
1124 else
1125 direntry->d_op = &cifs_dentry_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 d_instantiate(direntry, newinode);
Steve French2dd29d32007-04-23 22:07:35 +00001127 /* setting nlink not necessary except in cases where we
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001128 * failed to get it from the server or was set bogus */
Steve French2dd29d32007-04-23 22:07:35 +00001129 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001130 direntry->d_inode->i_nlink = 2;
Jeff Layton95089912008-08-06 04:39:02 +00001131
Jeff Layton67750fb2008-05-09 22:28:02 +00001132 mode &= ~current->fs->umask;
Jeff Layton95089912008-08-06 04:39:02 +00001133 /* must turn on setgid bit if parent dir has it */
1134 if (inode->i_mode & S_ISGID)
1135 mode |= S_ISGID;
1136
Steve Frenchc18c8422007-07-18 23:21:09 +00001137 if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001138 struct cifs_unix_set_info_args args = {
1139 .mode = mode,
1140 .ctime = NO_CHANGE_64,
1141 .atime = NO_CHANGE_64,
1142 .mtime = NO_CHANGE_64,
1143 .device = 0,
1144 };
Steve Frenchd0d2f2d2005-06-02 15:12:36 -07001145 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001146 args.uid = (__u64)current->fsuid;
Jeff Layton95089912008-08-06 04:39:02 +00001147 if (inode->i_mode & S_ISGID)
1148 args.gid = (__u64)inode->i_gid;
1149 else
1150 args.gid = (__u64)current->fsgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151 } else {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001152 args.uid = NO_CHANGE_64;
1153 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 }
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001155 CIFSSMBUnixSetInfo(xid, pTcon, full_path, &args,
1156 cifs_sb->local_nls,
1157 cifs_sb->mnt_cifs_flags &
1158 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French3ce53fc2007-06-08 14:55:14 +00001159 } else {
Jeff Layton67750fb2008-05-09 22:28:02 +00001160 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1161 (mode & S_IWUGO) == 0) {
1162 FILE_BASIC_INFO pInfo;
Jeff Layton6b37faa2008-10-06 21:54:41 +00001163 struct cifsInodeInfo *cifsInode;
1164 u32 dosattrs;
1165
Jeff Layton67750fb2008-05-09 22:28:02 +00001166 memset(&pInfo, 0, sizeof(pInfo));
Jeff Layton6b37faa2008-10-06 21:54:41 +00001167 cifsInode = CIFS_I(newinode);
1168 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1169 pInfo.Attributes = cpu_to_le32(dosattrs);
1170 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1171 full_path, &pInfo,
1172 cifs_sb->local_nls,
Jeff Layton67750fb2008-05-09 22:28:02 +00001173 cifs_sb->mnt_cifs_flags &
1174 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +00001175 if (tmprc == 0)
1176 cifsInode->cifsAttrs = dosattrs;
Jeff Layton67750fb2008-05-09 22:28:02 +00001177 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001178 if (direntry->d_inode) {
Jeff Laytonb0fd30d2008-05-22 09:33:34 -04001179 if (cifs_sb->mnt_cifs_flags &
1180 CIFS_MOUNT_DYNPERM)
1181 direntry->d_inode->i_mode =
1182 (mode | S_IFDIR);
Steve French4e94a102008-05-23 18:22:46 +00001183
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001184 if (cifs_sb->mnt_cifs_flags &
Steve French6473a552005-11-29 20:20:10 -08001185 CIFS_MOUNT_SET_UID) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001186 direntry->d_inode->i_uid =
Steve French6473a552005-11-29 20:20:10 -08001187 current->fsuid;
Jeff Layton95089912008-08-06 04:39:02 +00001188 if (inode->i_mode & S_ISGID)
1189 direntry->d_inode->i_gid =
1190 inode->i_gid;
1191 else
1192 direntry->d_inode->i_gid =
1193 current->fsgid;
Steve French6473a552005-11-29 20:20:10 -08001194 }
1195 }
Steve French2a138ebb2005-11-29 21:22:19 -08001196 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001198mkdir_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 kfree(full_path);
1200 FreeXid(xid);
1201 return rc;
1202}
1203
1204int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1205{
1206 int rc = 0;
1207 int xid;
1208 struct cifs_sb_info *cifs_sb;
1209 struct cifsTconInfo *pTcon;
1210 char *full_path = NULL;
1211 struct cifsInodeInfo *cifsInode;
1212
Steve French26a21b92006-05-31 18:05:34 +00001213 cFYI(1, ("cifs_rmdir, inode = 0x%p", inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214
1215 xid = GetXid();
1216
1217 cifs_sb = CIFS_SB(inode->i_sb);
1218 pTcon = cifs_sb->tcon;
1219
Steve French7f573562005-08-30 11:32:14 -07001220 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 if (full_path == NULL) {
1222 FreeXid(xid);
1223 return -ENOMEM;
1224 }
1225
Steve French737b7582005-04-28 22:41:06 -07001226 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1227 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228
1229 if (!rc) {
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001230 drop_nlink(inode);
Steve French3677db12007-02-26 16:46:11 +00001231 spin_lock(&direntry->d_inode->i_lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001232 i_size_write(direntry->d_inode, 0);
Dave Hansence71ec32006-09-30 23:29:06 -07001233 clear_nlink(direntry->d_inode);
Steve French3677db12007-02-26 16:46:11 +00001234 spin_unlock(&direntry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 }
1236
1237 cifsInode = CIFS_I(direntry->d_inode);
1238 cifsInode->time = 0; /* force revalidate to go get info when
1239 needed */
1240 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1241 current_fs_time(inode->i_sb);
1242
1243 kfree(full_path);
1244 FreeXid(xid);
1245 return rc;
1246}
1247
Steve Frenchee2fd962008-09-23 18:23:33 +00001248static int
1249cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1250 struct dentry *to_dentry, const char *toPath)
1251{
1252 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1253 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1254 __u16 srcfid;
1255 int oplock, rc;
1256
1257 /* try path-based rename first */
1258 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1259 cifs_sb->mnt_cifs_flags &
1260 CIFS_MOUNT_MAP_SPECIAL_CHR);
1261
1262 /*
1263 * don't bother with rename by filehandle unless file is busy and
1264 * source Note that cross directory moves do not work with
1265 * rename by filehandle to various Windows servers.
1266 */
1267 if (rc == 0 || rc != -ETXTBSY)
1268 return rc;
1269
1270 /* open the file to be renamed -- we need DELETE perms */
1271 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1272 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1273 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1274 CIFS_MOUNT_MAP_SPECIAL_CHR);
1275
1276 if (rc == 0) {
1277 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1278 (const char *) to_dentry->d_name.name,
1279 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1280 CIFS_MOUNT_MAP_SPECIAL_CHR);
1281
1282 CIFSSMBClose(xid, pTcon, srcfid);
1283 }
1284
1285 return rc;
1286}
1287
Jeff Layton14121bd2008-10-20 14:45:22 -04001288int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1289 struct inode *target_dir, struct dentry *target_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290{
Steve Frenchee2fd962008-09-23 18:23:33 +00001291 char *fromName = NULL;
1292 char *toName = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 struct cifs_sb_info *cifs_sb_source;
1294 struct cifs_sb_info *cifs_sb_target;
Jeff Layton14121bd2008-10-20 14:45:22 -04001295 struct cifsTconInfo *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001296 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1297 FILE_UNIX_BASIC_INFO *info_buf_target;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001298 int xid, rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
Jeff Layton14121bd2008-10-20 14:45:22 -04001300 cifs_sb_target = CIFS_SB(target_dir->i_sb);
1301 cifs_sb_source = CIFS_SB(source_dir->i_sb);
1302 tcon = cifs_sb_source->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303
Steve Frenchee2fd962008-09-23 18:23:33 +00001304 xid = GetXid();
1305
1306 /*
1307 * BB: this might be allowed if same server, but different share.
1308 * Consider adding support for this
1309 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001310 if (tcon != cifs_sb_target->tcon) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001311 rc = -EXDEV;
1312 goto cifs_rename_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 }
1314
Steve Frenchee2fd962008-09-23 18:23:33 +00001315 /*
1316 * we already have the rename sem so we do not need to
1317 * grab it again here to protect the path integrity
1318 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001319 fromName = build_path_from_dentry(source_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001320 if (fromName == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 rc = -ENOMEM;
1322 goto cifs_rename_exit;
1323 }
1324
Jeff Layton14121bd2008-10-20 14:45:22 -04001325 toName = build_path_from_dentry(target_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001326 if (toName == NULL) {
1327 rc = -ENOMEM;
1328 goto cifs_rename_exit;
1329 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330
Jeff Layton14121bd2008-10-20 14:45:22 -04001331 rc = cifs_do_rename(xid, source_dentry, fromName,
1332 target_dentry, toName);
Steve Frenchee2fd962008-09-23 18:23:33 +00001333
Jeff Layton14121bd2008-10-20 14:45:22 -04001334 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001335 /*
Jeff Layton14121bd2008-10-20 14:45:22 -04001336 * Are src and dst hardlinks of same inode? We can
1337 * only tell with unix extensions enabled
Steve Frenchee2fd962008-09-23 18:23:33 +00001338 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001339 info_buf_source =
1340 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1341 GFP_KERNEL);
1342 if (info_buf_source == NULL) {
1343 rc = -ENOMEM;
1344 goto cifs_rename_exit;
1345 }
1346
1347 info_buf_target = info_buf_source + 1;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001348 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
Jeff Layton14121bd2008-10-20 14:45:22 -04001349 info_buf_source,
1350 cifs_sb_source->local_nls,
1351 cifs_sb_source->mnt_cifs_flags &
1352 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton8d281ef2008-10-22 13:57:01 -04001353 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001354 goto unlink_target;
1355
Jeff Layton8d281ef2008-10-22 13:57:01 -04001356 tmprc = CIFSSMBUnixQPathInfo(xid, tcon,
Jeff Layton14121bd2008-10-20 14:45:22 -04001357 toName, info_buf_target,
1358 cifs_sb_target->local_nls,
1359 /* remap based on source sb */
1360 cifs_sb_source->mnt_cifs_flags &
1361 CIFS_MOUNT_MAP_SPECIAL_CHR);
1362
Jeff Layton8d281ef2008-10-22 13:57:01 -04001363 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001364 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001365 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001366 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001367 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001368 }
Jeff Layton14121bd2008-10-20 14:45:22 -04001369 } /* else ... BB we could add the same check for Windows by
1370 checking the UniqueId via FILE_INTERNAL_INFO */
1371
Jeff Layton14121bd2008-10-20 14:45:22 -04001372unlink_target:
Jeff Layton8d281ef2008-10-22 13:57:01 -04001373 if ((rc == -EACCES) || (rc == -EEXIST)) {
1374 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001375 if (tmprc)
1376 goto cifs_rename_exit;
1377
Jeff Layton14121bd2008-10-20 14:45:22 -04001378 rc = cifs_do_rename(xid, source_dentry, fromName,
1379 target_dentry, toName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 }
1381
1382cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001383 kfree(info_buf_source);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 kfree(fromName);
1385 kfree(toName);
1386 FreeXid(xid);
1387 return rc;
1388}
1389
1390int cifs_revalidate(struct dentry *direntry)
1391{
1392 int xid;
Jeff Laytoncea21802007-11-20 23:19:03 +00001393 int rc = 0, wbrc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 char *full_path;
1395 struct cifs_sb_info *cifs_sb;
1396 struct cifsInodeInfo *cifsInode;
1397 loff_t local_size;
1398 struct timespec local_mtime;
Steve French4b18f2a2008-04-29 00:06:05 +00001399 bool invalidate_inode = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400
1401 if (direntry->d_inode == NULL)
1402 return -ENOENT;
1403
1404 cifsInode = CIFS_I(direntry->d_inode);
1405
1406 if (cifsInode == NULL)
1407 return -ENOENT;
1408
1409 /* no sense revalidating inode info on file that no one can write */
1410 if (CIFS_I(direntry->d_inode)->clientCanCacheRead)
1411 return rc;
1412
1413 xid = GetXid();
1414
1415 cifs_sb = CIFS_SB(direntry->d_sb);
1416
1417 /* can not safely grab the rename sem here if rename calls revalidate
1418 since that would deadlock */
Steve French7f573562005-08-30 11:32:14 -07001419 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 if (full_path == NULL) {
1421 FreeXid(xid);
1422 return -ENOMEM;
1423 }
1424 cFYI(1, ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1425 "jiffies %ld", full_path, direntry->d_inode,
1426 direntry->d_inode->i_count.counter, direntry,
1427 direntry->d_time, jiffies));
1428
1429 if (cifsInode->time == 0) {
1430 /* was set to zero previously to force revalidate */
1431 } else if (time_before(jiffies, cifsInode->time + HZ) &&
1432 lookupCacheEnabled) {
1433 if ((S_ISREG(direntry->d_inode->i_mode) == 0) ||
1434 (direntry->d_inode->i_nlink == 1)) {
1435 kfree(full_path);
1436 FreeXid(xid);
1437 return rc;
1438 } else {
1439 cFYI(1, ("Have to revalidate file due to hardlinks"));
1440 }
1441 }
1442
1443 /* save mtime and size */
1444 local_mtime = direntry->d_inode->i_mtime;
1445 local_size = direntry->d_inode->i_size;
1446
Steve Frenchc18c8422007-07-18 23:21:09 +00001447 if (cifs_sb->tcon->unix_ext) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001449 direntry->d_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 if (rc) {
1451 cFYI(1, ("error on getting revalidate info %d", rc));
1452/* if (rc != -ENOENT)
1453 rc = 0; */ /* BB should we cache info on
1454 certain errors? */
1455 }
1456 } else {
1457 rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +00001458 direntry->d_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 if (rc) {
1460 cFYI(1, ("error on getting revalidate info %d", rc));
1461/* if (rc != -ENOENT)
1462 rc = 0; */ /* BB should we cache info on
1463 certain errors? */
1464 }
1465 }
1466 /* should we remap certain errors, access denied?, to zero */
1467
1468 /* if not oplocked, we invalidate inode pages if mtime or file size
1469 had changed on server */
1470
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001471 if (timespec_equal(&local_mtime, &direntry->d_inode->i_mtime) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 (local_size == direntry->d_inode->i_size)) {
1473 cFYI(1, ("cifs_revalidate - inode unchanged"));
1474 } else {
1475 /* file may have changed on server */
1476 if (cifsInode->clientCanCacheRead) {
1477 /* no need to invalidate inode pages since we were the
1478 only ones who could have modified the file and the
1479 server copy is staler than ours */
1480 } else {
Steve French4b18f2a2008-04-29 00:06:05 +00001481 invalidate_inode = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 }
1483 }
1484
1485 /* can not grab this sem since kernel filesys locking documentation
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001486 indicates i_mutex may be taken by the kernel on lookup and rename
1487 which could deadlock if we grab the i_mutex here as well */
1488/* mutex_lock(&direntry->d_inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489 /* need to write out dirty pages here */
1490 if (direntry->d_inode->i_mapping) {
1491 /* do we need to lock inode until after invalidate completes
1492 below? */
Jeff Laytoncea21802007-11-20 23:19:03 +00001493 wbrc = filemap_fdatawrite(direntry->d_inode->i_mapping);
1494 if (wbrc)
1495 CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 }
1497 if (invalidate_inode) {
Steve French3abb9272005-11-28 08:16:13 -08001498 /* shrink_dcache not necessary now that cifs dentry ops
1499 are exported for negative dentries */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001500/* if (S_ISDIR(direntry->d_inode->i_mode))
Steve French3abb9272005-11-28 08:16:13 -08001501 shrink_dcache_parent(direntry); */
1502 if (S_ISREG(direntry->d_inode->i_mode)) {
Suresh Jayaraman9e96af82008-08-05 14:38:40 +05301503 if (direntry->d_inode->i_mapping) {
Jeff Laytoncea21802007-11-20 23:19:03 +00001504 wbrc = filemap_fdatawait(direntry->d_inode->i_mapping);
1505 if (wbrc)
1506 CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
Suresh Jayaraman9e96af82008-08-05 14:38:40 +05301507 }
Steve French3abb9272005-11-28 08:16:13 -08001508 /* may eventually have to do this for open files too */
1509 if (list_empty(&(cifsInode->openFileList))) {
1510 /* changed on server - flush read ahead pages */
1511 cFYI(1, ("Invalidating read ahead data on "
1512 "closed file"));
1513 invalidate_remote_inode(direntry->d_inode);
1514 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515 }
1516 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001517/* mutex_unlock(&direntry->d_inode->i_mutex); */
Steve French50c2f752007-07-13 00:33:32 +00001518
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 kfree(full_path);
1520 FreeXid(xid);
1521 return rc;
1522}
1523
1524int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1525 struct kstat *stat)
1526{
1527 int err = cifs_revalidate(dentry);
Steve French5fe14c82006-11-07 19:26:33 +00001528 if (!err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 generic_fillattr(dentry->d_inode, stat);
Steve French5fe14c82006-11-07 19:26:33 +00001530 stat->blksize = CIFS_MAX_MSGSIZE;
1531 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532 return err;
1533}
1534
1535static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1536{
1537 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1538 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1539 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 int rc = 0;
1541
1542 page = grab_cache_page(mapping, index);
1543 if (!page)
1544 return -ENOMEM;
1545
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001546 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 unlock_page(page);
1548 page_cache_release(page);
1549 return rc;
1550}
1551
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001552static int cifs_vmtruncate(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00001553{
1554 struct address_space *mapping = inode->i_mapping;
1555 unsigned long limit;
1556
Steve Frenchba6a46a2007-02-26 20:06:29 +00001557 spin_lock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001558 if (inode->i_size < offset)
1559 goto do_expand;
1560 /*
1561 * truncation of in-use swapfiles is disallowed - it would cause
1562 * subsequent swapout to scribble on the now-freed blocks.
1563 */
Steve Frenchba6a46a2007-02-26 20:06:29 +00001564 if (IS_SWAPFILE(inode)) {
1565 spin_unlock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001566 goto out_busy;
Steve Frenchba6a46a2007-02-26 20:06:29 +00001567 }
Steve French3677db12007-02-26 16:46:11 +00001568 i_size_write(inode, offset);
1569 spin_unlock(&inode->i_lock);
Steve French8064ab42007-08-22 22:12:07 +00001570 /*
1571 * unmap_mapping_range is called twice, first simply for efficiency
1572 * so that truncate_inode_pages does fewer single-page unmaps. However
1573 * after this first call, and before truncate_inode_pages finishes,
1574 * it is possible for private pages to be COWed, which remain after
1575 * truncate_inode_pages finishes, hence the second unmap_mapping_range
1576 * call must be made for correctness.
1577 */
Steve French3677db12007-02-26 16:46:11 +00001578 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1579 truncate_inode_pages(mapping, offset);
Steve French8064ab42007-08-22 22:12:07 +00001580 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
Steve French3677db12007-02-26 16:46:11 +00001581 goto out_truncate;
1582
1583do_expand:
1584 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
Steve Frenchba6a46a2007-02-26 20:06:29 +00001585 if (limit != RLIM_INFINITY && offset > limit) {
1586 spin_unlock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001587 goto out_sig;
Steve Frenchba6a46a2007-02-26 20:06:29 +00001588 }
1589 if (offset > inode->i_sb->s_maxbytes) {
1590 spin_unlock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001591 goto out_big;
Steve Frenchba6a46a2007-02-26 20:06:29 +00001592 }
Steve French3677db12007-02-26 16:46:11 +00001593 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00001594 spin_unlock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001595out_truncate:
1596 if (inode->i_op && inode->i_op->truncate)
1597 inode->i_op->truncate(inode);
1598 return 0;
1599out_sig:
1600 send_sig(SIGXFSZ, current, 0);
1601out_big:
1602 return -EFBIG;
1603out_busy:
1604 return -ETXTBSY;
1605}
1606
Jeff Layton8efdbde2008-07-23 21:28:12 +00001607static int
1608cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1609 int xid, char *full_path)
1610{
1611 int rc;
1612 struct cifsFileInfo *open_file;
1613 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1614 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1615 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1616
1617 /*
1618 * To avoid spurious oplock breaks from server, in the case of
1619 * inodes that we already have open, avoid doing path based
1620 * setting of file size if we can do it by handle.
1621 * This keeps our caching token (oplock) and avoids timeouts
1622 * when the local oplock break takes longer to flush
1623 * writebehind data than the SMB timeout for the SetPathInfo
1624 * request would allow
1625 */
1626 open_file = find_writable_file(cifsInode);
1627 if (open_file) {
1628 __u16 nfid = open_file->netfid;
1629 __u32 npid = open_file->pid;
1630 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1631 npid, false);
1632 atomic_dec(&open_file->wrtPending);
1633 cFYI(1, ("SetFSize for attrs rc = %d", rc));
1634 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1635 unsigned int bytes_written;
1636 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1637 &bytes_written, NULL, NULL, 1);
1638 cFYI(1, ("Wrt seteof rc %d", rc));
1639 }
1640 } else
1641 rc = -EINVAL;
1642
1643 if (rc != 0) {
1644 /* Set file size by pathname rather than by handle
1645 either because no valid, writeable file handle for
1646 it was found or because there was an error setting
1647 it by handle */
1648 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1649 false, cifs_sb->local_nls,
1650 cifs_sb->mnt_cifs_flags &
1651 CIFS_MOUNT_MAP_SPECIAL_CHR);
1652 cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
1653 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1654 __u16 netfid;
1655 int oplock = 0;
1656
1657 rc = SMBLegacyOpen(xid, pTcon, full_path,
1658 FILE_OPEN, GENERIC_WRITE,
1659 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1660 cifs_sb->local_nls,
1661 cifs_sb->mnt_cifs_flags &
1662 CIFS_MOUNT_MAP_SPECIAL_CHR);
1663 if (rc == 0) {
1664 unsigned int bytes_written;
1665 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1666 attrs->ia_size,
1667 &bytes_written, NULL,
1668 NULL, 1);
1669 cFYI(1, ("wrt seteof rc %d", rc));
1670 CIFSSMBClose(xid, pTcon, netfid);
1671 }
1672 }
1673 }
1674
1675 if (rc == 0) {
1676 rc = cifs_vmtruncate(inode, attrs->ia_size);
1677 cifs_truncate_page(inode->i_mapping, inode->i_size);
1678 }
1679
1680 return rc;
1681}
1682
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001683static int
1684cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1685{
1686 int rc;
1687 int xid;
1688 char *full_path = NULL;
1689 struct inode *inode = direntry->d_inode;
1690 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1691 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1692 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1693 struct cifs_unix_set_info_args *args = NULL;
1694
1695 cFYI(1, ("setattr_unix on file %s attrs->ia_valid=0x%x",
1696 direntry->d_name.name, attrs->ia_valid));
1697
1698 xid = GetXid();
1699
1700 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1701 /* check if we have permission to change attrs */
1702 rc = inode_change_ok(inode, attrs);
1703 if (rc < 0)
1704 goto out;
1705 else
1706 rc = 0;
1707 }
1708
1709 full_path = build_path_from_dentry(direntry);
1710 if (full_path == NULL) {
1711 rc = -ENOMEM;
1712 goto out;
1713 }
1714
1715 if ((attrs->ia_valid & ATTR_MTIME) || (attrs->ia_valid & ATTR_SIZE)) {
1716 /*
1717 Flush data before changing file size or changing the last
1718 write time of the file on the server. If the
1719 flush returns error, store it to report later and continue.
1720 BB: This should be smarter. Why bother flushing pages that
1721 will be truncated anyway? Also, should we error out here if
1722 the flush returns error?
1723 */
1724 rc = filemap_write_and_wait(inode->i_mapping);
1725 if (rc != 0) {
1726 cifsInode->write_behind_rc = rc;
1727 rc = 0;
1728 }
1729 }
1730
1731 if (attrs->ia_valid & ATTR_SIZE) {
1732 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1733 if (rc != 0)
1734 goto out;
1735 }
1736
1737 /* skip mode change if it's just for clearing setuid/setgid */
1738 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1739 attrs->ia_valid &= ~ATTR_MODE;
1740
1741 args = kmalloc(sizeof(*args), GFP_KERNEL);
1742 if (args == NULL) {
1743 rc = -ENOMEM;
1744 goto out;
1745 }
1746
1747 /* set up the struct */
1748 if (attrs->ia_valid & ATTR_MODE)
1749 args->mode = attrs->ia_mode;
1750 else
1751 args->mode = NO_CHANGE_64;
1752
1753 if (attrs->ia_valid & ATTR_UID)
1754 args->uid = attrs->ia_uid;
1755 else
1756 args->uid = NO_CHANGE_64;
1757
1758 if (attrs->ia_valid & ATTR_GID)
1759 args->gid = attrs->ia_gid;
1760 else
1761 args->gid = NO_CHANGE_64;
1762
1763 if (attrs->ia_valid & ATTR_ATIME)
1764 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1765 else
1766 args->atime = NO_CHANGE_64;
1767
1768 if (attrs->ia_valid & ATTR_MTIME)
1769 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
1770 else
1771 args->mtime = NO_CHANGE_64;
1772
1773 if (attrs->ia_valid & ATTR_CTIME)
1774 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
1775 else
1776 args->ctime = NO_CHANGE_64;
1777
1778 args->device = 0;
1779 rc = CIFSSMBUnixSetInfo(xid, pTcon, full_path, args,
1780 cifs_sb->local_nls,
1781 cifs_sb->mnt_cifs_flags &
1782 CIFS_MOUNT_MAP_SPECIAL_CHR);
1783
1784 if (!rc)
1785 rc = inode_setattr(inode, attrs);
1786out:
1787 kfree(args);
1788 kfree(full_path);
1789 FreeXid(xid);
1790 return rc;
1791}
1792
Jeff Layton0510eeb2008-08-02 07:26:12 -04001793static int
1794cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795{
1796 int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001797 struct inode *inode = direntry->d_inode;
1798 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001799 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800 char *full_path = NULL;
1801 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001802 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001803 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001804
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 xid = GetXid();
1806
Steve French39798772006-05-31 22:40:51 +00001807 cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 direntry->d_name.name, attrs->ia_valid));
Steve French6473a552005-11-29 20:20:10 -08001809
Steve French2a138ebb2005-11-29 21:22:19 -08001810 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
Steve French6473a552005-11-29 20:20:10 -08001811 /* check if we have permission to change attrs */
Jeff Layton02eadef2008-05-09 21:26:11 +00001812 rc = inode_change_ok(inode, attrs);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001813 if (rc < 0) {
Steve French6473a552005-11-29 20:20:10 -08001814 FreeXid(xid);
1815 return rc;
1816 } else
1817 rc = 0;
1818 }
Steve French50c2f752007-07-13 00:33:32 +00001819
Steve French7f573562005-08-30 11:32:14 -07001820 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 if (full_path == NULL) {
1822 FreeXid(xid);
1823 return -ENOMEM;
1824 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825
Steve French50531442008-03-14 19:21:31 +00001826 if ((attrs->ia_valid & ATTR_MTIME) || (attrs->ia_valid & ATTR_SIZE)) {
Jeff Laytoncea21802007-11-20 23:19:03 +00001827 /*
Steve French50531442008-03-14 19:21:31 +00001828 Flush data before changing file size or changing the last
1829 write time of the file on the server. If the
Jeff Laytoncea21802007-11-20 23:19:03 +00001830 flush returns error, store it to report later and continue.
1831 BB: This should be smarter. Why bother flushing pages that
1832 will be truncated anyway? Also, should we error out here if
1833 the flush returns error?
1834 */
Jeff Layton02eadef2008-05-09 21:26:11 +00001835 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +00001836 if (rc != 0) {
Jeff Layton02eadef2008-05-09 21:26:11 +00001837 cifsInode->write_behind_rc = rc;
Jeff Laytoncea21802007-11-20 23:19:03 +00001838 rc = 0;
1839 }
Steve French50531442008-03-14 19:21:31 +00001840 }
Jeff Laytoncea21802007-11-20 23:19:03 +00001841
Steve French50531442008-03-14 19:21:31 +00001842 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00001843 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1844 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07001845 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04001847
1848 /*
1849 * Without unix extensions we can't send ownership changes to the
1850 * server, so silently ignore them. This is consistent with how
1851 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
1852 * CIFSACL support + proper Windows to Unix idmapping, we may be
1853 * able to support this in the future.
1854 */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001855 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04001856 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857
Jeff Laytond32c4f22007-10-18 03:05:22 -07001858 /* skip mode change if it's just for clearing setuid/setgid */
1859 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1860 attrs->ia_valid &= ~ATTR_MODE;
1861
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 if (attrs->ia_valid & ATTR_MODE) {
Jeff Layton51328612008-05-22 09:33:34 -04001863 cFYI(1, ("Mode changed to 0%o", attrs->ia_mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 mode = attrs->ia_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865 }
1866
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001867 if (attrs->ia_valid & ATTR_MODE) {
Steve Frenchcdbce9c2005-11-19 21:04:52 -08001868 rc = 0;
Steve French97837582007-12-31 07:47:21 +00001869#ifdef CONFIG_CIFS_EXPERIMENTAL
1870 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
Jeff Layton02eadef2008-05-09 21:26:11 +00001871 rc = mode_to_acl(inode, full_path, mode);
Jeff Layton51328612008-05-22 09:33:34 -04001872 else
Steve French97837582007-12-31 07:47:21 +00001873#endif
Jeff Layton51328612008-05-22 09:33:34 -04001874 if (((mode & S_IWUGO) == 0) &&
1875 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001876
1877 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
1878
Jeff Layton51328612008-05-22 09:33:34 -04001879 /* fix up mode if we're not using dynperm */
1880 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
1881 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
1882 } else if ((mode & S_IWUGO) &&
1883 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001884
1885 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
1886 /* Attributes of 0 are ignored */
1887 if (dosattr == 0)
1888 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04001889
1890 /* reset local inode permissions to normal */
1891 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1892 attrs->ia_mode &= ~(S_IALLUGO);
1893 if (S_ISDIR(inode->i_mode))
1894 attrs->ia_mode |=
1895 cifs_sb->mnt_dir_mode;
1896 else
1897 attrs->ia_mode |=
1898 cifs_sb->mnt_file_mode;
1899 }
1900 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1901 /* ignore mode change - ATTR_READONLY hasn't changed */
1902 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904 }
1905
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001906 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
1907 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
1908 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1909 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910
Steve Frenche30dcf32005-09-20 20:49:16 -07001911 /* Even if error on time set, no sense failing the call if
1912 the server would set the time to a reasonable value anyway,
1913 and this check ensures that we are not being called from
1914 sys_utimes in which case we ought to fail the call back to
1915 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001916 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001917 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07001918 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 }
1920
1921 /* do not need local check to inode_check_ok since the server does
1922 that */
1923 if (!rc)
Jeff Layton02eadef2008-05-09 21:26:11 +00001924 rc = inode_setattr(inode, attrs);
Steve Frenche30dcf32005-09-20 20:49:16 -07001925cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 kfree(full_path);
1927 FreeXid(xid);
1928 return rc;
1929}
1930
Jeff Layton0510eeb2008-08-02 07:26:12 -04001931int
1932cifs_setattr(struct dentry *direntry, struct iattr *attrs)
1933{
1934 struct inode *inode = direntry->d_inode;
1935 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1936 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1937
1938 if (pTcon->unix_ext)
1939 return cifs_setattr_unix(direntry, attrs);
1940
1941 return cifs_setattr_nounix(direntry, attrs);
1942
1943 /* BB: add cifs_setattr_legacy for really old servers */
1944}
1945
Steve French99ee4db2007-02-27 05:35:17 +00001946#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947void cifs_delete_inode(struct inode *inode)
1948{
Steve French26a21b92006-05-31 18:05:34 +00001949 cFYI(1, ("In cifs_delete_inode, inode = 0x%p", inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001950 /* may have to add back in if and when safe distributed caching of
1951 directories added e.g. via FindNotify */
1952}
Steve French99ee4db2007-02-27 05:35:17 +00001953#endif