?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] Avoid console spam with ext3 aborted journal.
[linux-2.6/verdex.git] / fs / cifs / inode.c
blob670947288262c099a0f32ecffd3e4ca110ad9eb4
1 /*
2 * fs/cifs/inode.c
3 *
4 * Copyright (C) International Business Machines Corp., 2002,2005
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/buffer_head.h>
23 #include <linux/stat.h>
24 #include <linux/pagemap.h>
25 #include <asm/div64.h>
26 #include "cifsfs.h"
27 #include "cifspdu.h"
28 #include "cifsglob.h"
29 #include "cifsproto.h"
30 #include "cifs_debug.h"
31 #include "cifs_fs_sb.h"
32
33 int cifs_get_inode_info_unix(struct inode **pinode,
34 const unsigned char *search_path, struct super_block *sb, int xid)
35 {
36 int rc = 0;
37 FILE_UNIX_BASIC_INFO findData;
38 struct cifsTconInfo *pTcon;
39 struct inode *inode;
40 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
41 char *tmp_path;
42
43 pTcon = cifs_sb->tcon;
44 cFYI(1, (" Getting info on %s ", search_path));
45 /* could have done a find first instead but this returns more info */
46 rc = CIFSSMBUnixQPathInfo(xid, pTcon, search_path, &findData,
47 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
48 CIFS_MOUNT_MAP_SPECIAL_CHR);
49 /* dump_mem("\nUnixQPathInfo return data", &findData,
50 sizeof(findData)); */
51 if (rc) {
52 if (rc == -EREMOTE) {
53 tmp_path =
54 kmalloc(strnlen(pTcon->treeName,
55 MAX_TREE_SIZE + 1) +
56 strnlen(search_path, MAX_PATHCONF) + 1,
57 GFP_KERNEL);
58 if (tmp_path == NULL) {
59 return -ENOMEM;
60 }
61 /* have to skip first of the double backslash of
62 UNC name */
63 strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
64 strncat(tmp_path, search_path, MAX_PATHCONF);
65 rc = connect_to_dfs_path(xid, pTcon->ses,
66 /* treename + */ tmp_path,
67 cifs_sb->local_nls,
68 cifs_sb->mnt_cifs_flags &
69 CIFS_MOUNT_MAP_SPECIAL_CHR);
70 kfree(tmp_path);
71
72 /* BB fix up inode etc. */
73 } else if (rc) {
74 return rc;
75 }
76 } else {
77 struct cifsInodeInfo *cifsInfo;
78 __u32 type = le32_to_cpu(findData.Type);
79 __u64 num_of_bytes = le64_to_cpu(findData.NumOfBytes);
80 __u64 end_of_file = le64_to_cpu(findData.EndOfFile);
81
82 /* get new inode */
83 if (*pinode == NULL) {
84 *pinode = new_inode(sb);
85 if(*pinode == NULL)
86 return -ENOMEM;
87 /* Is an i_ino of zero legal? */
88 /* Are there sanity checks we can use to ensure that
89 the server is really filling in that field? */
90 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
91 (*pinode)->i_ino =
92 (unsigned long)findData.UniqueId;
93 } /* note ino incremented to unique num in new_inode */
94 insert_inode_hash(*pinode);
95 }
96
97 inode = *pinode;
98 cifsInfo = CIFS_I(inode);
99
100 cFYI(1, (" Old time %ld ", cifsInfo->time));
101 cifsInfo->time = jiffies;
102 cFYI(1, (" New time %ld ", cifsInfo->time));
103 /* this is ok to set on every inode revalidate */
104 atomic_set(&cifsInfo->inUse,1);
105
106 inode->i_atime =
107 cifs_NTtimeToUnix(le64_to_cpu(findData.LastAccessTime));
108 inode->i_mtime =
109 cifs_NTtimeToUnix(le64_to_cpu
110 (findData.LastModificationTime));
111 inode->i_ctime =
112 cifs_NTtimeToUnix(le64_to_cpu(findData.LastStatusChange));
113 inode->i_mode = le64_to_cpu(findData.Permissions);
114 if (type == UNIX_FILE) {
115 inode->i_mode |= S_IFREG;
116 } else if (type == UNIX_SYMLINK) {
117 inode->i_mode |= S_IFLNK;
118 } else if (type == UNIX_DIR) {
119 inode->i_mode |= S_IFDIR;
120 } else if (type == UNIX_CHARDEV) {
121 inode->i_mode |= S_IFCHR;
122 inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
123 le64_to_cpu(findData.DevMinor) & MINORMASK);
124 } else if (type == UNIX_BLOCKDEV) {
125 inode->i_mode |= S_IFBLK;
126 inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
127 le64_to_cpu(findData.DevMinor) & MINORMASK);
128 } else if (type == UNIX_FIFO) {
129 inode->i_mode |= S_IFIFO;
130 } else if (type == UNIX_SOCKET) {
131 inode->i_mode |= S_IFSOCK;
132 }
133 inode->i_uid = le64_to_cpu(findData.Uid);
134 inode->i_gid = le64_to_cpu(findData.Gid);
135 inode->i_nlink = le64_to_cpu(findData.Nlinks);
136
137 if(is_size_safe_to_change(cifsInfo)) {
138 /* can not safely change the file size here if the
139 client is writing to it due to potential races */
140
141 i_size_write(inode, end_of_file);
142
143 /* blksize needs to be multiple of two. So safer to default to
144 blksize and blkbits set in superblock so 2**blkbits and blksize
145 will match rather than setting to:
146 (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
147
148 /* This seems incredibly stupid but it turns out that i_blocks
149 is not related to (i_size / i_blksize), instead 512 byte size
150 is required for calculating num blocks */
151
152 /* 512 bytes (2**9) is the fake blocksize that must be used */
153 /* for this calculation */
154 inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
155 }
156
157 if (num_of_bytes < end_of_file)
158 cFYI(1, ("allocation size less than end of file "));
159 cFYI(1,
160 ("Size %ld and blocks %ld",
161 (unsigned long) inode->i_size, inode->i_blocks));
162 if (S_ISREG(inode->i_mode)) {
163 cFYI(1, (" File inode "));
164 inode->i_op = &cifs_file_inode_ops;
165 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
166 inode->i_fop = &cifs_file_direct_ops;
167 else
168 inode->i_fop = &cifs_file_ops;
169 inode->i_data.a_ops = &cifs_addr_ops;
170 } else if (S_ISDIR(inode->i_mode)) {
171 cFYI(1, (" Directory inode"));
172 inode->i_op = &cifs_dir_inode_ops;
173 inode->i_fop = &cifs_dir_ops;
174 } else if (S_ISLNK(inode->i_mode)) {
175 cFYI(1, (" Symbolic Link inode "));
176 inode->i_op = &cifs_symlink_inode_ops;
177 /* tmp_inode->i_fop = */ /* do not need to set to anything */
178 } else {
179 cFYI(1, (" Init special inode "));
180 init_special_inode(inode, inode->i_mode,
181 inode->i_rdev);
182 }
183 }
184 return rc;
185 }
186
187 int cifs_get_inode_info(struct inode **pinode,
188 const unsigned char *search_path, FILE_ALL_INFO *pfindData,
189 struct super_block *sb, int xid)
190 {
191 int rc = 0;
192 struct cifsTconInfo *pTcon;
193 struct inode *inode;
194 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
195 char *tmp_path;
196 char *buf = NULL;
197
198 pTcon = cifs_sb->tcon;
199 cFYI(1,("Getting info on %s ", search_path));
200
201 if((pfindData == NULL) && (*pinode != NULL)) {
202 if(CIFS_I(*pinode)->clientCanCacheRead) {
203 cFYI(1,("No need to revalidate cached inode sizes"));
204 return rc;
205 }
206 }
207
208 /* if file info not passed in then get it from server */
209 if(pfindData == NULL) {
210 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
211 if(buf == NULL)
212 return -ENOMEM;
213 pfindData = (FILE_ALL_INFO *)buf;
214 /* could do find first instead but this returns more info */
215 rc = CIFSSMBQPathInfo(xid, pTcon, search_path, pfindData,
216 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
217 CIFS_MOUNT_MAP_SPECIAL_CHR);
218 }
219 /* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
220 if (rc) {
221 if (rc == -EREMOTE) {
222 tmp_path =
223 kmalloc(strnlen
224 (pTcon->treeName,
225 MAX_TREE_SIZE + 1) +
226 strnlen(search_path, MAX_PATHCONF) + 1,
227 GFP_KERNEL);
228 if (tmp_path == NULL) {
229 kfree(buf);
230 return -ENOMEM;
231 }
232
233 strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
234 strncat(tmp_path, search_path, MAX_PATHCONF);
235 rc = connect_to_dfs_path(xid, pTcon->ses,
236 /* treename + */ tmp_path,
237 cifs_sb->local_nls,
238 cifs_sb->mnt_cifs_flags &
239 CIFS_MOUNT_MAP_SPECIAL_CHR);
240 kfree(tmp_path);
241 /* BB fix up inode etc. */
242 } else if (rc) {
243 kfree(buf);
244 return rc;
245 }
246 } else {
247 struct cifsInodeInfo *cifsInfo;
248 __u32 attr = le32_to_cpu(pfindData->Attributes);
249
250 /* get new inode */
251 if (*pinode == NULL) {
252 *pinode = new_inode(sb);
253 if (*pinode == NULL)
254 return -ENOMEM;
255 /* Is an i_ino of zero legal? Can we use that to check
256 if the server supports returning inode numbers? Are
257 there other sanity checks we can use to ensure that
258 the server is really filling in that field? */
259
260 /* We can not use the IndexNumber field by default from
261 Windows or Samba (in ALL_INFO buf) but we can request
262 it explicitly. It may not be unique presumably if
263 the server has multiple devices mounted under one
264 share */
265
266 /* There may be higher info levels that work but are
267 there Windows server or network appliances for which
268 IndexNumber field is not guaranteed unique? */
269
270 #ifdef CONFIG_CIFS_EXPERIMENTAL
271 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM){
272 int rc1 = 0;
273 __u64 inode_num;
274
275 rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
276 search_path, &inode_num,
277 cifs_sb->local_nls,
278 cifs_sb->mnt_cifs_flags &
279 CIFS_MOUNT_MAP_SPECIAL_CHR);
280 if(rc1) {
281 cFYI(1,("GetSrvInodeNum rc %d", rc1));
282 /* BB EOPNOSUPP disable SERVER_INUM? */
283 } else /* do we need cast or hash to ino? */
284 (*pinode)->i_ino = inode_num;
285 } /* else ino incremented to unique num in new_inode*/
286 #endif /* CIFS_EXPERIMENTAL */
287 insert_inode_hash(*pinode);
288 }
289 inode = *pinode;
290 cifsInfo = CIFS_I(inode);
291 cifsInfo->cifsAttrs = attr;
292 cFYI(1, (" Old time %ld ", cifsInfo->time));
293 cifsInfo->time = jiffies;
294 cFYI(1, (" New time %ld ", cifsInfo->time));
295
296 /* blksize needs to be multiple of two. So safer to default to
297 blksize and blkbits set in superblock so 2**blkbits and blksize
298 will match rather than setting to:
299 (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
300
301 /* Linux can not store file creation time unfortunately so we ignore it */
302 inode->i_atime =
303 cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastAccessTime));
304 inode->i_mtime =
305 cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
306 inode->i_ctime =
307 cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
308 cFYI(0, (" Attributes came in as 0x%x ", attr));
309
310 /* set default mode. will override for dirs below */
311 if (atomic_read(&cifsInfo->inUse) == 0)
312 /* new inode, can safely set these fields */
313 inode->i_mode = cifs_sb->mnt_file_mode;
314
315 /* if (attr & ATTR_REPARSE) */
316 /* We no longer handle these as symlinks because we could not
317 follow them due to the absolute path with drive letter */
318 if (attr & ATTR_DIRECTORY) {
319 /* override default perms since we do not do byte range locking
320 on dirs */
321 inode->i_mode = cifs_sb->mnt_dir_mode;
322 inode->i_mode |= S_IFDIR;
323 } else {
324 inode->i_mode |= S_IFREG;
325 /* treat the dos attribute of read-only as read-only
326 mode e.g. 555 */
327 if (cifsInfo->cifsAttrs & ATTR_READONLY)
328 inode->i_mode &= ~(S_IWUGO);
329 /* BB add code here -
330 validate if device or weird share or device type? */
331 }
332 if (is_size_safe_to_change(cifsInfo)) {
333 /* can not safely change the file size here if the
334 client is writing to it due to potential races */
335 i_size_write(inode,le64_to_cpu(pfindData->EndOfFile));
336
337 /* 512 bytes (2**9) is the fake blocksize that must be
338 used for this calculation */
339 inode->i_blocks = (512 - 1 + le64_to_cpu(
340 pfindData->AllocationSize)) >> 9;
341 }
342
343 inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
344
345 /* BB fill in uid and gid here? with help from winbind?
346 or retrieve from NTFS stream extended attribute */
347 if (atomic_read(&cifsInfo->inUse) == 0) {
348 inode->i_uid = cifs_sb->mnt_uid;
349 inode->i_gid = cifs_sb->mnt_gid;
350 /* set so we do not keep refreshing these fields with
351 bad data after user has changed them in memory */
352 atomic_set(&cifsInfo->inUse,1);
353 }
354
355 if (S_ISREG(inode->i_mode)) {
356 cFYI(1, (" File inode "));
357 inode->i_op = &cifs_file_inode_ops;
358 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
359 inode->i_fop = &cifs_file_direct_ops;
360 else
361 inode->i_fop = &cifs_file_ops;
362 inode->i_data.a_ops = &cifs_addr_ops;
363 } else if (S_ISDIR(inode->i_mode)) {
364 cFYI(1, (" Directory inode "));
365 inode->i_op = &cifs_dir_inode_ops;
366 inode->i_fop = &cifs_dir_ops;
367 } else if (S_ISLNK(inode->i_mode)) {
368 cFYI(1, (" Symbolic Link inode "));
369 inode->i_op = &cifs_symlink_inode_ops;
370 } else {
371 init_special_inode(inode, inode->i_mode,
372 inode->i_rdev);
373 }
374 }
375 kfree(buf);
376 return rc;
377 }
378
379 /* gets root inode */
380 void cifs_read_inode(struct inode *inode)
381 {
382 int xid;
383 struct cifs_sb_info *cifs_sb;
384
385 cifs_sb = CIFS_SB(inode->i_sb);
386 xid = GetXid();
387 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
388 cifs_get_inode_info_unix(&inode, "", inode->i_sb,xid);
389 else
390 cifs_get_inode_info(&inode, "", NULL, inode->i_sb,xid);
391 /* can not call macro FreeXid here since in a void func */
392 _FreeXid(xid);
393 }
394
395 int cifs_unlink(struct inode *inode, struct dentry *direntry)
396 {
397 int rc = 0;
398 int xid;
399 struct cifs_sb_info *cifs_sb;
400 struct cifsTconInfo *pTcon;
401 char *full_path = NULL;
402 struct cifsInodeInfo *cifsInode;
403 FILE_BASIC_INFO *pinfo_buf;
404
405 cFYI(1, (" cifs_unlink, inode = 0x%p with ", inode));
406
407 xid = GetXid();
408
409 cifs_sb = CIFS_SB(inode->i_sb);
410 pTcon = cifs_sb->tcon;
411
412 /* Unlink can be called from rename so we can not grab the sem here
413 since we deadlock otherwise */
414 /* down(&direntry->d_sb->s_vfs_rename_sem);*/
415 full_path = build_path_from_dentry(direntry);
416 /* up(&direntry->d_sb->s_vfs_rename_sem);*/
417 if (full_path == NULL) {
418 FreeXid(xid);
419 return -ENOMEM;
420 }
421 rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls,
422 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
423
424 if (!rc) {
425 direntry->d_inode->i_nlink--;
426 } else if (rc == -ENOENT) {
427 d_drop(direntry);
428 } else if (rc == -ETXTBSY) {
429 int oplock = FALSE;
430 __u16 netfid;
431
432 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
433 CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
434 &netfid, &oplock, NULL, cifs_sb->local_nls,
435 cifs_sb->mnt_cifs_flags &
436 CIFS_MOUNT_MAP_SPECIAL_CHR);
437 if (rc==0) {
438 CIFSSMBRenameOpenFile(xid, pTcon, netfid, NULL,
439 cifs_sb->local_nls,
440 cifs_sb->mnt_cifs_flags &
441 CIFS_MOUNT_MAP_SPECIAL_CHR);
442 CIFSSMBClose(xid, pTcon, netfid);
443 direntry->d_inode->i_nlink--;
444 }
445 } else if (rc == -EACCES) {
446 /* try only if r/o attribute set in local lookup data? */
447 pinfo_buf = kmalloc(sizeof(FILE_BASIC_INFO), GFP_KERNEL);
448 if (pinfo_buf) {
449 memset(pinfo_buf, 0, sizeof(FILE_BASIC_INFO));
450 /* ATTRS set to normal clears r/o bit */
451 pinfo_buf->Attributes = cpu_to_le32(ATTR_NORMAL);
452 if (!(pTcon->ses->flags & CIFS_SES_NT4))
453 rc = CIFSSMBSetTimes(xid, pTcon, full_path,
454 pinfo_buf,
455 cifs_sb->local_nls,
456 cifs_sb->mnt_cifs_flags &
457 CIFS_MOUNT_MAP_SPECIAL_CHR);
458 else
459 rc = -EOPNOTSUPP;
460
461 if (rc == -EOPNOTSUPP) {
462 int oplock = FALSE;
463 __u16 netfid;
464 /* rc = CIFSSMBSetAttrLegacy(xid, pTcon,
465 full_path,
466 (__u16)ATTR_NORMAL,
467 cifs_sb->local_nls);
468 For some strange reason it seems that NT4 eats the
469 old setattr call without actually setting the
470 attributes so on to the third attempted workaround
471 */
472
473 /* BB could scan to see if we already have it open
474 and pass in pid of opener to function */
475 rc = CIFSSMBOpen(xid, pTcon, full_path,
476 FILE_OPEN, SYNCHRONIZE |
477 FILE_WRITE_ATTRIBUTES, 0,
478 &netfid, &oplock, NULL,
479 cifs_sb->local_nls,
480 cifs_sb->mnt_cifs_flags &
481 CIFS_MOUNT_MAP_SPECIAL_CHR);
482 if (rc==0) {
483 rc = CIFSSMBSetFileTimes(xid, pTcon,
484 pinfo_buf,
485 netfid);
486 CIFSSMBClose(xid, pTcon, netfid);
487 }
488 }
489 kfree(pinfo_buf);
490 }
491 if (rc==0) {
492 rc = CIFSSMBDelFile(xid, pTcon, full_path,
493 cifs_sb->local_nls,
494 cifs_sb->mnt_cifs_flags &
495 CIFS_MOUNT_MAP_SPECIAL_CHR);
496 if (!rc) {
497 direntry->d_inode->i_nlink--;
498 } else if (rc == -ETXTBSY) {
499 int oplock = FALSE;
500 __u16 netfid;
501
502 rc = CIFSSMBOpen(xid, pTcon, full_path,
503 FILE_OPEN, DELETE,
504 CREATE_NOT_DIR |
505 CREATE_DELETE_ON_CLOSE,
506 &netfid, &oplock, NULL,
507 cifs_sb->local_nls,
508 cifs_sb->mnt_cifs_flags &
509 CIFS_MOUNT_MAP_SPECIAL_CHR);
510 if (rc==0) {
511 CIFSSMBRenameOpenFile(xid, pTcon,
512 netfid, NULL,
513 cifs_sb->local_nls,
514 cifs_sb->mnt_cifs_flags &
515 CIFS_MOUNT_MAP_SPECIAL_CHR);
516 CIFSSMBClose(xid, pTcon, netfid);
517 direntry->d_inode->i_nlink--;
518 }
519 /* BB if rc = -ETXTBUSY goto the rename logic BB */
520 }
521 }
522 }
523 cifsInode = CIFS_I(direntry->d_inode);
524 cifsInode->time = 0; /* will force revalidate to get info when
525 needed */
526 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
527 current_fs_time(inode->i_sb);
528 cifsInode = CIFS_I(inode);
529 cifsInode->time = 0; /* force revalidate of dir as well */
530
531 kfree(full_path);
532 FreeXid(xid);
533 return rc;
534 }
535
536 int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
537 {
538 int rc = 0;
539 int xid;
540 struct cifs_sb_info *cifs_sb;
541 struct cifsTconInfo *pTcon;
542 char *full_path = NULL;
543 struct inode *newinode = NULL;
544
545 cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p ", mode, inode));
546
547 xid = GetXid();
548
549 cifs_sb = CIFS_SB(inode->i_sb);
550 pTcon = cifs_sb->tcon;
551
552 down(&inode->i_sb->s_vfs_rename_sem);
553 full_path = build_path_from_dentry(direntry);
554 up(&inode->i_sb->s_vfs_rename_sem);
555 if (full_path == NULL) {
556 FreeXid(xid);
557 return -ENOMEM;
558 }
559 /* BB add setting the equivalent of mode via CreateX w/ACLs */
560 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
561 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
562 if (rc) {
563 cFYI(1, ("cifs_mkdir returned 0x%x ", rc));
564 d_drop(direntry);
565 } else {
566 inode->i_nlink++;
567 if (pTcon->ses->capabilities & CAP_UNIX)
568 rc = cifs_get_inode_info_unix(&newinode, full_path,
569 inode->i_sb,xid);
570 else
571 rc = cifs_get_inode_info(&newinode, full_path, NULL,
572 inode->i_sb,xid);
573
574 direntry->d_op = &cifs_dentry_ops;
575 d_instantiate(direntry, newinode);
576 if (direntry->d_inode)
577 direntry->d_inode->i_nlink = 2;
578 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
579 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
580 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
581 mode,
582 (__u64)current->euid,
583 (__u64)current->egid,
584 0 /* dev_t */,
585 cifs_sb->local_nls,
586 cifs_sb->mnt_cifs_flags &
587 CIFS_MOUNT_MAP_SPECIAL_CHR);
588 } else {
589 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
590 mode, (__u64)-1,
591 (__u64)-1, 0 /* dev_t */,
592 cifs_sb->local_nls,
593 cifs_sb->mnt_cifs_flags &
594 CIFS_MOUNT_MAP_SPECIAL_CHR);
595 }
596 else {
597 /* BB to be implemented via Windows secrty descriptors
598 eg CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
599 -1, -1, local_nls); */
600 }
601 }
602 kfree(full_path);
603 FreeXid(xid);
604 return rc;
605 }
606
607 int cifs_rmdir(struct inode *inode, struct dentry *direntry)
608 {
609 int rc = 0;
610 int xid;
611 struct cifs_sb_info *cifs_sb;
612 struct cifsTconInfo *pTcon;
613 char *full_path = NULL;
614 struct cifsInodeInfo *cifsInode;
615
616 cFYI(1, (" cifs_rmdir, inode = 0x%p with ", inode));
617
618 xid = GetXid();
619
620 cifs_sb = CIFS_SB(inode->i_sb);
621 pTcon = cifs_sb->tcon;
622
623 down(&inode->i_sb->s_vfs_rename_sem);
624 full_path = build_path_from_dentry(direntry);
625 up(&inode->i_sb->s_vfs_rename_sem);
626 if (full_path == NULL) {
627 FreeXid(xid);
628 return -ENOMEM;
629 }
630
631 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
632 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
633
634 if (!rc) {
635 inode->i_nlink--;
636 i_size_write(direntry->d_inode,0);
637 direntry->d_inode->i_nlink = 0;
638 }
639
640 cifsInode = CIFS_I(direntry->d_inode);
641 cifsInode->time = 0; /* force revalidate to go get info when
642 needed */
643 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
644 current_fs_time(inode->i_sb);
645
646 kfree(full_path);
647 FreeXid(xid);
648 return rc;
649 }
650
651 int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
652 struct inode *target_inode, struct dentry *target_direntry)
653 {
654 char *fromName;
655 char *toName;
656 struct cifs_sb_info *cifs_sb_source;
657 struct cifs_sb_info *cifs_sb_target;
658 struct cifsTconInfo *pTcon;
659 int xid;
660 int rc = 0;
661
662 xid = GetXid();
663
664 cifs_sb_target = CIFS_SB(target_inode->i_sb);
665 cifs_sb_source = CIFS_SB(source_inode->i_sb);
666 pTcon = cifs_sb_source->tcon;
667
668 if (pTcon != cifs_sb_target->tcon) {
669 FreeXid(xid);
670 return -EXDEV; /* BB actually could be allowed if same server,
671 but different share.
672 Might eventually add support for this */
673 }
674
675 /* we already have the rename sem so we do not need to grab it again
676 here to protect the path integrity */
677 fromName = build_path_from_dentry(source_direntry);
678 toName = build_path_from_dentry(target_direntry);
679 if ((fromName == NULL) || (toName == NULL)) {
680 rc = -ENOMEM;
681 goto cifs_rename_exit;
682 }
683
684 rc = CIFSSMBRename(xid, pTcon, fromName, toName,
685 cifs_sb_source->local_nls,
686 cifs_sb_source->mnt_cifs_flags &
687 CIFS_MOUNT_MAP_SPECIAL_CHR);
688 if (rc == -EEXIST) {
689 /* check if they are the same file because rename of hardlinked
690 files is a noop */
691 FILE_UNIX_BASIC_INFO *info_buf_source;
692 FILE_UNIX_BASIC_INFO *info_buf_target;
693
694 info_buf_source =
695 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
696 if (info_buf_source != NULL) {
697 info_buf_target = info_buf_source + 1;
698 rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,
699 info_buf_source, cifs_sb_source->local_nls,
700 cifs_sb_source->mnt_cifs_flags &
701 CIFS_MOUNT_MAP_SPECIAL_CHR);
702 if (rc == 0) {
703 rc = CIFSSMBUnixQPathInfo(xid, pTcon, toName,
704 info_buf_target,
705 cifs_sb_target->local_nls,
706 /* remap based on source sb */
707 cifs_sb_source->mnt_cifs_flags &
708 CIFS_MOUNT_MAP_SPECIAL_CHR);
709 }
710 if ((rc == 0) &&
711 (info_buf_source->UniqueId ==
712 info_buf_target->UniqueId)) {
713 /* do not rename since the files are hardlinked which
714 is a noop */
715 } else {
716 /* we either can not tell the files are hardlinked
717 (as with Windows servers) or files are not
718 hardlinked so delete the target manually before
719 renaming to follow POSIX rather than Windows
720 semantics */
721 cifs_unlink(target_inode, target_direntry);
722 rc = CIFSSMBRename(xid, pTcon, fromName,
723 toName,
724 cifs_sb_source->local_nls,
725 cifs_sb_source->mnt_cifs_flags
726 & CIFS_MOUNT_MAP_SPECIAL_CHR);
727 }
728 kfree(info_buf_source);
729 } /* if we can not get memory just leave rc as EEXIST */
730 }
731
732 if (rc) {
733 cFYI(1, ("rename rc %d", rc));
734 }
735
736 if ((rc == -EIO) || (rc == -EEXIST)) {
737 int oplock = FALSE;
738 __u16 netfid;
739
740 /* BB FIXME Is Generic Read correct for rename? */
741 /* if renaming directory - we should not say CREATE_NOT_DIR,
742 need to test renaming open directory, also GENERIC_READ
743 might not right be right access to request */
744 rc = CIFSSMBOpen(xid, pTcon, fromName, FILE_OPEN, GENERIC_READ,
745 CREATE_NOT_DIR, &netfid, &oplock, NULL,
746 cifs_sb_source->local_nls,
747 cifs_sb_source->mnt_cifs_flags &
748 CIFS_MOUNT_MAP_SPECIAL_CHR);
749 if (rc==0) {
750 CIFSSMBRenameOpenFile(xid, pTcon, netfid, toName,
751 cifs_sb_source->local_nls,
752 cifs_sb_source->mnt_cifs_flags &
753 CIFS_MOUNT_MAP_SPECIAL_CHR);
754 CIFSSMBClose(xid, pTcon, netfid);
755 }
756 }
757
758 cifs_rename_exit:
759 kfree(fromName);
760 kfree(toName);
761 FreeXid(xid);
762 return rc;
763 }
764
765 int cifs_revalidate(struct dentry *direntry)
766 {
767 int xid;
768 int rc = 0;
769 char *full_path;
770 struct cifs_sb_info *cifs_sb;
771 struct cifsInodeInfo *cifsInode;
772 loff_t local_size;
773 struct timespec local_mtime;
774 int invalidate_inode = FALSE;
775
776 if (direntry->d_inode == NULL)
777 return -ENOENT;
778
779 cifsInode = CIFS_I(direntry->d_inode);
780
781 if (cifsInode == NULL)
782 return -ENOENT;
783
784 /* no sense revalidating inode info on file that no one can write */
785 if (CIFS_I(direntry->d_inode)->clientCanCacheRead)
786 return rc;
787
788 xid = GetXid();
789
790 cifs_sb = CIFS_SB(direntry->d_sb);
791
792 /* can not safely grab the rename sem here if rename calls revalidate
793 since that would deadlock */
794 full_path = build_path_from_dentry(direntry);
795 if (full_path == NULL) {
796 FreeXid(xid);
797 return -ENOMEM;
798 }
799 cFYI(1, ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
800 "jiffies %ld", full_path, direntry->d_inode,
801 direntry->d_inode->i_count.counter, direntry,
802 direntry->d_time, jiffies));
803
804 if (cifsInode->time == 0) {
805 /* was set to zero previously to force revalidate */
806 } else if (time_before(jiffies, cifsInode->time + HZ) &&
807 lookupCacheEnabled) {
808 if ((S_ISREG(direntry->d_inode->i_mode) == 0) ||
809 (direntry->d_inode->i_nlink == 1)) {
810 kfree(full_path);
811 FreeXid(xid);
812 return rc;
813 } else {
814 cFYI(1, ("Have to revalidate file due to hardlinks"));
815 }
816 }
817
818 /* save mtime and size */
819 local_mtime = direntry->d_inode->i_mtime;
820 local_size = direntry->d_inode->i_size;
821
822 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
823 rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
824 direntry->d_sb,xid);
825 if (rc) {
826 cFYI(1, ("error on getting revalidate info %d", rc));
827 /* if (rc != -ENOENT)
828 rc = 0; */ /* BB should we cache info on
829 certain errors? */
830 }
831 } else {
832 rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
833 direntry->d_sb,xid);
834 if (rc) {
835 cFYI(1, ("error on getting revalidate info %d", rc));
836 /* if (rc != -ENOENT)
837 rc = 0; */ /* BB should we cache info on
838 certain errors? */
839 }
840 }
841 /* should we remap certain errors, access denied?, to zero */
842
843 /* if not oplocked, we invalidate inode pages if mtime or file size
844 had changed on server */
845
846 if (timespec_equal(&local_mtime,&direntry->d_inode->i_mtime) &&
847 (local_size == direntry->d_inode->i_size)) {
848 cFYI(1, ("cifs_revalidate - inode unchanged"));
849 } else {
850 /* file may have changed on server */
851 if (cifsInode->clientCanCacheRead) {
852 /* no need to invalidate inode pages since we were the
853 only ones who could have modified the file and the
854 server copy is staler than ours */
855 } else {
856 invalidate_inode = TRUE;
857 }
858 }
859
860 /* can not grab this sem since kernel filesys locking documentation
861 indicates i_sem may be taken by the kernel on lookup and rename
862 which could deadlock if we grab the i_sem here as well */
863 /* down(&direntry->d_inode->i_sem);*/
864 /* need to write out dirty pages here */
865 if (direntry->d_inode->i_mapping) {
866 /* do we need to lock inode until after invalidate completes
867 below? */
868 filemap_fdatawrite(direntry->d_inode->i_mapping);
869 }
870 if (invalidate_inode) {
871 if (direntry->d_inode->i_mapping)
872 filemap_fdatawait(direntry->d_inode->i_mapping);
873 /* may eventually have to do this for open files too */
874 if (list_empty(&(cifsInode->openFileList))) {
875 /* Has changed on server - flush read ahead pages */
876 cFYI(1, ("Invalidating read ahead data on "
877 "closed file"));
878 invalidate_remote_inode(direntry->d_inode);
879 }
880 }
881 /* up(&direntry->d_inode->i_sem); */
882
883 kfree(full_path);
884 FreeXid(xid);
885 return rc;
886 }
887
888 int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
889 struct kstat *stat)
890 {
891 int err = cifs_revalidate(dentry);
892 if (!err)
893 generic_fillattr(dentry->d_inode, stat);
894 return err;
895 }
896
897 static int cifs_truncate_page(struct address_space *mapping, loff_t from)
898 {
899 pgoff_t index = from >> PAGE_CACHE_SHIFT;
900 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
901 struct page *page;
902 char *kaddr;
903 int rc = 0;
904
905 page = grab_cache_page(mapping, index);
906 if (!page)
907 return -ENOMEM;
908
909 kaddr = kmap_atomic(page, KM_USER0);
910 memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
911 flush_dcache_page(page);
912 kunmap_atomic(kaddr, KM_USER0);
913 unlock_page(page);
914 page_cache_release(page);
915 return rc;
916 }
917
918 int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
919 {
920 int xid;
921 struct cifs_sb_info *cifs_sb;
922 struct cifsTconInfo *pTcon;
923 char *full_path = NULL;
924 int rc = -EACCES;
925 int found = FALSE;
926 struct cifsFileInfo *open_file = NULL;
927 FILE_BASIC_INFO time_buf;
928 int set_time = FALSE;
929 __u64 mode = 0xFFFFFFFFFFFFFFFFULL;
930 __u64 uid = 0xFFFFFFFFFFFFFFFFULL;
931 __u64 gid = 0xFFFFFFFFFFFFFFFFULL;
932 struct cifsInodeInfo *cifsInode;
933 struct list_head *tmp;
934
935 xid = GetXid();
936
937 cFYI(1, (" In cifs_setattr, name = %s attrs->iavalid 0x%x ",
938 direntry->d_name.name, attrs->ia_valid));
939 cifs_sb = CIFS_SB(direntry->d_inode->i_sb);
940 pTcon = cifs_sb->tcon;
941
942 down(&direntry->d_sb->s_vfs_rename_sem);
943 full_path = build_path_from_dentry(direntry);
944 up(&direntry->d_sb->s_vfs_rename_sem);
945 if (full_path == NULL) {
946 FreeXid(xid);
947 return -ENOMEM;
948 }
949 cifsInode = CIFS_I(direntry->d_inode);
950
951 /* BB check if we need to refresh inode from server now ? BB */
952
953 /* need to flush data before changing file size on server */
954 filemap_fdatawrite(direntry->d_inode->i_mapping);
955 filemap_fdatawait(direntry->d_inode->i_mapping);
956
957 if (attrs->ia_valid & ATTR_SIZE) {
958 read_lock(&GlobalSMBSeslock);
959 /* To avoid spurious oplock breaks from server, in the case of
960 inodes that we already have open, avoid doing path based
961 setting of file size if we can do it by handle.
962 This keeps our caching token (oplock) and avoids timeouts
963 when the local oplock break takes longer to flush
964 writebehind data than the SMB timeout for the SetPathInfo
965 request would allow */
966 list_for_each(tmp, &cifsInode->openFileList) {
967 open_file = list_entry(tmp, struct cifsFileInfo,
968 flist);
969 /* We check if file is open for writing first */
970 if ((open_file->pfile) &&
971 ((open_file->pfile->f_flags & O_RDWR) ||
972 (open_file->pfile->f_flags & O_WRONLY))) {
973 if (open_file->invalidHandle == FALSE) {
974 /* we found a valid, writeable network
975 file handle to use to try to set the
976 file size */
977 __u16 nfid = open_file->netfid;
978 __u32 npid = open_file->pid;
979 read_unlock(&GlobalSMBSeslock);
980 found = TRUE;
981 rc = CIFSSMBSetFileSize(xid, pTcon,
982 attrs->ia_size, nfid, npid,
983 FALSE);
984 cFYI(1, ("SetFileSize by handle "
985 "(setattrs) rc = %d", rc));
986 /* Do not need reopen and retry on
987 EAGAIN since we will retry by
988 pathname below */
989
990 /* now that we found one valid file
991 handle no sense continuing to loop
992 trying others, so break here */
993 break;
994 }
995 }
996 }
997 if (found == FALSE)
998 read_unlock(&GlobalSMBSeslock);
999
1000 if (rc != 0) {
1001 /* Set file size by pathname rather than by handle
1002 either because no valid, writeable file handle for
1003 it was found or because there was an error setting
1004 it by handle */
1005 rc = CIFSSMBSetEOF(xid, pTcon, full_path,
1006 attrs->ia_size, FALSE,
1007 cifs_sb->local_nls,
1008 cifs_sb->mnt_cifs_flags &
1009 CIFS_MOUNT_MAP_SPECIAL_CHR);
1010 cFYI(1, (" SetEOF by path (setattrs) rc = %d", rc));
1011 }
1012
1013 /* Server is ok setting allocation size implicitly - no need
1014 to call:
1015 CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, TRUE,
1016 cifs_sb->local_nls);
1017 */
1018
1019 if (rc == 0) {
1020 rc = vmtruncate(direntry->d_inode, attrs->ia_size);
1021 cifs_truncate_page(direntry->d_inode->i_mapping,
1022 direntry->d_inode->i_size);
1023 }
1024 }
1025 if (attrs->ia_valid & ATTR_UID) {
1026 cFYI(1, (" CIFS - UID changed to %d", attrs->ia_uid));
1027 uid = attrs->ia_uid;
1028 /* entry->uid = cpu_to_le16(attr->ia_uid); */
1029 }
1030 if (attrs->ia_valid & ATTR_GID) {
1031 cFYI(1, (" CIFS - GID changed to %d", attrs->ia_gid));
1032 gid = attrs->ia_gid;
1033 /* entry->gid = cpu_to_le16(attr->ia_gid); */
1034 }
1035
1036 time_buf.Attributes = 0;
1037 if (attrs->ia_valid & ATTR_MODE) {
1038 cFYI(1, (" CIFS - Mode changed to 0x%x", attrs->ia_mode));
1039 mode = attrs->ia_mode;
1040 /* entry->mode = cpu_to_le16(attr->ia_mode); */
1041 }
1042
1043 if ((cifs_sb->tcon->ses->capabilities & CAP_UNIX)
1044 && (attrs->ia_valid & (ATTR_MODE | ATTR_GID | ATTR_UID)))
1045 rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode, uid, gid,
1046 0 /* dev_t */, cifs_sb->local_nls,
1047 cifs_sb->mnt_cifs_flags &
1048 CIFS_MOUNT_MAP_SPECIAL_CHR);
1049 else if (attrs->ia_valid & ATTR_MODE) {
1050 if ((mode & S_IWUGO) == 0) /* not writeable */ {
1051 if ((cifsInode->cifsAttrs & ATTR_READONLY) == 0)
1052 time_buf.Attributes =
1053 cpu_to_le32(cifsInode->cifsAttrs |
1054 ATTR_READONLY);
1055 } else if ((mode & S_IWUGO) == S_IWUGO) {
1056 if (cifsInode->cifsAttrs & ATTR_READONLY)
1057 time_buf.Attributes =
1058 cpu_to_le32(cifsInode->cifsAttrs &
1059 (~ATTR_READONLY));
1060 }
1061 /* BB to be implemented -
1062 via Windows security descriptors or streams */
1063 /* CIFSSMBWinSetPerms(xid, pTcon, full_path, mode, uid, gid,
1064 cifs_sb->local_nls); */
1065 }
1066
1067 if (attrs->ia_valid & ATTR_ATIME) {
1068 set_time = TRUE;
1069 time_buf.LastAccessTime =
1070 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1071 } else
1072 time_buf.LastAccessTime = 0;
1073
1074 if (attrs->ia_valid & ATTR_MTIME) {
1075 set_time = TRUE;
1076 time_buf.LastWriteTime =
1077 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1078 } else
1079 time_buf.LastWriteTime = 0;
1080
1081 if (attrs->ia_valid & ATTR_CTIME) {
1082 set_time = TRUE;
1083 cFYI(1, (" CIFS - CTIME changed ")); /* BB probably no need */
1084 time_buf.ChangeTime =
1085 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1086 } else
1087 time_buf.ChangeTime = 0;
1088
1089 if (set_time || time_buf.Attributes) {
1090 /* BB what if setting one attribute fails (such as size) but
1091 time setting works? */
1092 time_buf.CreationTime = 0; /* do not change */
1093 /* In the future we should experiment - try setting timestamps
1094 via Handle (SetFileInfo) instead of by path */
1095 if (!(pTcon->ses->flags & CIFS_SES_NT4))
1096 rc = CIFSSMBSetTimes(xid, pTcon, full_path, &time_buf,
1097 cifs_sb->local_nls,
1098 cifs_sb->mnt_cifs_flags &
1099 CIFS_MOUNT_MAP_SPECIAL_CHR);
1100 else
1101 rc = -EOPNOTSUPP;
1102
1103 if (rc == -EOPNOTSUPP) {
1104 int oplock = FALSE;
1105 __u16 netfid;
1106
1107 cFYI(1, ("calling SetFileInfo since SetPathInfo for "
1108 "times not supported by this server"));
1109 /* BB we could scan to see if we already have it open
1110 and pass in pid of opener to function */
1111 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1112 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1113 CREATE_NOT_DIR, &netfid, &oplock,
1114 NULL, cifs_sb->local_nls,
1115 cifs_sb->mnt_cifs_flags &
1116 CIFS_MOUNT_MAP_SPECIAL_CHR);
1117 if (rc==0) {
1118 rc = CIFSSMBSetFileTimes(xid, pTcon, &time_buf,
1119 netfid);
1120 CIFSSMBClose(xid, pTcon, netfid);
1121 } else {
1122 /* BB For even older servers we could convert time_buf
1123 into old DOS style which uses two second
1124 granularity */
1125
1126 /* rc = CIFSSMBSetTimesLegacy(xid, pTcon, full_path,
1127 &time_buf, cifs_sb->local_nls); */
1128 }
1129 }
1130 }
1131
1132 /* do not need local check to inode_check_ok since the server does
1133 that */
1134 if (!rc)
1135 rc = inode_setattr(direntry->d_inode, attrs);
1136 kfree(full_path);
1137 FreeXid(xid);
1138 return rc;
1139 }
1140
1141 void cifs_delete_inode(struct inode *inode)
1142 {
1143 cFYI(1, ("In cifs_delete_inode, inode = 0x%p ", inode));
1144 /* may have to add back in if and when safe distributed caching of
1145 directories added e.g. via FindNotify */
1146 }
Verdex Pro support