?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
disable most mode changes on non-unix/non-cifsacl mounts
[linux-2.6/kmemtrace.git] / fs / cifs / inode.c
blob722be543ceec1ec9f4f086d149247b12d6ac3b7a
1 /*
2 * fs/cifs/inode.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2007
5 * Author(s): Steve French (sfrench@us.ibm.com)
6 *
7 * This library is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU Lesser General Public License as published
9 * by the Free Software Foundation; either version 2.1 of the License, or
10 * (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
15 * the GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public License
18 * along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21 #include <linux/fs.h>
22 #include <linux/stat.h>
23 #include <linux/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
32
33 static void cifs_set_ops(struct inode *inode, const bool is_dfs_referral)
34 {
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:
60 #ifdef CONFIG_CIFS_DFS_UPCALL
61 if (is_dfs_referral) {
62 inode->i_op = &cifs_dfs_referral_inode_operations;
63 } else {
64 #else /* NO DFS support, treat as a directory */
65 {
66 #endif
67 inode->i_op = &cifs_dir_inode_ops;
68 inode->i_fop = &cifs_dir_ops;
69 }
70 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
80 static 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
164
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 */
170 static void fill_fake_finddataunix(FILE_UNIX_BASIC_INFO *pfnd_dat,
171 struct super_block *sb)
172 {
173 struct inode *pinode = NULL;
174
175 memset(pfnd_dat, 0, sizeof(FILE_UNIX_BASIC_INFO));
176
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
202 int cifs_get_inode_info_unix(struct inode **pinode,
203 const unsigned char *full_path, struct super_block *sb, int xid)
204 {
205 int rc = 0;
206 FILE_UNIX_BASIC_INFO find_data;
207 struct cifsTconInfo *pTcon;
208 struct inode *inode;
209 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
210 bool is_dfs_referral = false;
211 struct cifsInodeInfo *cifsInfo;
212 __u64 num_of_bytes;
213 __u64 end_of_file;
214
215 pTcon = cifs_sb->tcon;
216 cFYI(1, ("Getting info on %s", full_path));
217
218 /* could have done a find first instead but this returns more info */
219 rc = CIFSSMBUnixQPathInfo(xid, pTcon, full_path, &find_data,
220 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
221 CIFS_MOUNT_MAP_SPECIAL_CHR);
222 if (rc) {
223 if (rc == -EREMOTE && !is_dfs_referral) {
224 is_dfs_referral = true;
225 cFYI(DBG2, ("DFS ref"));
226 /* for DFS, server does not give us real inode data */
227 fill_fake_finddataunix(&find_data, sb);
228 rc = 0;
229 }
230 }
231 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;
239 goto cgiiu_exit;
240 }
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);
272 cgiiu_exit:
273 return rc;
274 }
275
276 static int decode_sfu_inode(struct inode *inode, __u64 size,
277 const unsigned char *path,
278 struct cifs_sb_info *cifs_sb, int xid)
279 {
280 int rc;
281 int oplock = 0;
282 __u16 netfid;
283 struct cifsTconInfo *pTcon = cifs_sb->tcon;
284 char buf[24];
285 unsigned int bytes_read;
286 char *pbuf;
287
288 pbuf = buf;
289
290 if (size == 0) {
291 inode->i_mode |= S_IFIFO;
292 return 0;
293 } else if (size < 8) {
294 return -EINVAL; /* EOPNOTSUPP? */
295 }
296
297 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);
302 if (rc == 0) {
303 int buf_type = CIFS_NO_BUFFER;
304 /* Read header */
305 rc = CIFSSMBRead(xid, pTcon,
306 netfid,
307 24 /* length */, 0 /* offset */,
308 &bytes_read, &pbuf, &buf_type);
309 if ((rc == 0) && (bytes_read >= 8)) {
310 if (memcmp("IntxBLK", pbuf, 8) == 0) {
311 cFYI(1, ("Block device"));
312 inode->i_mode |= S_IFBLK;
313 if (bytes_read == 24) {
314 /* 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 }
321 } else if (memcmp("IntxCHR", pbuf, 8) == 0) {
322 cFYI(1, ("Char device"));
323 inode->i_mode |= S_IFCHR;
324 if (bytes_read == 24) {
325 /* 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);
331 }
332 } else if (memcmp("IntxLNK", pbuf, 7) == 0) {
333 cFYI(1, ("Symlink"));
334 inode->i_mode |= S_IFLNK;
335 } else {
336 inode->i_mode |= S_IFREG; /* file? */
337 rc = -EOPNOTSUPP;
338 }
339 } else {
340 inode->i_mode |= S_IFREG; /* then it is a file */
341 rc = -EOPNOTSUPP; /* or some unknown SFU type */
342 }
343 CIFSSMBClose(xid, pTcon, netfid);
344 }
345 return rc;
346 }
347
348 #define SFBITS_MASK (S_ISVTX | S_ISGID | S_ISUID) /* SETFILEBITS valid bits */
349
350 static int get_sfu_mode(struct inode *inode,
351 const unsigned char *path,
352 struct cifs_sb_info *cifs_sb, int xid)
353 {
354 #ifdef CONFIG_CIFS_XATTR
355 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,
361 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
362 if (rc < 0)
363 return (int)rc;
364 else if (rc > 3) {
365 mode = le32_to_cpu(*((__le32 *)ea_value));
366 inode->i_mode &= ~SFBITS_MASK;
367 cFYI(1, ("special bits 0%o org mode 0%o", mode, inode->i_mode));
368 inode->i_mode = (mode & SFBITS_MASK) | inode->i_mode;
369 cFYI(1, ("special mode bits 0%o", mode));
370 return 0;
371 } else {
372 return 0;
373 }
374 #else
375 return -EOPNOTSUPP;
376 #endif
377 }
378
379 /*
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 */
384 static void fill_fake_finddata(FILE_ALL_INFO *pfnd_dat,
385 struct super_block *sb)
386 {
387 memset(pfnd_dat, 0, sizeof(FILE_ALL_INFO));
388
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
408 int cifs_get_inode_info(struct inode **pinode,
409 const unsigned char *full_path, FILE_ALL_INFO *pfindData,
410 struct super_block *sb, int xid, const __u16 *pfid)
411 {
412 int rc = 0;
413 __u32 attr;
414 struct cifsInodeInfo *cifsInfo;
415 struct cifsTconInfo *pTcon;
416 struct inode *inode;
417 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
418 char *buf = NULL;
419 bool adjustTZ = false;
420 bool is_dfs_referral = false;
421 umode_t default_mode;
422
423 pTcon = cifs_sb->tcon;
424 cFYI(1, ("Getting info on %s", full_path));
425
426 if ((pfindData == NULL) && (*pinode != NULL)) {
427 if (CIFS_I(*pinode)->clientCanCacheRead) {
428 cFYI(1, ("No need to revalidate cached inode sizes"));
429 return rc;
430 }
431 }
432
433 /* if file info not passed in then get it from server */
434 if (pfindData == NULL) {
435 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
436 if (buf == NULL)
437 return -ENOMEM;
438 pfindData = (FILE_ALL_INFO *)buf;
439
440 /* could do find first instead but this returns more info */
441 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
442 0 /* not legacy */,
443 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
444 CIFS_MOUNT_MAP_SPECIAL_CHR);
445 /* 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 */
448 if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
449 rc = SMBQueryInformation(xid, pTcon, full_path,
450 pfindData, cifs_sb->local_nls,
451 cifs_sb->mnt_cifs_flags &
452 CIFS_MOUNT_MAP_SPECIAL_CHR);
453 adjustTZ = true;
454 }
455 }
456 /* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
457 if (rc == -EREMOTE) {
458 is_dfs_referral = true;
459 fill_fake_finddata(pfindData, sb);
460 rc = 0;
461 } else if (rc)
462 goto cgii_exit;
463
464 attr = le32_to_cpu(pfindData->Attributes);
465
466 /* get new inode */
467 if (*pinode == NULL) {
468 *pinode = new_inode(sb);
469 if (*pinode == NULL) {
470 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? */
477
478 /* 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 */
482
483 /* 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? */
486
487 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
488 int rc1 = 0;
489 __u64 inode_num;
490
491 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
492 full_path, &inode_num,
493 cifs_sb->local_nls,
494 cifs_sb->mnt_cifs_flags &
495 CIFS_MOUNT_MAP_SPECIAL_CHR);
496 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);
505 }
506 inode = *pinode;
507 cifsInfo = CIFS_I(inode);
508 cifsInfo->cifsAttrs = attr;
509 cFYI(1, ("Old time %ld", cifsInfo->time));
510 cifsInfo->time = jiffies;
511 cFYI(1, ("New time %ld", cifsInfo->time));
512
513 /* blksize needs to be multiple of two. So safer to default to
514 blksize and blkbits set in superblock so 2**blkbits and blksize
515 will match rather than setting to:
516 (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
517
518 /* Linux can not store file creation time so ignore it */
519 if (pfindData->LastAccessTime)
520 inode->i_atime = cifs_NTtimeToUnix
521 (le64_to_cpu(pfindData->LastAccessTime));
522 else /* do not need to use current_fs_time - time not stored */
523 inode->i_atime = CURRENT_TIME;
524 inode->i_mtime =
525 cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
526 inode->i_ctime =
527 cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
528 cFYI(DBG2, ("Attributes came in as 0x%x", attr));
529 if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
530 inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
531 inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
532 }
533
534 /* get default inode mode */
535 if (attr & ATTR_DIRECTORY)
536 default_mode = cifs_sb->mnt_dir_mode;
537 else
538 default_mode = cifs_sb->mnt_file_mode;
539
540 /* set permission bits */
541 if (atomic_read(&cifsInfo->inUse) == 0 ||
542 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
543 inode->i_mode = default_mode;
544 else {
545 /* just reenable write bits if !ATTR_READONLY */
546 if ((inode->i_mode & S_IWUGO) == 0 &&
547 (attr & ATTR_READONLY) == 0)
548 inode->i_mode |= (S_IWUGO & default_mode);
549 inode->i_mode &= ~S_IFMT;
550 }
551 /* clear write bits if ATTR_READONLY is set */
552 if (attr & ATTR_READONLY)
553 inode->i_mode &= ~S_IWUGO;
554
555 /* set inode type */
556 if ((attr & ATTR_SYSTEM) &&
557 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)) {
558 /* no need to fix endianness on 0 */
559 if (pfindData->EndOfFile == 0)
560 inode->i_mode |= S_IFIFO;
561 else if (decode_sfu_inode(inode,
562 le64_to_cpu(pfindData->EndOfFile),
563 full_path, cifs_sb, xid))
564 cFYI(1, ("unknown SFU file type\n"));
565 } else {
566 if (attr & ATTR_DIRECTORY)
567 inode->i_mode |= S_IFDIR;
568 else
569 inode->i_mode |= S_IFREG;
570 }
571
572 spin_lock(&inode->i_lock);
573 if (is_size_safe_to_change(cifsInfo,
574 le64_to_cpu(pfindData->EndOfFile))) {
575 /* can not safely shrink the file size here if the
576 client is writing to it due to potential races */
577 i_size_write(inode, le64_to_cpu(pfindData->EndOfFile));
578
579 /* 512 bytes (2**9) is the fake blocksize that must be
580 used for this calculation */
581 inode->i_blocks = (512 - 1 + le64_to_cpu(
582 pfindData->AllocationSize)) >> 9;
583 }
584 spin_unlock(&inode->i_lock);
585
586 inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
587
588 /* BB fill in uid and gid here? with help from winbind?
589 or retrieve from NTFS stream extended attribute */
590 #ifdef CONFIG_CIFS_EXPERIMENTAL
591 /* fill in 0777 bits from ACL */
592 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
593 cFYI(1, ("Getting mode bits from ACL"));
594 acl_to_uid_mode(inode, full_path, pfid);
595 }
596 #endif
597 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
598 /* fill in remaining high mode bits e.g. SUID, VTX */
599 get_sfu_mode(inode, full_path, cifs_sb, xid);
600 } else if (atomic_read(&cifsInfo->inUse) == 0) {
601 inode->i_uid = cifs_sb->mnt_uid;
602 inode->i_gid = cifs_sb->mnt_gid;
603 /* set so we do not keep refreshing these fields with
604 bad data after user has changed them in memory */
605 atomic_set(&cifsInfo->inUse, 1);
606 }
607
608 cifs_set_ops(inode, is_dfs_referral);
609
610
611
612
613 cgii_exit:
614 kfree(buf);
615 return rc;
616 }
617
618 static const struct inode_operations cifs_ipc_inode_ops = {
619 .lookup = cifs_lookup,
620 };
621
622 /* gets root inode */
623 struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
624 {
625 int xid;
626 struct cifs_sb_info *cifs_sb;
627 struct inode *inode;
628 long rc;
629
630 inode = iget_locked(sb, ino);
631 if (!inode)
632 return ERR_PTR(-ENOMEM);
633 if (!(inode->i_state & I_NEW))
634 return inode;
635
636 cifs_sb = CIFS_SB(inode->i_sb);
637 xid = GetXid();
638
639 if (cifs_sb->tcon->unix_ext)
640 rc = cifs_get_inode_info_unix(&inode, "", inode->i_sb, xid);
641 else
642 rc = cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid,
643 NULL);
644 if (rc && cifs_sb->tcon->ipc) {
645 cFYI(1, ("ipc connection - fake read inode"));
646 inode->i_mode |= S_IFDIR;
647 inode->i_nlink = 2;
648 inode->i_op = &cifs_ipc_inode_ops;
649 inode->i_fop = &simple_dir_operations;
650 inode->i_uid = cifs_sb->mnt_uid;
651 inode->i_gid = cifs_sb->mnt_gid;
652 _FreeXid(xid);
653 iget_failed(inode);
654 return ERR_PTR(rc);
655 }
656
657 unlock_new_inode(inode);
658
659 /* can not call macro FreeXid here since in a void func
660 * TODO: This is no longer true
661 */
662 _FreeXid(xid);
663 return inode;
664 }
665
666 int cifs_unlink(struct inode *inode, struct dentry *direntry)
667 {
668 int rc = 0;
669 int xid;
670 struct cifs_sb_info *cifs_sb;
671 struct cifsTconInfo *pTcon;
672 char *full_path = NULL;
673 struct cifsInodeInfo *cifsInode;
674 FILE_BASIC_INFO *pinfo_buf;
675
676 cFYI(1, ("cifs_unlink, inode = 0x%p", inode));
677
678 xid = GetXid();
679
680 if (inode)
681 cifs_sb = CIFS_SB(inode->i_sb);
682 else
683 cifs_sb = CIFS_SB(direntry->d_sb);
684 pTcon = cifs_sb->tcon;
685
686 /* Unlink can be called from rename so we can not grab the sem here
687 since we deadlock otherwise */
688 /* mutex_lock(&direntry->d_sb->s_vfs_rename_mutex);*/
689 full_path = build_path_from_dentry(direntry);
690 /* mutex_unlock(&direntry->d_sb->s_vfs_rename_mutex);*/
691 if (full_path == NULL) {
692 FreeXid(xid);
693 return -ENOMEM;
694 }
695
696 if ((pTcon->ses->capabilities & CAP_UNIX) &&
697 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
698 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
699 rc = CIFSPOSIXDelFile(xid, pTcon, full_path,
700 SMB_POSIX_UNLINK_FILE_TARGET, cifs_sb->local_nls,
701 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
702 cFYI(1, ("posix del rc %d", rc));
703 if ((rc == 0) || (rc == -ENOENT))
704 goto psx_del_no_retry;
705 }
706
707 rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls,
708 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
709 psx_del_no_retry:
710 if (!rc) {
711 if (direntry->d_inode)
712 drop_nlink(direntry->d_inode);
713 } else if (rc == -ENOENT) {
714 d_drop(direntry);
715 } else if (rc == -ETXTBSY) {
716 int oplock = 0;
717 __u16 netfid;
718
719 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
720 CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
721 &netfid, &oplock, NULL, cifs_sb->local_nls,
722 cifs_sb->mnt_cifs_flags &
723 CIFS_MOUNT_MAP_SPECIAL_CHR);
724 if (rc == 0) {
725 CIFSSMBRenameOpenFile(xid, pTcon, netfid, NULL,
726 cifs_sb->local_nls,
727 cifs_sb->mnt_cifs_flags &
728 CIFS_MOUNT_MAP_SPECIAL_CHR);
729 CIFSSMBClose(xid, pTcon, netfid);
730 if (direntry->d_inode)
731 drop_nlink(direntry->d_inode);
732 }
733 } else if (rc == -EACCES) {
734 /* try only if r/o attribute set in local lookup data? */
735 pinfo_buf = kzalloc(sizeof(FILE_BASIC_INFO), GFP_KERNEL);
736 if (pinfo_buf) {
737 /* ATTRS set to normal clears r/o bit */
738 pinfo_buf->Attributes = cpu_to_le32(ATTR_NORMAL);
739 if (!(pTcon->ses->flags & CIFS_SES_NT4))
740 rc = CIFSSMBSetTimes(xid, pTcon, full_path,
741 pinfo_buf,
742 cifs_sb->local_nls,
743 cifs_sb->mnt_cifs_flags &
744 CIFS_MOUNT_MAP_SPECIAL_CHR);
745 else
746 rc = -EOPNOTSUPP;
747
748 if (rc == -EOPNOTSUPP) {
749 int oplock = 0;
750 __u16 netfid;
751 /* rc = CIFSSMBSetAttrLegacy(xid, pTcon,
752 full_path,
753 (__u16)ATTR_NORMAL,
754 cifs_sb->local_nls);
755 For some strange reason it seems that NT4 eats the
756 old setattr call without actually setting the
757 attributes so on to the third attempted workaround
758 */
759
760 /* BB could scan to see if we already have it open
761 and pass in pid of opener to function */
762 rc = CIFSSMBOpen(xid, pTcon, full_path,
763 FILE_OPEN, SYNCHRONIZE |
764 FILE_WRITE_ATTRIBUTES, 0,
765 &netfid, &oplock, NULL,
766 cifs_sb->local_nls,
767 cifs_sb->mnt_cifs_flags &
768 CIFS_MOUNT_MAP_SPECIAL_CHR);
769 if (rc == 0) {
770 rc = CIFSSMBSetFileTimes(xid, pTcon,
771 pinfo_buf,
772 netfid);
773 CIFSSMBClose(xid, pTcon, netfid);
774 }
775 }
776 kfree(pinfo_buf);
777 }
778 if (rc == 0) {
779 rc = CIFSSMBDelFile(xid, pTcon, full_path,
780 cifs_sb->local_nls,
781 cifs_sb->mnt_cifs_flags &
782 CIFS_MOUNT_MAP_SPECIAL_CHR);
783 if (!rc) {
784 if (direntry->d_inode)
785 drop_nlink(direntry->d_inode);
786 } else if (rc == -ETXTBSY) {
787 int oplock = 0;
788 __u16 netfid;
789
790 rc = CIFSSMBOpen(xid, pTcon, full_path,
791 FILE_OPEN, DELETE,
792 CREATE_NOT_DIR |
793 CREATE_DELETE_ON_CLOSE,
794 &netfid, &oplock, NULL,
795 cifs_sb->local_nls,
796 cifs_sb->mnt_cifs_flags &
797 CIFS_MOUNT_MAP_SPECIAL_CHR);
798 if (rc == 0) {
799 CIFSSMBRenameOpenFile(xid, pTcon,
800 netfid, NULL,
801 cifs_sb->local_nls,
802 cifs_sb->mnt_cifs_flags &
803 CIFS_MOUNT_MAP_SPECIAL_CHR);
804 CIFSSMBClose(xid, pTcon, netfid);
805 if (direntry->d_inode)
806 drop_nlink(direntry->d_inode);
807 }
808 /* BB if rc = -ETXTBUSY goto the rename logic BB */
809 }
810 }
811 }
812 if (direntry->d_inode) {
813 cifsInode = CIFS_I(direntry->d_inode);
814 cifsInode->time = 0; /* will force revalidate to get info
815 when needed */
816 direntry->d_inode->i_ctime = current_fs_time(inode->i_sb);
817 }
818 if (inode) {
819 inode->i_ctime = inode->i_mtime = current_fs_time(inode->i_sb);
820 cifsInode = CIFS_I(inode);
821 cifsInode->time = 0; /* force revalidate of dir as well */
822 }
823
824 kfree(full_path);
825 FreeXid(xid);
826 return rc;
827 }
828
829 static void posix_fill_in_inode(struct inode *tmp_inode,
830 FILE_UNIX_BASIC_INFO *pData, int isNewInode)
831 {
832 struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
833 loff_t local_size;
834 struct timespec local_mtime;
835
836 cifsInfo->time = jiffies;
837 atomic_inc(&cifsInfo->inUse);
838
839 /* save mtime and size */
840 local_mtime = tmp_inode->i_mtime;
841 local_size = tmp_inode->i_size;
842
843 cifs_unix_info_to_inode(tmp_inode, pData, 1);
844 cifs_set_ops(tmp_inode, false);
845
846 if (!S_ISREG(tmp_inode->i_mode))
847 return;
848
849 /*
850 * No sense invalidating pages for new inode
851 * since we we have not started caching
852 * readahead file data yet.
853 */
854 if (isNewInode)
855 return;
856
857 if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
858 (local_size == tmp_inode->i_size)) {
859 cFYI(1, ("inode exists but unchanged"));
860 } else {
861 /* file may have changed on server */
862 cFYI(1, ("invalidate inode, readdir detected change"));
863 invalidate_remote_inode(tmp_inode);
864 }
865 }
866
867 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
868 {
869 int rc = 0;
870 int xid;
871 struct cifs_sb_info *cifs_sb;
872 struct cifsTconInfo *pTcon;
873 char *full_path = NULL;
874 struct inode *newinode = NULL;
875
876 cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p", mode, inode));
877
878 xid = GetXid();
879
880 cifs_sb = CIFS_SB(inode->i_sb);
881 pTcon = cifs_sb->tcon;
882
883 full_path = build_path_from_dentry(direntry);
884 if (full_path == NULL) {
885 FreeXid(xid);
886 return -ENOMEM;
887 }
888
889 if ((pTcon->ses->capabilities & CAP_UNIX) &&
890 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
891 le64_to_cpu(pTcon->fsUnixInfo.Capability))) {
892 u32 oplock = 0;
893 FILE_UNIX_BASIC_INFO *pInfo =
894 kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
895 if (pInfo == NULL) {
896 rc = -ENOMEM;
897 goto mkdir_out;
898 }
899
900 mode &= ~current->fs->umask;
901 rc = CIFSPOSIXCreate(xid, pTcon, SMB_O_DIRECTORY | SMB_O_CREAT,
902 mode, NULL /* netfid */, pInfo, &oplock,
903 full_path, cifs_sb->local_nls,
904 cifs_sb->mnt_cifs_flags &
905 CIFS_MOUNT_MAP_SPECIAL_CHR);
906 if (rc == -EOPNOTSUPP) {
907 kfree(pInfo);
908 goto mkdir_retry_old;
909 } else if (rc) {
910 cFYI(1, ("posix mkdir returned 0x%x", rc));
911 d_drop(direntry);
912 } else {
913 if (pInfo->Type == cpu_to_le32(-1)) {
914 /* no return info, go query for it */
915 kfree(pInfo);
916 goto mkdir_get_info;
917 }
918 /*BB check (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID ) to see if need
919 to set uid/gid */
920 inc_nlink(inode);
921 if (pTcon->nocase)
922 direntry->d_op = &cifs_ci_dentry_ops;
923 else
924 direntry->d_op = &cifs_dentry_ops;
925
926 newinode = new_inode(inode->i_sb);
927 if (newinode == NULL) {
928 kfree(pInfo);
929 goto mkdir_get_info;
930 }
931 /* Is an i_ino of zero legal? */
932 /* Are there sanity checks we can use to ensure that
933 the server is really filling in that field? */
934 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
935 newinode->i_ino =
936 (unsigned long)pInfo->UniqueId;
937 } /* note ino incremented to unique num in new_inode */
938 if (inode->i_sb->s_flags & MS_NOATIME)
939 newinode->i_flags |= S_NOATIME | S_NOCMTIME;
940 newinode->i_nlink = 2;
941
942 insert_inode_hash(newinode);
943 d_instantiate(direntry, newinode);
944
945 /* we already checked in POSIXCreate whether
946 frame was long enough */
947 posix_fill_in_inode(direntry->d_inode,
948 pInfo, 1 /* NewInode */);
949 #ifdef CONFIG_CIFS_DEBUG2
950 cFYI(1, ("instantiated dentry %p %s to inode %p",
951 direntry, direntry->d_name.name, newinode));
952
953 if (newinode->i_nlink != 2)
954 cFYI(1, ("unexpected number of links %d",
955 newinode->i_nlink));
956 #endif
957 }
958 kfree(pInfo);
959 goto mkdir_out;
960 }
961 mkdir_retry_old:
962 /* BB add setting the equivalent of mode via CreateX w/ACLs */
963 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
964 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
965 if (rc) {
966 cFYI(1, ("cifs_mkdir returned 0x%x", rc));
967 d_drop(direntry);
968 } else {
969 mkdir_get_info:
970 inc_nlink(inode);
971 if (pTcon->unix_ext)
972 rc = cifs_get_inode_info_unix(&newinode, full_path,
973 inode->i_sb, xid);
974 else
975 rc = cifs_get_inode_info(&newinode, full_path, NULL,
976 inode->i_sb, xid, NULL);
977
978 if (pTcon->nocase)
979 direntry->d_op = &cifs_ci_dentry_ops;
980 else
981 direntry->d_op = &cifs_dentry_ops;
982 d_instantiate(direntry, newinode);
983 /* setting nlink not necessary except in cases where we
984 * failed to get it from the server or was set bogus */
985 if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
986 direntry->d_inode->i_nlink = 2;
987 mode &= ~current->fs->umask;
988 if (pTcon->unix_ext) {
989 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
990 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
991 mode,
992 (__u64)current->fsuid,
993 (__u64)current->fsgid,
994 0 /* dev_t */,
995 cifs_sb->local_nls,
996 cifs_sb->mnt_cifs_flags &
997 CIFS_MOUNT_MAP_SPECIAL_CHR);
998 } else {
999 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
1000 mode, (__u64)-1,
1001 (__u64)-1, 0 /* dev_t */,
1002 cifs_sb->local_nls,
1003 cifs_sb->mnt_cifs_flags &
1004 CIFS_MOUNT_MAP_SPECIAL_CHR);
1005 }
1006 } else {
1007 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
1008 (mode & S_IWUGO) == 0) {
1009 FILE_BASIC_INFO pInfo;
1010 memset(&pInfo, 0, sizeof(pInfo));
1011 pInfo.Attributes = cpu_to_le32(ATTR_READONLY);
1012 CIFSSMBSetTimes(xid, pTcon, full_path,
1013 &pInfo, cifs_sb->local_nls,
1014 cifs_sb->mnt_cifs_flags &
1015 CIFS_MOUNT_MAP_SPECIAL_CHR);
1016 }
1017 if (direntry->d_inode) {
1018 if (cifs_sb->mnt_cifs_flags &
1019 CIFS_MOUNT_DYNPERM)
1020 direntry->d_inode->i_mode =
1021 (mode | S_IFDIR);
1022
1023 if (cifs_sb->mnt_cifs_flags &
1024 CIFS_MOUNT_SET_UID) {
1025 direntry->d_inode->i_uid =
1026 current->fsuid;
1027 direntry->d_inode->i_gid =
1028 current->fsgid;
1029 }
1030 }
1031 }
1032 }
1033 mkdir_out:
1034 kfree(full_path);
1035 FreeXid(xid);
1036 return rc;
1037 }
1038
1039 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
1040 {
1041 int rc = 0;
1042 int xid;
1043 struct cifs_sb_info *cifs_sb;
1044 struct cifsTconInfo *pTcon;
1045 char *full_path = NULL;
1046 struct cifsInodeInfo *cifsInode;
1047
1048 cFYI(1, ("cifs_rmdir, inode = 0x%p", inode));
1049
1050 xid = GetXid();
1051
1052 cifs_sb = CIFS_SB(inode->i_sb);
1053 pTcon = cifs_sb->tcon;
1054
1055 full_path = build_path_from_dentry(direntry);
1056 if (full_path == NULL) {
1057 FreeXid(xid);
1058 return -ENOMEM;
1059 }
1060
1061 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
1062 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1063
1064 if (!rc) {
1065 drop_nlink(inode);
1066 spin_lock(&direntry->d_inode->i_lock);
1067 i_size_write(direntry->d_inode, 0);
1068 clear_nlink(direntry->d_inode);
1069 spin_unlock(&direntry->d_inode->i_lock);
1070 }
1071
1072 cifsInode = CIFS_I(direntry->d_inode);
1073 cifsInode->time = 0; /* force revalidate to go get info when
1074 needed */
1075 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
1076 current_fs_time(inode->i_sb);
1077
1078 kfree(full_path);
1079 FreeXid(xid);
1080 return rc;
1081 }
1082
1083 int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
1084 struct inode *target_inode, struct dentry *target_direntry)
1085 {
1086 char *fromName;
1087 char *toName;
1088 struct cifs_sb_info *cifs_sb_source;
1089 struct cifs_sb_info *cifs_sb_target;
1090 struct cifsTconInfo *pTcon;
1091 int xid;
1092 int rc = 0;
1093
1094 xid = GetXid();
1095
1096 cifs_sb_target = CIFS_SB(target_inode->i_sb);
1097 cifs_sb_source = CIFS_SB(source_inode->i_sb);
1098 pTcon = cifs_sb_source->tcon;
1099
1100 if (pTcon != cifs_sb_target->tcon) {
1101 FreeXid(xid);
1102 return -EXDEV; /* BB actually could be allowed if same server,
1103 but different share.
1104 Might eventually add support for this */
1105 }
1106
1107 /* we already have the rename sem so we do not need to grab it again
1108 here to protect the path integrity */
1109 fromName = build_path_from_dentry(source_direntry);
1110 toName = build_path_from_dentry(target_direntry);
1111 if ((fromName == NULL) || (toName == NULL)) {
1112 rc = -ENOMEM;
1113 goto cifs_rename_exit;
1114 }
1115
1116 rc = CIFSSMBRename(xid, pTcon, fromName, toName,
1117 cifs_sb_source->local_nls,
1118 cifs_sb_source->mnt_cifs_flags &
1119 CIFS_MOUNT_MAP_SPECIAL_CHR);
1120 if (rc == -EEXIST) {
1121 /* check if they are the same file because rename of hardlinked
1122 files is a noop */
1123 FILE_UNIX_BASIC_INFO *info_buf_source;
1124 FILE_UNIX_BASIC_INFO *info_buf_target;
1125
1126 info_buf_source =
1127 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
1128 if (info_buf_source != NULL) {
1129 info_buf_target = info_buf_source + 1;
1130 if (pTcon->unix_ext)
1131 rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,
1132 info_buf_source,
1133 cifs_sb_source->local_nls,
1134 cifs_sb_source->mnt_cifs_flags &
1135 CIFS_MOUNT_MAP_SPECIAL_CHR);
1136 /* else rc is still EEXIST so will fall through to
1137 unlink the target and retry rename */
1138 if (rc == 0) {
1139 rc = CIFSSMBUnixQPathInfo(xid, pTcon, toName,
1140 info_buf_target,
1141 cifs_sb_target->local_nls,
1142 /* remap based on source sb */
1143 cifs_sb_source->mnt_cifs_flags &
1144 CIFS_MOUNT_MAP_SPECIAL_CHR);
1145 }
1146 if ((rc == 0) &&
1147 (info_buf_source->UniqueId ==
1148 info_buf_target->UniqueId)) {
1149 /* do not rename since the files are hardlinked which
1150 is a noop */
1151 } else {
1152 /* we either can not tell the files are hardlinked
1153 (as with Windows servers) or files are not
1154 hardlinked so delete the target manually before
1155 renaming to follow POSIX rather than Windows
1156 semantics */
1157 cifs_unlink(target_inode, target_direntry);
1158 rc = CIFSSMBRename(xid, pTcon, fromName,
1159 toName,
1160 cifs_sb_source->local_nls,
1161 cifs_sb_source->mnt_cifs_flags
1162 & CIFS_MOUNT_MAP_SPECIAL_CHR);
1163 }
1164 kfree(info_buf_source);
1165 } /* if we can not get memory just leave rc as EEXIST */
1166 }
1167
1168 if (rc)
1169 cFYI(1, ("rename rc %d", rc));
1170
1171 if ((rc == -EIO) || (rc == -EEXIST)) {
1172 int oplock = 0;
1173 __u16 netfid;
1174
1175 /* BB FIXME Is Generic Read correct for rename? */
1176 /* if renaming directory - we should not say CREATE_NOT_DIR,
1177 need to test renaming open directory, also GENERIC_READ
1178 might not right be right access to request */
1179 rc = CIFSSMBOpen(xid, pTcon, fromName, FILE_OPEN, GENERIC_READ,
1180 CREATE_NOT_DIR, &netfid, &oplock, NULL,
1181 cifs_sb_source->local_nls,
1182 cifs_sb_source->mnt_cifs_flags &
1183 CIFS_MOUNT_MAP_SPECIAL_CHR);
1184 if (rc == 0) {
1185 rc = CIFSSMBRenameOpenFile(xid, pTcon, netfid, toName,
1186 cifs_sb_source->local_nls,
1187 cifs_sb_source->mnt_cifs_flags &
1188 CIFS_MOUNT_MAP_SPECIAL_CHR);
1189 CIFSSMBClose(xid, pTcon, netfid);
1190 }
1191 }
1192
1193 cifs_rename_exit:
1194 kfree(fromName);
1195 kfree(toName);
1196 FreeXid(xid);
1197 return rc;
1198 }
1199
1200 int cifs_revalidate(struct dentry *direntry)
1201 {
1202 int xid;
1203 int rc = 0, wbrc = 0;
1204 char *full_path;
1205 struct cifs_sb_info *cifs_sb;
1206 struct cifsInodeInfo *cifsInode;
1207 loff_t local_size;
1208 struct timespec local_mtime;
1209 bool invalidate_inode = false;
1210
1211 if (direntry->d_inode == NULL)
1212 return -ENOENT;
1213
1214 cifsInode = CIFS_I(direntry->d_inode);
1215
1216 if (cifsInode == NULL)
1217 return -ENOENT;
1218
1219 /* no sense revalidating inode info on file that no one can write */
1220 if (CIFS_I(direntry->d_inode)->clientCanCacheRead)
1221 return rc;
1222
1223 xid = GetXid();
1224
1225 cifs_sb = CIFS_SB(direntry->d_sb);
1226
1227 /* can not safely grab the rename sem here if rename calls revalidate
1228 since that would deadlock */
1229 full_path = build_path_from_dentry(direntry);
1230 if (full_path == NULL) {
1231 FreeXid(xid);
1232 return -ENOMEM;
1233 }
1234 cFYI(1, ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
1235 "jiffies %ld", full_path, direntry->d_inode,
1236 direntry->d_inode->i_count.counter, direntry,
1237 direntry->d_time, jiffies));
1238
1239 if (cifsInode->time == 0) {
1240 /* was set to zero previously to force revalidate */
1241 } else if (time_before(jiffies, cifsInode->time + HZ) &&
1242 lookupCacheEnabled) {
1243 if ((S_ISREG(direntry->d_inode->i_mode) == 0) ||
1244 (direntry->d_inode->i_nlink == 1)) {
1245 kfree(full_path);
1246 FreeXid(xid);
1247 return rc;
1248 } else {
1249 cFYI(1, ("Have to revalidate file due to hardlinks"));
1250 }
1251 }
1252
1253 /* save mtime and size */
1254 local_mtime = direntry->d_inode->i_mtime;
1255 local_size = direntry->d_inode->i_size;
1256
1257 if (cifs_sb->tcon->unix_ext) {
1258 rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
1259 direntry->d_sb, xid);
1260 if (rc) {
1261 cFYI(1, ("error on getting revalidate info %d", rc));
1262 /* if (rc != -ENOENT)
1263 rc = 0; */ /* BB should we cache info on
1264 certain errors? */
1265 }
1266 } else {
1267 rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
1268 direntry->d_sb, xid, NULL);
1269 if (rc) {
1270 cFYI(1, ("error on getting revalidate info %d", rc));
1271 /* if (rc != -ENOENT)
1272 rc = 0; */ /* BB should we cache info on
1273 certain errors? */
1274 }
1275 }
1276 /* should we remap certain errors, access denied?, to zero */
1277
1278 /* if not oplocked, we invalidate inode pages if mtime or file size
1279 had changed on server */
1280
1281 if (timespec_equal(&local_mtime, &direntry->d_inode->i_mtime) &&
1282 (local_size == direntry->d_inode->i_size)) {
1283 cFYI(1, ("cifs_revalidate - inode unchanged"));
1284 } else {
1285 /* file may have changed on server */
1286 if (cifsInode->clientCanCacheRead) {
1287 /* no need to invalidate inode pages since we were the
1288 only ones who could have modified the file and the
1289 server copy is staler than ours */
1290 } else {
1291 invalidate_inode = true;
1292 }
1293 }
1294
1295 /* can not grab this sem since kernel filesys locking documentation
1296 indicates i_mutex may be taken by the kernel on lookup and rename
1297 which could deadlock if we grab the i_mutex here as well */
1298 /* mutex_lock(&direntry->d_inode->i_mutex);*/
1299 /* need to write out dirty pages here */
1300 if (direntry->d_inode->i_mapping) {
1301 /* do we need to lock inode until after invalidate completes
1302 below? */
1303 wbrc = filemap_fdatawrite(direntry->d_inode->i_mapping);
1304 if (wbrc)
1305 CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
1306 }
1307 if (invalidate_inode) {
1308 /* shrink_dcache not necessary now that cifs dentry ops
1309 are exported for negative dentries */
1310 /* if (S_ISDIR(direntry->d_inode->i_mode))
1311 shrink_dcache_parent(direntry); */
1312 if (S_ISREG(direntry->d_inode->i_mode)) {
1313 if (direntry->d_inode->i_mapping)
1314 wbrc = filemap_fdatawait(direntry->d_inode->i_mapping);
1315 if (wbrc)
1316 CIFS_I(direntry->d_inode)->write_behind_rc = wbrc;
1317 /* may eventually have to do this for open files too */
1318 if (list_empty(&(cifsInode->openFileList))) {
1319 /* changed on server - flush read ahead pages */
1320 cFYI(1, ("Invalidating read ahead data on "
1321 "closed file"));
1322 invalidate_remote_inode(direntry->d_inode);
1323 }
1324 }
1325 }
1326 /* mutex_unlock(&direntry->d_inode->i_mutex); */
1327
1328 kfree(full_path);
1329 FreeXid(xid);
1330 return rc;
1331 }
1332
1333 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
1334 struct kstat *stat)
1335 {
1336 int err = cifs_revalidate(dentry);
1337 if (!err) {
1338 generic_fillattr(dentry->d_inode, stat);
1339 stat->blksize = CIFS_MAX_MSGSIZE;
1340 }
1341 return err;
1342 }
1343
1344 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
1345 {
1346 pgoff_t index = from >> PAGE_CACHE_SHIFT;
1347 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
1348 struct page *page;
1349 int rc = 0;
1350
1351 page = grab_cache_page(mapping, index);
1352 if (!page)
1353 return -ENOMEM;
1354
1355 zero_user_segment(page, offset, PAGE_CACHE_SIZE);
1356 unlock_page(page);
1357 page_cache_release(page);
1358 return rc;
1359 }
1360
1361 static int cifs_vmtruncate(struct inode *inode, loff_t offset)
1362 {
1363 struct address_space *mapping = inode->i_mapping;
1364 unsigned long limit;
1365
1366 spin_lock(&inode->i_lock);
1367 if (inode->i_size < offset)
1368 goto do_expand;
1369 /*
1370 * truncation of in-use swapfiles is disallowed - it would cause
1371 * subsequent swapout to scribble on the now-freed blocks.
1372 */
1373 if (IS_SWAPFILE(inode)) {
1374 spin_unlock(&inode->i_lock);
1375 goto out_busy;
1376 }
1377 i_size_write(inode, offset);
1378 spin_unlock(&inode->i_lock);
1379 /*
1380 * unmap_mapping_range is called twice, first simply for efficiency
1381 * so that truncate_inode_pages does fewer single-page unmaps. However
1382 * after this first call, and before truncate_inode_pages finishes,
1383 * it is possible for private pages to be COWed, which remain after
1384 * truncate_inode_pages finishes, hence the second unmap_mapping_range
1385 * call must be made for correctness.
1386 */
1387 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1388 truncate_inode_pages(mapping, offset);
1389 unmap_mapping_range(mapping, offset + PAGE_SIZE - 1, 0, 1);
1390 goto out_truncate;
1391
1392 do_expand:
1393 limit = current->signal->rlim[RLIMIT_FSIZE].rlim_cur;
1394 if (limit != RLIM_INFINITY && offset > limit) {
1395 spin_unlock(&inode->i_lock);
1396 goto out_sig;
1397 }
1398 if (offset > inode->i_sb->s_maxbytes) {
1399 spin_unlock(&inode->i_lock);
1400 goto out_big;
1401 }
1402 i_size_write(inode, offset);
1403 spin_unlock(&inode->i_lock);
1404 out_truncate:
1405 if (inode->i_op && inode->i_op->truncate)
1406 inode->i_op->truncate(inode);
1407 return 0;
1408 out_sig:
1409 send_sig(SIGXFSZ, current, 0);
1410 out_big:
1411 return -EFBIG;
1412 out_busy:
1413 return -ETXTBSY;
1414 }
1415
1416 int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
1417 {
1418 int xid;
1419 struct cifs_sb_info *cifs_sb;
1420 struct cifsTconInfo *pTcon;
1421 char *full_path = NULL;
1422 int rc = -EACCES;
1423 struct cifsFileInfo *open_file = NULL;
1424 FILE_BASIC_INFO time_buf;
1425 bool set_time = false;
1426 bool set_dosattr = false;
1427 __u64 mode = 0xFFFFFFFFFFFFFFFFULL;
1428 __u64 uid = 0xFFFFFFFFFFFFFFFFULL;
1429 __u64 gid = 0xFFFFFFFFFFFFFFFFULL;
1430 struct cifsInodeInfo *cifsInode;
1431 struct inode *inode = direntry->d_inode;
1432
1433 xid = GetXid();
1434
1435 cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
1436 direntry->d_name.name, attrs->ia_valid));
1437
1438 cifs_sb = CIFS_SB(inode->i_sb);
1439 pTcon = cifs_sb->tcon;
1440
1441 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
1442 /* check if we have permission to change attrs */
1443 rc = inode_change_ok(inode, attrs);
1444 if (rc < 0) {
1445 FreeXid(xid);
1446 return rc;
1447 } else
1448 rc = 0;
1449 }
1450
1451 full_path = build_path_from_dentry(direntry);
1452 if (full_path == NULL) {
1453 FreeXid(xid);
1454 return -ENOMEM;
1455 }
1456 cifsInode = CIFS_I(inode);
1457
1458 if ((attrs->ia_valid & ATTR_MTIME) || (attrs->ia_valid & ATTR_SIZE)) {
1459 /*
1460 Flush data before changing file size or changing the last
1461 write time of the file on the server. If the
1462 flush returns error, store it to report later and continue.
1463 BB: This should be smarter. Why bother flushing pages that
1464 will be truncated anyway? Also, should we error out here if
1465 the flush returns error?
1466 */
1467 rc = filemap_write_and_wait(inode->i_mapping);
1468 if (rc != 0) {
1469 cifsInode->write_behind_rc = rc;
1470 rc = 0;
1471 }
1472 }
1473
1474 if (attrs->ia_valid & ATTR_SIZE) {
1475 /* To avoid spurious oplock breaks from server, in the case of
1476 inodes that we already have open, avoid doing path based
1477 setting of file size if we can do it by handle.
1478 This keeps our caching token (oplock) and avoids timeouts
1479 when the local oplock break takes longer to flush
1480 writebehind data than the SMB timeout for the SetPathInfo
1481 request would allow */
1482
1483 open_file = find_writable_file(cifsInode);
1484 if (open_file) {
1485 __u16 nfid = open_file->netfid;
1486 __u32 npid = open_file->pid;
1487 rc = CIFSSMBSetFileSize(xid, pTcon, attrs->ia_size,
1488 nfid, npid, false);
1489 atomic_dec(&open_file->wrtPending);
1490 cFYI(1, ("SetFSize for attrs rc = %d", rc));
1491 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1492 unsigned int bytes_written;
1493 rc = CIFSSMBWrite(xid, pTcon,
1494 nfid, 0, attrs->ia_size,
1495 &bytes_written, NULL, NULL,
1496 1 /* 45 seconds */);
1497 cFYI(1, ("Wrt seteof rc %d", rc));
1498 }
1499 } else
1500 rc = -EINVAL;
1501
1502 if (rc != 0) {
1503 /* Set file size by pathname rather than by handle
1504 either because no valid, writeable file handle for
1505 it was found or because there was an error setting
1506 it by handle */
1507 rc = CIFSSMBSetEOF(xid, pTcon, full_path,
1508 attrs->ia_size, false,
1509 cifs_sb->local_nls,
1510 cifs_sb->mnt_cifs_flags &
1511 CIFS_MOUNT_MAP_SPECIAL_CHR);
1512 cFYI(1, ("SetEOF by path (setattrs) rc = %d", rc));
1513 if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1514 __u16 netfid;
1515 int oplock = 0;
1516
1517 rc = SMBLegacyOpen(xid, pTcon, full_path,
1518 FILE_OPEN, GENERIC_WRITE,
1519 CREATE_NOT_DIR, &netfid, &oplock,
1520 NULL, cifs_sb->local_nls,
1521 cifs_sb->mnt_cifs_flags &
1522 CIFS_MOUNT_MAP_SPECIAL_CHR);
1523 if (rc == 0) {
1524 unsigned int bytes_written;
1525 rc = CIFSSMBWrite(xid, pTcon,
1526 netfid, 0,
1527 attrs->ia_size,
1528 &bytes_written, NULL,
1529 NULL, 1 /* 45 sec */);
1530 cFYI(1, ("wrt seteof rc %d", rc));
1531 CIFSSMBClose(xid, pTcon, netfid);
1532 }
1533
1534 }
1535 }
1536
1537 /* Server is ok setting allocation size implicitly - no need
1538 to call:
1539 CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, true,
1540 cifs_sb->local_nls);
1541 */
1542
1543 if (rc == 0) {
1544 rc = cifs_vmtruncate(inode, attrs->ia_size);
1545 cifs_truncate_page(inode->i_mapping, inode->i_size);
1546 } else
1547 goto cifs_setattr_exit;
1548 }
1549
1550 /*
1551 * Without unix extensions we can't send ownership changes to the
1552 * server, so silently ignore them. This is consistent with how
1553 * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
1554 * CIFSACL support + proper Windows to Unix idmapping, we may be
1555 * able to support this in the future.
1556 */
1557 if (!pTcon->unix_ext &&
1558 !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
1559 attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
1560 } else {
1561 if (attrs->ia_valid & ATTR_UID) {
1562 cFYI(1, ("UID changed to %d", attrs->ia_uid));
1563 uid = attrs->ia_uid;
1564 }
1565 if (attrs->ia_valid & ATTR_GID) {
1566 cFYI(1, ("GID changed to %d", attrs->ia_gid));
1567 gid = attrs->ia_gid;
1568 }
1569 }
1570
1571 time_buf.Attributes = 0;
1572
1573 /* skip mode change if it's just for clearing setuid/setgid */
1574 if (attrs->ia_valid & (ATTR_KILL_SUID|ATTR_KILL_SGID))
1575 attrs->ia_valid &= ~ATTR_MODE;
1576
1577 if (attrs->ia_valid & ATTR_MODE) {
1578 cFYI(1, ("Mode changed to 0%o", attrs->ia_mode));
1579 mode = attrs->ia_mode;
1580 }
1581
1582 if ((pTcon->unix_ext)
1583 && (attrs->ia_valid & (ATTR_MODE | ATTR_GID | ATTR_UID)))
1584 rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode, uid, gid,
1585 0 /* dev_t */, cifs_sb->local_nls,
1586 cifs_sb->mnt_cifs_flags &
1587 CIFS_MOUNT_MAP_SPECIAL_CHR);
1588 else if (attrs->ia_valid & ATTR_MODE) {
1589 rc = 0;
1590 #ifdef CONFIG_CIFS_EXPERIMENTAL
1591 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
1592 rc = mode_to_acl(inode, full_path, mode);
1593 else
1594 #endif
1595 if (((mode & S_IWUGO) == 0) &&
1596 (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
1597 set_dosattr = true;
1598 time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs |
1599 ATTR_READONLY);
1600 /* fix up mode if we're not using dynperm */
1601 if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
1602 attrs->ia_mode = inode->i_mode & ~S_IWUGO;
1603 } else if ((mode & S_IWUGO) &&
1604 (cifsInode->cifsAttrs & ATTR_READONLY)) {
1605 /* If file is readonly on server, we would
1606 not be able to write to it - so if any write
1607 bit is enabled for user or group or other we
1608 need to at least try to remove r/o dos attr */
1609 set_dosattr = true;
1610 time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs &
1611 (~ATTR_READONLY));
1612 /* Windows ignores set to zero */
1613 if (time_buf.Attributes == 0)
1614 time_buf.Attributes |= cpu_to_le32(ATTR_NORMAL);
1615
1616 /* reset local inode permissions to normal */
1617 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1618 attrs->ia_mode &= ~(S_IALLUGO);
1619 if (S_ISDIR(inode->i_mode))
1620 attrs->ia_mode |=
1621 cifs_sb->mnt_dir_mode;
1622 else
1623 attrs->ia_mode |=
1624 cifs_sb->mnt_file_mode;
1625 }
1626 } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
1627 /* ignore mode change - ATTR_READONLY hasn't changed */
1628 attrs->ia_valid &= ~ATTR_MODE;
1629 }
1630 }
1631
1632 if (attrs->ia_valid & ATTR_ATIME) {
1633 set_time = true;
1634 time_buf.LastAccessTime =
1635 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1636 } else
1637 time_buf.LastAccessTime = 0;
1638
1639 if (attrs->ia_valid & ATTR_MTIME) {
1640 set_time = true;
1641 time_buf.LastWriteTime =
1642 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1643 } else
1644 time_buf.LastWriteTime = 0;
1645 /* Do not set ctime explicitly unless other time
1646 stamps are changed explicitly (i.e. by utime()
1647 since we would then have a mix of client and
1648 server times */
1649
1650 if (set_time && (attrs->ia_valid & ATTR_CTIME)) {
1651 set_time = true;
1652 /* Although Samba throws this field away
1653 it may be useful to Windows - but we do
1654 not want to set ctime unless some other
1655 timestamp is changing */
1656 cFYI(1, ("CIFS - CTIME changed"));
1657 time_buf.ChangeTime =
1658 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1659 } else
1660 time_buf.ChangeTime = 0;
1661
1662 if (set_time || set_dosattr) {
1663 time_buf.CreationTime = 0; /* do not change */
1664 /* In the future we should experiment - try setting timestamps
1665 via Handle (SetFileInfo) instead of by path */
1666 if (!(pTcon->ses->flags & CIFS_SES_NT4))
1667 rc = CIFSSMBSetTimes(xid, pTcon, full_path, &time_buf,
1668 cifs_sb->local_nls,
1669 cifs_sb->mnt_cifs_flags &
1670 CIFS_MOUNT_MAP_SPECIAL_CHR);
1671 else
1672 rc = -EOPNOTSUPP;
1673
1674 if (rc == -EOPNOTSUPP) {
1675 int oplock = 0;
1676 __u16 netfid;
1677
1678 cFYI(1, ("calling SetFileInfo since SetPathInfo for "
1679 "times not supported by this server"));
1680 /* BB we could scan to see if we already have it open
1681 and pass in pid of opener to function */
1682 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1683 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1684 CREATE_NOT_DIR, &netfid, &oplock,
1685 NULL, cifs_sb->local_nls,
1686 cifs_sb->mnt_cifs_flags &
1687 CIFS_MOUNT_MAP_SPECIAL_CHR);
1688 if (rc == 0) {
1689 rc = CIFSSMBSetFileTimes(xid, pTcon, &time_buf,
1690 netfid);
1691 CIFSSMBClose(xid, pTcon, netfid);
1692 } else {
1693 /* BB For even older servers we could convert time_buf
1694 into old DOS style which uses two second
1695 granularity */
1696
1697 /* rc = CIFSSMBSetTimesLegacy(xid, pTcon, full_path,
1698 &time_buf, cifs_sb->local_nls); */
1699 }
1700 }
1701 /* Even if error on time set, no sense failing the call if
1702 the server would set the time to a reasonable value anyway,
1703 and this check ensures that we are not being called from
1704 sys_utimes in which case we ought to fail the call back to
1705 the user when the server rejects the call */
1706 if ((rc) && (attrs->ia_valid &
1707 (ATTR_MODE | ATTR_GID | ATTR_UID | ATTR_SIZE)))
1708 rc = 0;
1709 }
1710
1711 /* do not need local check to inode_check_ok since the server does
1712 that */
1713 if (!rc)
1714 rc = inode_setattr(inode, attrs);
1715 cifs_setattr_exit:
1716 kfree(full_path);
1717 FreeXid(xid);
1718 return rc;
1719 }
1720
1721 #if 0
1722 void cifs_delete_inode(struct inode *inode)
1723 {
1724 cFYI(1, ("In cifs_delete_inode, inode = 0x%p", inode));
1725 /* may have to add back in if and when safe distributed caching of
1726 directories added e.g. via FindNotify */
1727 }
1728 #endif
kmemtrace - Kernel memory tracer