blob: f247da9f4edc2a650f7e59c559f17767d1f8dccd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/inode.c
3 *
Steve French8be0ed42008-12-05 19:14:12 +00004 * Copyright (C) International Business Machines Corp., 2002,2008
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
Steve French8be0ed42008-12-05 19:14:12 +0000624static char *build_path_to_root(struct cifs_sb_info *cifs_sb)
625{
626 int pplen = cifs_sb->prepathlen;
627 int dfsplen;
628 char *full_path = NULL;
629
630 /* if no prefix path, simply set path to the root of share to "" */
631 if (pplen == 0) {
632 full_path = kmalloc(1, GFP_KERNEL);
633 if (full_path)
634 full_path[0] = 0;
635 return full_path;
636 }
637
638 if (cifs_sb->tcon && (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS))
639 dfsplen = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE + 1);
640 else
641 dfsplen = 0;
642
643 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
644 if (full_path == NULL)
645 return full_path;
646
647 if (dfsplen) {
648 strncpy(full_path, cifs_sb->tcon->treeName, dfsplen);
649 /* switch slash direction in prepath depending on whether
650 * windows or posix style path names
651 */
652 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
653 int i;
654 for (i = 0; i < dfsplen; i++) {
655 if (full_path[i] == '\\')
656 full_path[i] = '/';
657 }
658 }
659 }
660 strncpy(full_path + dfsplen, cifs_sb->prepath, pplen);
661 full_path[dfsplen + pplen] = 0; /* add trailing null */
662 return full_path;
663}
664
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665/* gets root inode */
David Howellsce634ab2008-02-07 00:15:33 -0800666struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667{
David Howellsce634ab2008-02-07 00:15:33 -0800668 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 struct cifs_sb_info *cifs_sb;
David Howellsce634ab2008-02-07 00:15:33 -0800670 struct inode *inode;
671 long rc;
Steve French8be0ed42008-12-05 19:14:12 +0000672 char *full_path;
David Howellsce634ab2008-02-07 00:15:33 -0800673
674 inode = iget_locked(sb, ino);
675 if (!inode)
676 return ERR_PTR(-ENOMEM);
677 if (!(inode->i_state & I_NEW))
678 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
680 cifs_sb = CIFS_SB(inode->i_sb);
Steve French8be0ed42008-12-05 19:14:12 +0000681 full_path = build_path_to_root(cifs_sb);
682 if (full_path == NULL)
683 return ERR_PTR(-ENOMEM);
Steve Frenchc18c8422007-07-18 23:21:09 +0000684
Steve French8be0ed42008-12-05 19:14:12 +0000685 xid = GetXid();
Steve Frenchc18c8422007-07-18 23:21:09 +0000686 if (cifs_sb->tcon->unix_ext)
Steve French8be0ed42008-12-05 19:14:12 +0000687 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
688 xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 else
Steve French8be0ed42008-12-05 19:14:12 +0000690 rc = cifs_get_inode_info(&inode, full_path, NULL, inode->i_sb,
691 xid, NULL);
Steve French7f8ed422007-09-28 22:28:55 +0000692 if (rc && cifs_sb->tcon->ipc) {
693 cFYI(1, ("ipc connection - fake read inode"));
694 inode->i_mode |= S_IFDIR;
695 inode->i_nlink = 2;
696 inode->i_op = &cifs_ipc_inode_ops;
697 inode->i_fop = &simple_dir_operations;
698 inode->i_uid = cifs_sb->mnt_uid;
699 inode->i_gid = cifs_sb->mnt_gid;
Steve Frenchad661332008-08-12 14:14:40 +0000700 } else if (rc) {
Steve French8be0ed42008-12-05 19:14:12 +0000701 kfree(full_path);
David Howellsce634ab2008-02-07 00:15:33 -0800702 _FreeXid(xid);
703 iget_failed(inode);
704 return ERR_PTR(rc);
Steve French7f8ed422007-09-28 22:28:55 +0000705 }
706
David Howellsce634ab2008-02-07 00:15:33 -0800707 unlock_new_inode(inode);
708
Steve French8be0ed42008-12-05 19:14:12 +0000709 kfree(full_path);
David Howellsce634ab2008-02-07 00:15:33 -0800710 /* can not call macro FreeXid here since in a void func
711 * TODO: This is no longer true
712 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 _FreeXid(xid);
David Howellsce634ab2008-02-07 00:15:33 -0800714 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715}
716
Steve French388e57b2008-09-16 23:50:58 +0000717static int
718cifs_set_file_info(struct inode *inode, struct iattr *attrs, int xid,
719 char *full_path, __u32 dosattr)
720{
721 int rc;
722 int oplock = 0;
723 __u16 netfid;
724 __u32 netpid;
725 bool set_time = false;
726 struct cifsFileInfo *open_file;
727 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
728 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
729 struct cifsTconInfo *pTcon = cifs_sb->tcon;
730 FILE_BASIC_INFO info_buf;
731
732 if (attrs->ia_valid & ATTR_ATIME) {
733 set_time = true;
734 info_buf.LastAccessTime =
735 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
736 } else
737 info_buf.LastAccessTime = 0;
738
739 if (attrs->ia_valid & ATTR_MTIME) {
740 set_time = true;
741 info_buf.LastWriteTime =
742 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
743 } else
744 info_buf.LastWriteTime = 0;
745
746 /*
747 * Samba throws this field away, but windows may actually use it.
748 * Do not set ctime unless other time stamps are changed explicitly
749 * (i.e. by utimes()) since we would then have a mix of client and
750 * server times.
751 */
752 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
753 cFYI(1, ("CIFS - CTIME changed"));
754 info_buf.ChangeTime =
755 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
756 } else
757 info_buf.ChangeTime = 0;
758
759 info_buf.CreationTime = 0; /* don't change */
760 info_buf.Attributes = cpu_to_le32(dosattr);
761
762 /*
763 * If the file is already open for write, just use that fileid
764 */
765 open_file = find_writable_file(cifsInode);
766 if (open_file) {
767 netfid = open_file->netfid;
768 netpid = open_file->pid;
769 goto set_via_filehandle;
770 }
771
772 /*
773 * NT4 apparently returns success on this call, but it doesn't
774 * really work.
775 */
776 if (!(pTcon->ses->flags & CIFS_SES_NT4)) {
777 rc = CIFSSMBSetPathInfo(xid, pTcon, full_path,
778 &info_buf, cifs_sb->local_nls,
779 cifs_sb->mnt_cifs_flags &
780 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +0000781 if (rc == 0) {
782 cifsInode->cifsAttrs = dosattr;
783 goto out;
784 } else if (rc != -EOPNOTSUPP && rc != -EINVAL)
Steve French388e57b2008-09-16 23:50:58 +0000785 goto out;
786 }
787
788 cFYI(1, ("calling SetFileInfo since SetPathInfo for "
789 "times not supported by this server"));
790 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
791 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
792 CREATE_NOT_DIR, &netfid, &oplock,
793 NULL, cifs_sb->local_nls,
794 cifs_sb->mnt_cifs_flags &
795 CIFS_MOUNT_MAP_SPECIAL_CHR);
796
797 if (rc != 0) {
798 if (rc == -EIO)
799 rc = -EINVAL;
800 goto out;
801 }
802
803 netpid = current->tgid;
804
805set_via_filehandle:
806 rc = CIFSSMBSetFileInfo(xid, pTcon, &info_buf, netfid, netpid);
Steve Frenchd3889082008-09-24 19:22:52 +0000807 if (!rc)
808 cifsInode->cifsAttrs = dosattr;
809
Steve French388e57b2008-09-16 23:50:58 +0000810 if (open_file == NULL)
811 CIFSSMBClose(xid, pTcon, netfid);
812 else
813 atomic_dec(&open_file->wrtPending);
814out:
815 return rc;
816}
817
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400818/*
819 * open the given file (if it isn't already), set the DELETE_ON_CLOSE bit
820 * and rename it to a random name that hopefully won't conflict with
821 * anything else.
822 */
823static int
Steve French32709582008-10-20 00:44:19 +0000824cifs_rename_pending_delete(char *full_path, struct dentry *dentry, int xid)
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400825{
826 int oplock = 0;
827 int rc;
828 __u16 netfid;
Steve French32709582008-10-20 00:44:19 +0000829 struct inode *inode = dentry->d_inode;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400830 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
831 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
832 struct cifsTconInfo *tcon = cifs_sb->tcon;
Steve French32709582008-10-20 00:44:19 +0000833 __u32 dosattr, origattr;
834 FILE_BASIC_INFO *info_buf = NULL;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400835
836 rc = CIFSSMBOpen(xid, tcon, full_path, FILE_OPEN,
Jeff Laytondd1db2d2008-10-16 19:27:12 -0400837 DELETE|FILE_WRITE_ATTRIBUTES, CREATE_NOT_DIR,
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400838 &netfid, &oplock, NULL, cifs_sb->local_nls,
839 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
840 if (rc != 0)
841 goto out;
842
Steve French32709582008-10-20 00:44:19 +0000843 origattr = cifsInode->cifsAttrs;
844 if (origattr == 0)
845 origattr |= ATTR_NORMAL;
846
847 dosattr = origattr & ~ATTR_READONLY;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400848 if (dosattr == 0)
849 dosattr |= ATTR_NORMAL;
850 dosattr |= ATTR_HIDDEN;
851
Steve French32709582008-10-20 00:44:19 +0000852 /* set ATTR_HIDDEN and clear ATTR_READONLY, but only if needed */
853 if (dosattr != origattr) {
854 info_buf = kzalloc(sizeof(*info_buf), GFP_KERNEL);
855 if (info_buf == NULL) {
856 rc = -ENOMEM;
857 goto out_close;
858 }
859 info_buf->Attributes = cpu_to_le32(dosattr);
860 rc = CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
861 current->tgid);
862 /* although we would like to mark the file hidden
863 if that fails we will still try to rename it */
Steve French41346092008-10-20 18:24:42 +0000864 if (rc != 0)
Steve French32709582008-10-20 00:44:19 +0000865 cifsInode->cifsAttrs = dosattr;
866 else
867 dosattr = origattr; /* since not able to change them */
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400868 }
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400869
Jeff Laytondd1db2d2008-10-16 19:27:12 -0400870 /* rename the file */
871 rc = CIFSSMBRenameOpenFile(xid, tcon, netfid, NULL, cifs_sb->local_nls,
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400872 cifs_sb->mnt_cifs_flags &
873 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French32709582008-10-20 00:44:19 +0000874 if (rc != 0) {
875 rc = -ETXTBSY;
876 goto undo_setattr;
877 }
Jeff Layton6d22f092008-09-23 11:48:35 -0400878
Steve French32709582008-10-20 00:44:19 +0000879 /* try to set DELETE_ON_CLOSE */
880 if (!cifsInode->delete_pending) {
881 rc = CIFSSMBSetFileDisposition(xid, tcon, true, netfid,
882 current->tgid);
883 /*
884 * some samba versions return -ENOENT when we try to set the
885 * file disposition here. Likely a samba bug, but work around
886 * it for now. This means that some cifsXXX files may hang
887 * around after they shouldn't.
888 *
889 * BB: remove this hack after more servers have the fix
890 */
891 if (rc == -ENOENT)
892 rc = 0;
893 else if (rc != 0) {
894 rc = -ETXTBSY;
895 goto undo_rename;
896 }
897 cifsInode->delete_pending = true;
898 }
Jeff Layton7ce86d52008-09-24 11:32:59 -0400899
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400900out_close:
901 CIFSSMBClose(xid, tcon, netfid);
902out:
Steve French32709582008-10-20 00:44:19 +0000903 kfree(info_buf);
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400904 return rc;
Steve French32709582008-10-20 00:44:19 +0000905
906 /*
907 * reset everything back to the original state. Don't bother
908 * dealing with errors here since we can't do anything about
909 * them anyway.
910 */
911undo_rename:
912 CIFSSMBRenameOpenFile(xid, tcon, netfid, dentry->d_name.name,
913 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
914 CIFS_MOUNT_MAP_SPECIAL_CHR);
915undo_setattr:
916 if (dosattr != origattr) {
917 info_buf->Attributes = cpu_to_le32(origattr);
918 if (!CIFSSMBSetFileInfo(xid, tcon, info_buf, netfid,
919 current->tgid))
920 cifsInode->cifsAttrs = origattr;
921 }
922
923 goto out_close;
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400924}
925
Jeff Layton5f0319a2008-09-16 14:05:16 -0400926int cifs_unlink(struct inode *dir, struct dentry *dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927{
928 int rc = 0;
929 int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 char *full_path = NULL;
Jeff Layton5f0319a2008-09-16 14:05:16 -0400931 struct inode *inode = dentry->d_inode;
Steve French60502472008-10-07 18:42:52 +0000932 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Jeff Layton5f0319a2008-09-16 14:05:16 -0400933 struct super_block *sb = dir->i_sb;
934 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
935 struct cifsTconInfo *tcon = cifs_sb->tcon;
Steve French60502472008-10-07 18:42:52 +0000936 struct iattr *attrs = NULL;
937 __u32 dosattr = 0, origattr = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938
Jeff Layton5f0319a2008-09-16 14:05:16 -0400939 cFYI(1, ("cifs_unlink, dir=0x%p, dentry=0x%p", dir, dentry));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940
941 xid = GetXid();
942
Jeff Layton5f0319a2008-09-16 14:05:16 -0400943 /* Unlink can be called from rename so we can not take the
944 * sb->s_vfs_rename_mutex here */
945 full_path = build_path_from_dentry(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 if (full_path == NULL) {
947 FreeXid(xid);
948 return -ENOMEM;
949 }
Steve French2d785a52007-07-15 01:48:57 +0000950
Jeff Layton5f0319a2008-09-16 14:05:16 -0400951 if ((tcon->ses->capabilities & CAP_UNIX) &&
Steve French2d785a52007-07-15 01:48:57 +0000952 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Jeff Layton5f0319a2008-09-16 14:05:16 -0400953 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
954 rc = CIFSPOSIXDelFile(xid, tcon, full_path,
Steve French2d785a52007-07-15 01:48:57 +0000955 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
956 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
957 cFYI(1, ("posix del rc %d", rc));
958 if ((rc == 0) || (rc == -ENOENT))
959 goto psx_del_no_retry;
960 }
961
Steve French60502472008-10-07 18:42:52 +0000962retry_std_delete:
Jeff Layton5f0319a2008-09-16 14:05:16 -0400963 rc = CIFSSMBDelFile(xid, tcon, full_path, cifs_sb->local_nls,
Steve French737b7582005-04-28 22:41:06 -0700964 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French60502472008-10-07 18:42:52 +0000965
Steve French2d785a52007-07-15 01:48:57 +0000966psx_del_no_retry:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 if (!rc) {
Jeff Layton5f0319a2008-09-16 14:05:16 -0400968 if (inode)
969 drop_nlink(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 } else if (rc == -ENOENT) {
Jeff Layton5f0319a2008-09-16 14:05:16 -0400971 d_drop(dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 } else if (rc == -ETXTBSY) {
Steve French32709582008-10-20 00:44:19 +0000973 rc = cifs_rename_pending_delete(full_path, dentry, xid);
Jeff Laytona12a1ac2008-09-23 11:48:35 -0400974 if (rc == 0)
975 drop_nlink(inode);
Steve French60502472008-10-07 18:42:52 +0000976 } else if (rc == -EACCES && dosattr == 0) {
Steve French388e57b2008-09-16 23:50:58 +0000977 attrs = kzalloc(sizeof(*attrs), GFP_KERNEL);
978 if (attrs == NULL) {
979 rc = -ENOMEM;
980 goto out_reval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 }
Steve French388e57b2008-09-16 23:50:58 +0000982
983 /* try to reset dos attributes */
Steve French60502472008-10-07 18:42:52 +0000984 origattr = cifsInode->cifsAttrs;
985 if (origattr == 0)
986 origattr |= ATTR_NORMAL;
987 dosattr = origattr & ~ATTR_READONLY;
Steve French388e57b2008-09-16 23:50:58 +0000988 if (dosattr == 0)
989 dosattr |= ATTR_NORMAL;
990 dosattr |= ATTR_HIDDEN;
991
992 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
Steve French388e57b2008-09-16 23:50:58 +0000993 if (rc != 0)
994 goto out_reval;
Steve French60502472008-10-07 18:42:52 +0000995
996 goto retry_std_delete;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 }
Steve French60502472008-10-07 18:42:52 +0000998
999 /* undo the setattr if we errored out and it's needed */
1000 if (rc != 0 && dosattr != 0)
1001 cifs_set_file_info(inode, attrs, xid, full_path, origattr);
1002
Steve French388e57b2008-09-16 23:50:58 +00001003out_reval:
Jeff Layton5f0319a2008-09-16 14:05:16 -04001004 if (inode) {
1005 cifsInode = CIFS_I(inode);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001006 cifsInode->time = 0; /* will force revalidate to get info
1007 when needed */
Jeff Layton5f0319a2008-09-16 14:05:16 -04001008 inode->i_ctime = current_fs_time(sb);
Steve Frenchb2aeb9d2005-05-17 13:16:18 -05001009 }
Jeff Layton5f0319a2008-09-16 14:05:16 -04001010 dir->i_ctime = dir->i_mtime = current_fs_time(sb);
1011 cifsInode = CIFS_I(dir);
Steve French60502472008-10-07 18:42:52 +00001012 CIFS_I(dir)->time = 0; /* force revalidate of dir as well */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013
1014 kfree(full_path);
Steve French60502472008-10-07 18:42:52 +00001015 kfree(attrs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 FreeXid(xid);
1017 return rc;
1018}
1019
Steve French2dd29d32007-04-23 22:07:35 +00001020static void posix_fill_in_inode(struct inode *tmp_inode,
Steve French0b442d22008-02-26 03:44:02 +00001021 FILE_UNIX_BASIC_INFO *pData, int isNewInode)
Steve French2dd29d32007-04-23 22:07:35 +00001022{
Christoph Hellwig75f12982008-02-25 20:25:21 +00001023 struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
Steve French2dd29d32007-04-23 22:07:35 +00001024 loff_t local_size;
1025 struct timespec local_mtime;
1026
Steve French2dd29d32007-04-23 22:07:35 +00001027 cifsInfo->time = jiffies;
1028 atomic_inc(&cifsInfo->inUse);
1029
1030 /* save mtime and size */
1031 local_mtime = tmp_inode->i_mtime;
1032 local_size = tmp_inode->i_size;
1033
Christoph Hellwig75f12982008-02-25 20:25:21 +00001034 cifs_unix_info_to_inode(tmp_inode, pData, 1);
Igor Mammedov79626702008-03-09 03:44:18 +00001035 cifs_set_ops(tmp_inode, false);
Steve French2dd29d32007-04-23 22:07:35 +00001036
Christoph Hellwig75f12982008-02-25 20:25:21 +00001037 if (!S_ISREG(tmp_inode->i_mode))
1038 return;
1039
1040 /*
1041 * No sense invalidating pages for new inode
1042 * since we we have not started caching
1043 * readahead file data yet.
1044 */
1045 if (isNewInode)
1046 return;
1047
1048 if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
1049 (local_size == tmp_inode->i_size)) {
1050 cFYI(1, ("inode exists but unchanged"));
Steve French2dd29d32007-04-23 22:07:35 +00001051 } else {
Christoph Hellwig75f12982008-02-25 20:25:21 +00001052 /* file may have changed on server */
1053 cFYI(1, ("invalidate inode, readdir detected change"));
1054 invalidate_remote_inode(tmp_inode);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001055 }
Steve French2dd29d32007-04-23 22:07:35 +00001056}
1057
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
1059{
Jeff Layton6b37faa2008-10-06 21:54:41 +00001060 int rc = 0, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 int xid;
1062 struct cifs_sb_info *cifs_sb;
1063 struct cifsTconInfo *pTcon;
1064 char *full_path = NULL;
1065 struct inode *newinode = NULL;
1066
Steve French6473a552005-11-29 20:20:10 -08001067 cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068
1069 xid = GetXid();
1070
1071 cifs_sb = CIFS_SB(inode->i_sb);
1072 pTcon = cifs_sb->tcon;
1073
Steve French7f573562005-08-30 11:32:14 -07001074 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 if (full_path == NULL) {
1076 FreeXid(xid);
1077 return -ENOMEM;
1078 }
Steve French50c2f752007-07-13 00:33:32 +00001079
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001080 if ((pTcon->ses->capabilities & CAP_UNIX) &&
1081 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Steve French2dd29d32007-04-23 22:07:35 +00001082 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
1083 u32 oplock = 0;
Steve Frenchf6d09982008-01-08 23:18:22 +00001084 FILE_UNIX_BASIC_INFO *pInfo =
Steve French2dd29d32007-04-23 22:07:35 +00001085 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001086 if (pInfo == NULL) {
Steve French2dd29d32007-04-23 22:07:35 +00001087 rc = -ENOMEM;
1088 goto mkdir_out;
1089 }
Steve French50c2f752007-07-13 00:33:32 +00001090
Jeffa8cd9252007-09-13 18:38:50 +00001091 mode &= ~current->fs->umask;
Steve French2dd29d32007-04-23 22:07:35 +00001092 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
1093 mode, NULL /* netfid */, pInfo, &oplock,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001094 full_path, cifs_sb->local_nls,
1095 cifs_sb->mnt_cifs_flags &
Steve French2dd29d32007-04-23 22:07:35 +00001096 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve Frenchc45d7072007-09-17 02:04:21 +00001097 if (rc == -EOPNOTSUPP) {
1098 kfree(pInfo);
1099 goto mkdir_retry_old;
1100 } else if (rc) {
Steve French2dd29d32007-04-23 22:07:35 +00001101 cFYI(1, ("posix mkdir returned 0x%x", rc));
1102 d_drop(direntry);
1103 } else {
Cyril Gorcunov8f2376a2007-10-14 17:58:43 +00001104 if (pInfo->Type == cpu_to_le32(-1)) {
1105 /* no return info, go query for it */
Steve French5a07cdf2007-09-16 23:12:47 +00001106 kfree(pInfo);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001107 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001108 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001109/*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
1110 to set uid/gid */
Steve French2dd29d32007-04-23 22:07:35 +00001111 inc_nlink(inode);
1112 if (pTcon->nocase)
1113 direntry->d_op = &cifs_ci_dentry_ops;
1114 else
1115 direntry->d_op = &cifs_dentry_ops;
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001116
1117 newinode = new_inode(inode->i_sb);
Steve French5a07cdf2007-09-16 23:12:47 +00001118 if (newinode == NULL) {
1119 kfree(pInfo);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001120 goto mkdir_get_info;
Steve French5a07cdf2007-09-16 23:12:47 +00001121 }
Jeff Layton6b37faa2008-10-06 21:54:41 +00001122
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001123 /* Is an i_ino of zero legal? */
1124 /* Are there sanity checks we can use to ensure that
1125 the server is really filling in that field? */
1126 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
1127 newinode->i_ino =
1128 (unsigned long)pInfo->UniqueId;
1129 } /* note ino incremented to unique num in new_inode */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001130 if (inode->i_sb->s_flags & MS_NOATIME)
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001131 newinode->i_flags |= S_NOATIME | S_NOCMTIME;
1132 newinode->i_nlink = 2;
1133
1134 insert_inode_hash(newinode);
Steve French2dd29d32007-04-23 22:07:35 +00001135 d_instantiate(direntry, newinode);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001136
1137 /* we already checked in POSIXCreate whether
1138 frame was long enough */
1139 posix_fill_in_inode(direntry->d_inode,
Steve French0b442d22008-02-26 03:44:02 +00001140 pInfo, 1 /* NewInode */);
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001141#ifdef CONFIG_CIFS_DEBUG2
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001142 cFYI(1, ("instantiated dentry %p %s to inode %p",
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001143 direntry, direntry->d_name.name, newinode));
1144
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001145 if (newinode->i_nlink != 2)
1146 cFYI(1, ("unexpected number of links %d",
Steve Frenchcbac3cb2007-04-25 11:46:06 +00001147 newinode->i_nlink));
1148#endif
Steve French2dd29d32007-04-23 22:07:35 +00001149 }
1150 kfree(pInfo);
1151 goto mkdir_out;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001152 }
Steve Frenchc45d7072007-09-17 02:04:21 +00001153mkdir_retry_old:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 /* BB add setting the equivalent of mode via CreateX w/ACLs */
Steve French737b7582005-04-28 22:41:06 -07001155 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
1156 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001157 if (rc) {
Steve French26a21b92006-05-31 18:05:34 +00001158 cFYI(1, ("cifs_mkdir returned 0x%x", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 d_drop(direntry);
1160 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001161mkdir_get_info:
Dave Hansend8c76e62006-09-30 23:29:04 -07001162 inc_nlink(inode);
Steve Frenchc18c8422007-07-18 23:21:09 +00001163 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 rc = cifs_get_inode_info_unix(&newinode, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001165 inode->i_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 else
1167 rc = cifs_get_inode_info(&newinode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +00001168 inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169
Steve Frenchb92327f2005-08-22 20:09:43 -07001170 if (pTcon->nocase)
1171 direntry->d_op = &cifs_ci_dentry_ops;
1172 else
1173 direntry->d_op = &cifs_dentry_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 d_instantiate(direntry, newinode);
Steve French2dd29d32007-04-23 22:07:35 +00001175 /* setting nlink not necessary except in cases where we
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001176 * failed to get it from the server or was set bogus */
Steve French2dd29d32007-04-23 22:07:35 +00001177 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001178 direntry->d_inode->i_nlink = 2;
Jeff Layton95089912008-08-06 04:39:02 +00001179
Jeff Layton67750fb2008-05-09 22:28:02 +00001180 mode &= ~current->fs->umask;
Jeff Layton95089912008-08-06 04:39:02 +00001181 /* must turn on setgid bit if parent dir has it */
1182 if (inode->i_mode & S_ISGID)
1183 mode |= S_ISGID;
1184
Steve Frenchc18c8422007-07-18 23:21:09 +00001185 if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001186 struct cifs_unix_set_info_args args = {
1187 .mode = mode,
1188 .ctime = NO_CHANGE_64,
1189 .atime = NO_CHANGE_64,
1190 .mtime = NO_CHANGE_64,
1191 .device = 0,
1192 };
Steve Frenchd0d2f2d2005-06-02 15:12:36 -07001193 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
David Howellsa001e5b2008-11-14 10:38:47 +11001194 args.uid = (__u64)current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001195 if (inode->i_mode & S_ISGID)
1196 args.gid = (__u64)inode->i_gid;
1197 else
David Howellsa001e5b2008-11-14 10:38:47 +11001198 args.gid = (__u64)current_fsgid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 } else {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001200 args.uid = NO_CHANGE_64;
1201 args.gid = NO_CHANGE_64;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 }
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001203 CIFSSMBUnixSetInfo(xid, pTcon, full_path, &args,
1204 cifs_sb->local_nls,
1205 cifs_sb->mnt_cifs_flags &
1206 CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French3ce53fc2007-06-08 14:55:14 +00001207 } else {
Jeff Layton67750fb2008-05-09 22:28:02 +00001208 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1209 (mode & S_IWUGO) == 0) {
1210 FILE_BASIC_INFO pInfo;
Jeff Layton6b37faa2008-10-06 21:54:41 +00001211 struct cifsInodeInfo *cifsInode;
1212 u32 dosattrs;
1213
Jeff Layton67750fb2008-05-09 22:28:02 +00001214 memset(&pInfo, 0, sizeof(pInfo));
Jeff Layton6b37faa2008-10-06 21:54:41 +00001215 cifsInode = CIFS_I(newinode);
1216 dosattrs = cifsInode->cifsAttrs|ATTR_READONLY;
1217 pInfo.Attributes = cpu_to_le32(dosattrs);
1218 tmprc = CIFSSMBSetPathInfo(xid, pTcon,
1219 full_path, &pInfo,
1220 cifs_sb->local_nls,
Jeff Layton67750fb2008-05-09 22:28:02 +00001221 cifs_sb->mnt_cifs_flags &
1222 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton6b37faa2008-10-06 21:54:41 +00001223 if (tmprc == 0)
1224 cifsInode->cifsAttrs = dosattrs;
Jeff Layton67750fb2008-05-09 22:28:02 +00001225 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001226 if (direntry->d_inode) {
Jeff Laytonb0fd30d2008-05-22 09:33:34 -04001227 if (cifs_sb->mnt_cifs_flags &
1228 CIFS_MOUNT_DYNPERM)
1229 direntry->d_inode->i_mode =
1230 (mode | S_IFDIR);
Steve French4e94a102008-05-23 18:22:46 +00001231
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001232 if (cifs_sb->mnt_cifs_flags &
Steve French6473a552005-11-29 20:20:10 -08001233 CIFS_MOUNT_SET_UID) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001234 direntry->d_inode->i_uid =
David Howellsa001e5b2008-11-14 10:38:47 +11001235 current_fsuid();
Jeff Layton95089912008-08-06 04:39:02 +00001236 if (inode->i_mode & S_ISGID)
1237 direntry->d_inode->i_gid =
1238 inode->i_gid;
1239 else
1240 direntry->d_inode->i_gid =
David Howellsa001e5b2008-11-14 10:38:47 +11001241 current_fsgid();
Steve French6473a552005-11-29 20:20:10 -08001242 }
1243 }
Steve French2a138ebb2005-11-29 21:22:19 -08001244 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001246mkdir_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 kfree(full_path);
1248 FreeXid(xid);
1249 return rc;
1250}
1251
1252int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1253{
1254 int rc = 0;
1255 int xid;
1256 struct cifs_sb_info *cifs_sb;
1257 struct cifsTconInfo *pTcon;
1258 char *full_path = NULL;
1259 struct cifsInodeInfo *cifsInode;
1260
Steve French26a21b92006-05-31 18:05:34 +00001261 cFYI(1, ("cifs_rmdir, inode = 0x%p", inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
1263 xid = GetXid();
1264
1265 cifs_sb = CIFS_SB(inode->i_sb);
1266 pTcon = cifs_sb->tcon;
1267
Steve French7f573562005-08-30 11:32:14 -07001268 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 if (full_path == NULL) {
1270 FreeXid(xid);
1271 return -ENOMEM;
1272 }
1273
Steve French737b7582005-04-28 22:41:06 -07001274 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1275 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276
1277 if (!rc) {
Dave Hansen9a53c3a2006-09-30 23:29:03 -07001278 drop_nlink(inode);
Steve French3677db12007-02-26 16:46:11 +00001279 spin_lock(&direntry->d_inode->i_lock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001280 i_size_write(direntry->d_inode, 0);
Dave Hansence71ec32006-09-30 23:29:06 -07001281 clear_nlink(direntry->d_inode);
Steve French3677db12007-02-26 16:46:11 +00001282 spin_unlock(&direntry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 }
1284
1285 cifsInode = CIFS_I(direntry->d_inode);
1286 cifsInode->time = 0; /* force revalidate to go get info when
1287 needed */
1288 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1289 current_fs_time(inode->i_sb);
1290
1291 kfree(full_path);
1292 FreeXid(xid);
1293 return rc;
1294}
1295
Steve Frenchee2fd962008-09-23 18:23:33 +00001296static int
1297cifs_do_rename(int xid, struct dentry *from_dentry, const char *fromPath,
1298 struct dentry *to_dentry, const char *toPath)
1299{
1300 struct cifs_sb_info *cifs_sb = CIFS_SB(from_dentry->d_sb);
1301 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1302 __u16 srcfid;
1303 int oplock, rc;
1304
1305 /* try path-based rename first */
1306 rc = CIFSSMBRename(xid, pTcon, fromPath, toPath, cifs_sb->local_nls,
1307 cifs_sb->mnt_cifs_flags &
1308 CIFS_MOUNT_MAP_SPECIAL_CHR);
1309
1310 /*
1311 * don't bother with rename by filehandle unless file is busy and
1312 * source Note that cross directory moves do not work with
1313 * rename by filehandle to various Windows servers.
1314 */
1315 if (rc == 0 || rc != -ETXTBSY)
1316 return rc;
1317
1318 /* open the file to be renamed -- we need DELETE perms */
1319 rc = CIFSSMBOpen(xid, pTcon, fromPath, FILE_OPEN, DELETE,
1320 CREATE_NOT_DIR, &srcfid, &oplock, NULL,
1321 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1322 CIFS_MOUNT_MAP_SPECIAL_CHR);
1323
1324 if (rc == 0) {
1325 rc = CIFSSMBRenameOpenFile(xid, pTcon, srcfid,
1326 (const char *) to_dentry->d_name.name,
1327 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
1328 CIFS_MOUNT_MAP_SPECIAL_CHR);
1329
1330 CIFSSMBClose(xid, pTcon, srcfid);
1331 }
1332
1333 return rc;
1334}
1335
Jeff Layton14121bd2008-10-20 14:45:22 -04001336int cifs_rename(struct inode *source_dir, struct dentry *source_dentry,
1337 struct inode *target_dir, struct dentry *target_dentry)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338{
Steve Frenchee2fd962008-09-23 18:23:33 +00001339 char *fromName = NULL;
1340 char *toName = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 struct cifs_sb_info *cifs_sb_source;
1342 struct cifs_sb_info *cifs_sb_target;
Jeff Layton14121bd2008-10-20 14:45:22 -04001343 struct cifsTconInfo *tcon;
Steve Frenchee2fd962008-09-23 18:23:33 +00001344 FILE_UNIX_BASIC_INFO *info_buf_source = NULL;
1345 FILE_UNIX_BASIC_INFO *info_buf_target;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001346 int xid, rc, tmprc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347
Jeff Layton14121bd2008-10-20 14:45:22 -04001348 cifs_sb_target = CIFS_SB(target_dir->i_sb);
1349 cifs_sb_source = CIFS_SB(source_dir->i_sb);
1350 tcon = cifs_sb_source->tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351
Steve Frenchee2fd962008-09-23 18:23:33 +00001352 xid = GetXid();
1353
1354 /*
1355 * BB: this might be allowed if same server, but different share.
1356 * Consider adding support for this
1357 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001358 if (tcon != cifs_sb_target->tcon) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001359 rc = -EXDEV;
1360 goto cifs_rename_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 }
1362
Steve Frenchee2fd962008-09-23 18:23:33 +00001363 /*
1364 * we already have the rename sem so we do not need to
1365 * grab it again here to protect the path integrity
1366 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001367 fromName = build_path_from_dentry(source_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001368 if (fromName == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 rc = -ENOMEM;
1370 goto cifs_rename_exit;
1371 }
1372
Jeff Layton14121bd2008-10-20 14:45:22 -04001373 toName = build_path_from_dentry(target_dentry);
Steve Frenchee2fd962008-09-23 18:23:33 +00001374 if (toName == NULL) {
1375 rc = -ENOMEM;
1376 goto cifs_rename_exit;
1377 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378
Jeff Layton14121bd2008-10-20 14:45:22 -04001379 rc = cifs_do_rename(xid, source_dentry, fromName,
1380 target_dentry, toName);
Steve Frenchee2fd962008-09-23 18:23:33 +00001381
Jeff Layton14121bd2008-10-20 14:45:22 -04001382 if (rc == -EEXIST && tcon->unix_ext) {
Steve Frenchee2fd962008-09-23 18:23:33 +00001383 /*
Jeff Layton14121bd2008-10-20 14:45:22 -04001384 * Are src and dst hardlinks of same inode? We can
1385 * only tell with unix extensions enabled
Steve Frenchee2fd962008-09-23 18:23:33 +00001386 */
Jeff Layton14121bd2008-10-20 14:45:22 -04001387 info_buf_source =
1388 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO),
1389 GFP_KERNEL);
1390 if (info_buf_source == NULL) {
1391 rc = -ENOMEM;
1392 goto cifs_rename_exit;
1393 }
1394
1395 info_buf_target = info_buf_source + 1;
Jeff Layton8d281ef2008-10-22 13:57:01 -04001396 tmprc = CIFSSMBUnixQPathInfo(xid, tcon, fromName,
Jeff Layton14121bd2008-10-20 14:45:22 -04001397 info_buf_source,
1398 cifs_sb_source->local_nls,
1399 cifs_sb_source->mnt_cifs_flags &
1400 CIFS_MOUNT_MAP_SPECIAL_CHR);
Jeff Layton8d281ef2008-10-22 13:57:01 -04001401 if (tmprc != 0)
Jeff Layton14121bd2008-10-20 14:45:22 -04001402 goto unlink_target;
1403
Jeff Layton8d281ef2008-10-22 13:57:01 -04001404 tmprc = CIFSSMBUnixQPathInfo(xid, tcon,
Jeff Layton14121bd2008-10-20 14:45:22 -04001405 toName, info_buf_target,
1406 cifs_sb_target->local_nls,
1407 /* remap based on source sb */
1408 cifs_sb_source->mnt_cifs_flags &
1409 CIFS_MOUNT_MAP_SPECIAL_CHR);
1410
Jeff Layton8d281ef2008-10-22 13:57:01 -04001411 if (tmprc == 0 && (info_buf_source->UniqueId ==
Jeff Laytonae6884a2008-11-03 14:05:08 -05001412 info_buf_target->UniqueId)) {
Jeff Layton14121bd2008-10-20 14:45:22 -04001413 /* same file, POSIX says that this is a noop */
Jeff Laytonae6884a2008-11-03 14:05:08 -05001414 rc = 0;
Jeff Layton14121bd2008-10-20 14:45:22 -04001415 goto cifs_rename_exit;
Jeff Laytonae6884a2008-11-03 14:05:08 -05001416 }
Jeff Layton14121bd2008-10-20 14:45:22 -04001417 } /* else ... BB we could add the same check for Windows by
1418 checking the UniqueId via FILE_INTERNAL_INFO */
1419
Jeff Layton14121bd2008-10-20 14:45:22 -04001420unlink_target:
Jeff Layton8d281ef2008-10-22 13:57:01 -04001421 if ((rc == -EACCES) || (rc == -EEXIST)) {
1422 tmprc = cifs_unlink(target_dir, target_dentry);
Jeff Layton14121bd2008-10-20 14:45:22 -04001423 if (tmprc)
1424 goto cifs_rename_exit;
1425
Jeff Layton14121bd2008-10-20 14:45:22 -04001426 rc = cifs_do_rename(xid, source_dentry, fromName,
1427 target_dentry, toName);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 }
1429
1430cifs_rename_exit:
Steve Frenchee2fd962008-09-23 18:23:33 +00001431 kfree(info_buf_source);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 kfree(fromName);
1433 kfree(toName);
1434 FreeXid(xid);
1435 return rc;
1436}
1437
1438int cifs_revalidate(struct dentry *direntry)
1439{
1440 int xid;
Jeff Laytoncea21802007-11-20 23:19:03 +00001441 int rc = 0, wbrc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 char *full_path;
1443 struct cifs_sb_info *cifs_sb;
1444 struct cifsInodeInfo *cifsInode;
1445 loff_t local_size;
1446 struct timespec local_mtime;
Steve French4b18f2a2008-04-29 00:06:05 +00001447 bool invalidate_inode = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448
1449 if (direntry->d_inode == NULL)
1450 return -ENOENT;
1451
1452 cifsInode = CIFS_I(direntry->d_inode);
1453
1454 if (cifsInode == NULL)
1455 return -ENOENT;
1456
1457 /* no sense revalidating inode info on file that no one can write */
1458 if (CIFS_I(direntry->d_inode)->clientCanCacheRead)
1459 return rc;
1460
1461 xid = GetXid();
1462
1463 cifs_sb = CIFS_SB(direntry->d_sb);
1464
1465 /* can not safely grab the rename sem here if rename calls revalidate
1466 since that would deadlock */
Steve French7f573562005-08-30 11:32:14 -07001467 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 if (full_path == NULL) {
1469 FreeXid(xid);
1470 return -ENOMEM;
1471 }
1472 cFYI(1, ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1473 "jiffies %ld", full_path, direntry->d_inode,
1474 direntry->d_inode->i_count.counter, direntry,
1475 direntry->d_time, jiffies));
1476
1477 if (cifsInode->time == 0) {
1478 /* was set to zero previously to force revalidate */
1479 } else if (time_before(jiffies, cifsInode->time + HZ) &&
1480 lookupCacheEnabled) {
1481 if ((S_ISREG(direntry->d_inode->i_mode) == 0) ||
1482 (direntry->d_inode->i_nlink == 1)) {
1483 kfree(full_path);
1484 FreeXid(xid);
1485 return rc;
1486 } else {
1487 cFYI(1, ("Have to revalidate file due to hardlinks"));
1488 }
1489 }
1490
1491 /* save mtime and size */
1492 local_mtime = direntry->d_inode->i_mtime;
1493 local_size = direntry->d_inode->i_size;
1494
Steve Frenchc18c8422007-07-18 23:21:09 +00001495 if (cifs_sb->tcon->unix_ext) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001497 direntry->d_sb, xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 if (rc) {
1499 cFYI(1, ("error on getting revalidate info %d", rc));
1500/* if (rc != -ENOENT)
1501 rc = 0; */ /* BB should we cache info on
1502 certain errors? */
1503 }
1504 } else {
1505 rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
Steve French8b1327f2008-03-14 22:37:16 +00001506 direntry->d_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507 if (rc) {
1508 cFYI(1, ("error on getting revalidate info %d", rc));
1509/* if (rc != -ENOENT)
1510 rc = 0; */ /* BB should we cache info on
1511 certain errors? */
1512 }
1513 }
1514 /* should we remap certain errors, access denied?, to zero */
1515
1516 /* if not oplocked, we invalidate inode pages if mtime or file size
1517 had changed on server */
1518
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001519 if (timespec_equal(&local_mtime, &direntry->d_inode->i_mtime) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001520 (local_size == direntry->d_inode->i_size)) {
1521 cFYI(1, ("cifs_revalidate - inode unchanged"));
1522 } else {
1523 /* file may have changed on server */
1524 if (cifsInode->clientCanCacheRead) {
1525 /* no need to invalidate inode pages since we were the
1526 only ones who could have modified the file and the
1527 server copy is staler than ours */
1528 } else {
Steve French4b18f2a2008-04-29 00:06:05 +00001529 invalidate_inode = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 }
1531 }
1532
1533 /* can not grab this sem since kernel filesys locking documentation
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001534 indicates i_mutex may be taken by the kernel on lookup and rename
1535 which could deadlock if we grab the i_mutex here as well */
1536/* mutex_lock(&direntry->d_inode->i_mutex);*/
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 /* need to write out dirty pages here */
1538 if (direntry->d_inode->i_mapping) {
1539 /* do we need to lock inode until after invalidate completes
1540 below? */
Jeff Laytoncea21802007-11-20 23:19:03 +00001541 wbrc = filemap_fdatawrite(direntry->d_inode->i_mapping);
1542 if (wbrc)
1543 CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001544 }
1545 if (invalidate_inode) {
Steve French3abb9272005-11-28 08:16:13 -08001546 /* shrink_dcache not necessary now that cifs dentry ops
1547 are exported for negative dentries */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001548/* if (S_ISDIR(direntry->d_inode->i_mode))
Steve French3abb9272005-11-28 08:16:13 -08001549 shrink_dcache_parent(direntry); */
1550 if (S_ISREG(direntry->d_inode->i_mode)) {
Suresh Jayaraman9e96af82008-08-05 14:38:40 +05301551 if (direntry->d_inode->i_mapping) {
Jeff Laytoncea21802007-11-20 23:19:03 +00001552 wbrc = filemap_fdatawait(direntry->d_inode->i_mapping);
1553 if (wbrc)
1554 CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
Suresh Jayaraman9e96af82008-08-05 14:38:40 +05301555 }
Steve French3abb9272005-11-28 08:16:13 -08001556 /* may eventually have to do this for open files too */
1557 if (list_empty(&(cifsInode->openFileList))) {
1558 /* changed on server - flush read ahead pages */
1559 cFYI(1, ("Invalidating read ahead data on "
1560 "closed file"));
1561 invalidate_remote_inode(direntry->d_inode);
1562 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 }
1564 }
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001565/* mutex_unlock(&direntry->d_inode->i_mutex); */
Steve French50c2f752007-07-13 00:33:32 +00001566
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 kfree(full_path);
1568 FreeXid(xid);
1569 return rc;
1570}
1571
1572int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1573 struct kstat *stat)
1574{
1575 int err = cifs_revalidate(dentry);
Steve French5fe14c82006-11-07 19:26:33 +00001576 if (!err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 generic_fillattr(dentry->d_inode, stat);
Steve French5fe14c82006-11-07 19:26:33 +00001578 stat->blksize = CIFS_MAX_MSGSIZE;
1579 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 return err;
1581}
1582
1583static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1584{
1585 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1586 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1587 struct page *page;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 int rc = 0;
1589
1590 page = grab_cache_page(mapping, index);
1591 if (!page)
1592 return -ENOMEM;
1593
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001594 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 unlock_page(page);
1596 page_cache_release(page);
1597 return rc;
1598}
1599
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001600static int cifs_vmtruncate(struct inode *inode, loff_t offset)
Steve French3677db12007-02-26 16:46:11 +00001601{
1602 struct address_space *mapping = inode->i_mapping;
1603 unsigned long limit;
1604
Steve Frenchba6a46a2007-02-26 20:06:29 +00001605 spin_lock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001606 if (inode->i_size < offset)
1607 goto do_expand;
1608 /*
1609 * truncation of in-use swapfiles is disallowed - it would cause
1610 * subsequent swapout to scribble on the now-freed blocks.
1611 */
Steve Frenchba6a46a2007-02-26 20:06:29 +00001612 if (IS_SWAPFILE(inode)) {
1613 spin_unlock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001614 goto out_busy;
Steve Frenchba6a46a2007-02-26 20:06:29 +00001615 }
Steve French3677db12007-02-26 16:46:11 +00001616 i_size_write(inode, offset);
1617 spin_unlock(&inode->i_lock);
Steve French8064ab42007-08-22 22:12:07 +00001618 /*
1619 * unmap_mapping_range is called twice, first simply for efficiency
1620 * so that truncate_inode_pages does fewer single-page unmaps. However
1621 * after this first call, and before truncate_inode_pages finishes,
1622 * it is possible for private pages to be COWed, which remain after
1623 * truncate_inode_pages finishes, hence the second unmap_mapping_range
1624 * call must be made for correctness.
1625 */
Steve French3677db12007-02-26 16:46:11 +00001626 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1627 truncate_inode_pages(mapping, offset);
Steve French8064ab42007-08-22 22:12:07 +00001628 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
Steve French3677db12007-02-26 16:46:11 +00001629 goto out_truncate;
1630
1631do_expand:
1632 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
Steve Frenchba6a46a2007-02-26 20:06:29 +00001633 if (limit != RLIM_INFINITY && offset > limit) {
1634 spin_unlock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001635 goto out_sig;
Steve Frenchba6a46a2007-02-26 20:06:29 +00001636 }
1637 if (offset > inode->i_sb->s_maxbytes) {
1638 spin_unlock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001639 goto out_big;
Steve Frenchba6a46a2007-02-26 20:06:29 +00001640 }
Steve French3677db12007-02-26 16:46:11 +00001641 i_size_write(inode, offset);
Steve Frenchba6a46a2007-02-26 20:06:29 +00001642 spin_unlock(&inode->i_lock);
Steve French3677db12007-02-26 16:46:11 +00001643out_truncate:
1644 if (inode->i_op && inode->i_op->truncate)
1645 inode->i_op->truncate(inode);
1646 return 0;
1647out_sig:
1648 send_sig(SIGXFSZ, current, 0);
1649out_big:
1650 return -EFBIG;
1651out_busy:
1652 return -ETXTBSY;
1653}
1654
Jeff Layton8efdbde2008-07-23 21:28:12 +00001655static int
1656cifs_set_file_size(struct inode *inode, struct iattr *attrs,
1657 int xid, char *full_path)
1658{
1659 int rc;
1660 struct cifsFileInfo *open_file;
1661 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1662 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1663 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1664
1665 /*
1666 * To avoid spurious oplock breaks from server, in the case of
1667 * inodes that we already have open, avoid doing path based
1668 * setting of file size if we can do it by handle.
1669 * This keeps our caching token (oplock) and avoids timeouts
1670 * when the local oplock break takes longer to flush
1671 * writebehind data than the SMB timeout for the SetPathInfo
1672 * request would allow
1673 */
1674 open_file = find_writable_file(cifsInode);
1675 if (open_file) {
1676 __u16 nfid = open_file->netfid;
1677 __u32 npid = open_file->pid;
1678 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size, nfid,
1679 npid, false);
1680 atomic_dec(&open_file->wrtPending);
1681 cFYI(1, ("SetFSize for attrs rc = %d", rc));
1682 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1683 unsigned int bytes_written;
1684 rc = CIFSSMBWrite(xid, pTcon, nfid, 0, attrs->ia_size,
1685 &bytes_written, NULL, NULL, 1);
1686 cFYI(1, ("Wrt seteof rc %d", rc));
1687 }
1688 } else
1689 rc = -EINVAL;
1690
1691 if (rc != 0) {
1692 /* Set file size by pathname rather than by handle
1693 either because no valid, writeable file handle for
1694 it was found or because there was an error setting
1695 it by handle */
1696 rc = CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size,
1697 false, cifs_sb->local_nls,
1698 cifs_sb->mnt_cifs_flags &
1699 CIFS_MOUNT_MAP_SPECIAL_CHR);
1700 cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
1701 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1702 __u16 netfid;
1703 int oplock = 0;
1704
1705 rc = SMBLegacyOpen(xid, pTcon, full_path,
1706 FILE_OPEN, GENERIC_WRITE,
1707 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1708 cifs_sb->local_nls,
1709 cifs_sb->mnt_cifs_flags &
1710 CIFS_MOUNT_MAP_SPECIAL_CHR);
1711 if (rc == 0) {
1712 unsigned int bytes_written;
1713 rc = CIFSSMBWrite(xid, pTcon, netfid, 0,
1714 attrs->ia_size,
1715 &bytes_written, NULL,
1716 NULL, 1);
1717 cFYI(1, ("wrt seteof rc %d", rc));
1718 CIFSSMBClose(xid, pTcon, netfid);
1719 }
1720 }
1721 }
1722
1723 if (rc == 0) {
1724 rc = cifs_vmtruncate(inode, attrs->ia_size);
1725 cifs_truncate_page(inode->i_mapping, inode->i_size);
1726 }
1727
1728 return rc;
1729}
1730
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001731static int
1732cifs_setattr_unix(struct dentry *direntry, struct iattr *attrs)
1733{
1734 int rc;
1735 int xid;
1736 char *full_path = NULL;
1737 struct inode *inode = direntry->d_inode;
1738 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
1739 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1740 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1741 struct cifs_unix_set_info_args *args = NULL;
1742
1743 cFYI(1, ("setattr_unix on file %s attrs->ia_valid=0x%x",
1744 direntry->d_name.name, attrs->ia_valid));
1745
1746 xid = GetXid();
1747
1748 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1749 /* check if we have permission to change attrs */
1750 rc = inode_change_ok(inode, attrs);
1751 if (rc < 0)
1752 goto out;
1753 else
1754 rc = 0;
1755 }
1756
1757 full_path = build_path_from_dentry(direntry);
1758 if (full_path == NULL) {
1759 rc = -ENOMEM;
1760 goto out;
1761 }
1762
1763 if ((attrs->ia_valid & ATTR_MTIME) || (attrs->ia_valid & ATTR_SIZE)) {
1764 /*
1765 Flush data before changing file size or changing the last
1766 write time of the file on the server. If the
1767 flush returns error, store it to report later and continue.
1768 BB: This should be smarter. Why bother flushing pages that
1769 will be truncated anyway? Also, should we error out here if
1770 the flush returns error?
1771 */
1772 rc = filemap_write_and_wait(inode->i_mapping);
1773 if (rc != 0) {
1774 cifsInode->write_behind_rc = rc;
1775 rc = 0;
1776 }
1777 }
1778
1779 if (attrs->ia_valid & ATTR_SIZE) {
1780 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1781 if (rc != 0)
1782 goto out;
1783 }
1784
1785 /* skip mode change if it's just for clearing setuid/setgid */
1786 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1787 attrs->ia_valid &= ~ATTR_MODE;
1788
1789 args = kmalloc(sizeof(*args), GFP_KERNEL);
1790 if (args == NULL) {
1791 rc = -ENOMEM;
1792 goto out;
1793 }
1794
1795 /* set up the struct */
1796 if (attrs->ia_valid & ATTR_MODE)
1797 args->mode = attrs->ia_mode;
1798 else
1799 args->mode = NO_CHANGE_64;
1800
1801 if (attrs->ia_valid & ATTR_UID)
1802 args->uid = attrs->ia_uid;
1803 else
1804 args->uid = NO_CHANGE_64;
1805
1806 if (attrs->ia_valid & ATTR_GID)
1807 args->gid = attrs->ia_gid;
1808 else
1809 args->gid = NO_CHANGE_64;
1810
1811 if (attrs->ia_valid & ATTR_ATIME)
1812 args->atime = cifs_UnixTimeToNT(attrs->ia_atime);
1813 else
1814 args->atime = NO_CHANGE_64;
1815
1816 if (attrs->ia_valid & ATTR_MTIME)
1817 args->mtime = cifs_UnixTimeToNT(attrs->ia_mtime);
1818 else
1819 args->mtime = NO_CHANGE_64;
1820
1821 if (attrs->ia_valid & ATTR_CTIME)
1822 args->ctime = cifs_UnixTimeToNT(attrs->ia_ctime);
1823 else
1824 args->ctime = NO_CHANGE_64;
1825
1826 args->device = 0;
1827 rc = CIFSSMBUnixSetInfo(xid, pTcon, full_path, args,
1828 cifs_sb->local_nls,
1829 cifs_sb->mnt_cifs_flags &
1830 CIFS_MOUNT_MAP_SPECIAL_CHR);
1831
1832 if (!rc)
1833 rc = inode_setattr(inode, attrs);
1834out:
1835 kfree(args);
1836 kfree(full_path);
1837 FreeXid(xid);
1838 return rc;
1839}
1840
Jeff Layton0510eeb2008-08-02 07:26:12 -04001841static int
1842cifs_setattr_nounix(struct dentry *direntry, struct iattr *attrs)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843{
1844 int xid;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001845 struct inode *inode = direntry->d_inode;
1846 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001847 struct cifsInodeInfo *cifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 char *full_path = NULL;
1849 int rc = -EACCES;
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001850 __u32 dosattr = 0;
Jeff Layton4e1e7fb2008-08-02 07:26:12 -04001851 __u64 mode = NO_CHANGE_64;
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001852
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 xid = GetXid();
1854
Steve French39798772006-05-31 22:40:51 +00001855 cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856 direntry->d_name.name, attrs->ia_valid));
Steve French6473a552005-11-29 20:20:10 -08001857
Steve French2a138ebb2005-11-29 21:22:19 -08001858 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
Steve French6473a552005-11-29 20:20:10 -08001859 /* check if we have permission to change attrs */
Jeff Layton02eadef2008-05-09 21:26:11 +00001860 rc = inode_change_ok(inode, attrs);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001861 if (rc < 0) {
Steve French6473a552005-11-29 20:20:10 -08001862 FreeXid(xid);
1863 return rc;
1864 } else
1865 rc = 0;
1866 }
Steve French50c2f752007-07-13 00:33:32 +00001867
Steve French7f573562005-08-30 11:32:14 -07001868 full_path = build_path_from_dentry(direntry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 if (full_path == NULL) {
1870 FreeXid(xid);
1871 return -ENOMEM;
1872 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873
Steve French50531442008-03-14 19:21:31 +00001874 if ((attrs->ia_valid & ATTR_MTIME) || (attrs->ia_valid & ATTR_SIZE)) {
Jeff Laytoncea21802007-11-20 23:19:03 +00001875 /*
Steve French50531442008-03-14 19:21:31 +00001876 Flush data before changing file size or changing the last
1877 write time of the file on the server. If the
Jeff Laytoncea21802007-11-20 23:19:03 +00001878 flush returns error, store it to report later and continue.
1879 BB: This should be smarter. Why bother flushing pages that
1880 will be truncated anyway? Also, should we error out here if
1881 the flush returns error?
1882 */
Jeff Layton02eadef2008-05-09 21:26:11 +00001883 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +00001884 if (rc != 0) {
Jeff Layton02eadef2008-05-09 21:26:11 +00001885 cifsInode->write_behind_rc = rc;
Jeff Laytoncea21802007-11-20 23:19:03 +00001886 rc = 0;
1887 }
Steve French50531442008-03-14 19:21:31 +00001888 }
Jeff Laytoncea21802007-11-20 23:19:03 +00001889
Steve French50531442008-03-14 19:21:31 +00001890 if (attrs->ia_valid & ATTR_SIZE) {
Jeff Layton8efdbde2008-07-23 21:28:12 +00001891 rc = cifs_set_file_size(inode, attrs, xid, full_path);
1892 if (rc != 0)
Steve Frenche30dcf32005-09-20 20:49:16 -07001893 goto cifs_setattr_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001894 }
Jeff Layton4ca691a2008-05-22 09:33:34 -04001895
1896 /*
1897 * Without unix extensions we can't send ownership changes to the
1898 * server, so silently ignore them. This is consistent with how
1899 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
1900 * CIFSACL support + proper Windows to Unix idmapping, we may be
1901 * able to support this in the future.
1902 */
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001903 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID))
Jeff Layton4ca691a2008-05-22 09:33:34 -04001904 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905
Jeff Laytond32c4f22007-10-18 03:05:22 -07001906 /* skip mode change if it's just for clearing setuid/setgid */
1907 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1908 attrs->ia_valid &= ~ATTR_MODE;
1909
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 if (attrs->ia_valid & ATTR_MODE) {
Jeff Layton51328612008-05-22 09:33:34 -04001911 cFYI(1, ("Mode changed to 0%o", attrs->ia_mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 mode = attrs->ia_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 }
1914
Jeff Layton3fe5c1d2008-08-02 07:26:12 -04001915 if (attrs->ia_valid & ATTR_MODE) {
Steve Frenchcdbce9c2005-11-19 21:04:52 -08001916 rc = 0;
Steve French97837582007-12-31 07:47:21 +00001917#ifdef CONFIG_CIFS_EXPERIMENTAL
1918 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
Jeff Layton02eadef2008-05-09 21:26:11 +00001919 rc = mode_to_acl(inode, full_path, mode);
Jeff Layton51328612008-05-22 09:33:34 -04001920 else
Steve French97837582007-12-31 07:47:21 +00001921#endif
Jeff Layton51328612008-05-22 09:33:34 -04001922 if (((mode & S_IWUGO) == 0) &&
1923 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001924
1925 dosattr = cifsInode->cifsAttrs | ATTR_READONLY;
1926
Jeff Layton51328612008-05-22 09:33:34 -04001927 /* fix up mode if we're not using dynperm */
1928 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
1929 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
1930 } else if ((mode & S_IWUGO) &&
1931 (cifsInode->cifsAttrs & ATTR_READONLY)) {
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001932
1933 dosattr = cifsInode->cifsAttrs & ~ATTR_READONLY;
1934 /* Attributes of 0 are ignored */
1935 if (dosattr == 0)
1936 dosattr |= ATTR_NORMAL;
Jeff Layton51328612008-05-22 09:33:34 -04001937
1938 /* reset local inode permissions to normal */
1939 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1940 attrs->ia_mode &= ~(S_IALLUGO);
1941 if (S_ISDIR(inode->i_mode))
1942 attrs->ia_mode |=
1943 cifs_sb->mnt_dir_mode;
1944 else
1945 attrs->ia_mode |=
1946 cifs_sb->mnt_file_mode;
1947 }
1948 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1949 /* ignore mode change - ATTR_READONLY hasn't changed */
1950 attrs->ia_valid &= ~ATTR_MODE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001952 }
1953
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001954 if (attrs->ia_valid & (ATTR_MTIME|ATTR_ATIME|ATTR_CTIME) ||
1955 ((attrs->ia_valid & ATTR_MODE) && dosattr)) {
1956 rc = cifs_set_file_info(inode, attrs, xid, full_path, dosattr);
1957 /* BB: check for rc = -EOPNOTSUPP and switch to legacy mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958
Steve Frenche30dcf32005-09-20 20:49:16 -07001959 /* Even if error on time set, no sense failing the call if
1960 the server would set the time to a reasonable value anyway,
1961 and this check ensures that we are not being called from
1962 sys_utimes in which case we ought to fail the call back to
1963 the user when the server rejects the call */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001964 if ((rc) && (attrs->ia_valid &
Jeff Laytonfeb3e202008-08-02 07:26:12 -04001965 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
Steve Frenche30dcf32005-09-20 20:49:16 -07001966 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 }
1968
1969 /* do not need local check to inode_check_ok since the server does
1970 that */
1971 if (!rc)
Jeff Layton02eadef2008-05-09 21:26:11 +00001972 rc = inode_setattr(inode, attrs);
Steve Frenche30dcf32005-09-20 20:49:16 -07001973cifs_setattr_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 kfree(full_path);
1975 FreeXid(xid);
1976 return rc;
1977}
1978
Jeff Layton0510eeb2008-08-02 07:26:12 -04001979int
1980cifs_setattr(struct dentry *direntry, struct iattr *attrs)
1981{
1982 struct inode *inode = direntry->d_inode;
1983 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1984 struct cifsTconInfo *pTcon = cifs_sb->tcon;
1985
1986 if (pTcon->unix_ext)
1987 return cifs_setattr_unix(direntry, attrs);
1988
1989 return cifs_setattr_nounix(direntry, attrs);
1990
1991 /* BB: add cifs_setattr_legacy for really old servers */
1992}
1993
Steve French99ee4db2007-02-27 05:35:17 +00001994#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995void cifs_delete_inode(struct inode *inode)
1996{
Steve French26a21b92006-05-31 18:05:34 +00001997 cFYI(1, ("In cifs_delete_inode, inode = 0x%p", inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 /* may have to add back in if and when safe distributed caching of
1999 directories added e.g. via FindNotify */
2000}
Steve French99ee4db2007-02-27 05:35:17 +00002001#endif