projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge with rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / cifs / inode.c
CommitLineData
1da177e4
LT		 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
33int 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,
737b758c
SF		 47 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
48 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 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,
737b758c
SF		 67 cifs_sb->local_nls,
68 cifs_sb->mnt_cifs_flags &
69 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 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
187int 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,
737b758c
SF		 216 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
217 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 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,
737b758c
SF		 237 cifs_sb->local_nls,
238 cifs_sb->mnt_cifs_flags &
239 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 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,
737b758c
SF		 277 cifs_sb->local_nls,
278 cifs_sb->mnt_cifs_flags &
279 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 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 */
380void 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
395int 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 }
737b758c
SF		 421 rc = CIFSSMBDelFile(xid, pTcon, full_path, cifs_sb->local_nls,
422 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 423
424 if (!rc) {
b2aeb9d5
SF		 425 if(direntry->d_inode)
426 direntry->d_inode->i_nlink--;
1da177e4
LT		 427 } else if (rc == -ENOENT) {
428 d_drop(direntry);
429 } else if (rc == -ETXTBSY) {
430 int oplock = FALSE;
431 __u16 netfid;
432
433 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN, DELETE,
434 CREATE_NOT_DIR | CREATE_DELETE_ON_CLOSE,
737b758c
SF		 435 &netfid, &oplock, NULL, cifs_sb->local_nls,
436 cifs_sb->mnt_cifs_flags &
437 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 438 if (rc==0) {
439 CIFSSMBRenameOpenFile(xid, pTcon, netfid, NULL,
737b758c
SF		 440 cifs_sb->local_nls,
441 cifs_sb->mnt_cifs_flags &
442 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4 443 CIFSSMBClose(xid, pTcon, netfid);
b2aeb9d5
SF		 444 if(direntry->d_inode)
445 direntry->d_inode->i_nlink--;
1da177e4
LT		 446 }
447 } else if (rc == -EACCES) {
448 /* try only if r/o attribute set in local lookup data? */
449 pinfo_buf = kmalloc(sizeof(FILE_BASIC_INFO), GFP_KERNEL);
450 if (pinfo_buf) {
451 memset(pinfo_buf, 0, sizeof(FILE_BASIC_INFO));
452 /* ATTRS set to normal clears r/o bit */
453 pinfo_buf->Attributes = cpu_to_le32(ATTR_NORMAL);
454 if (!(pTcon->ses->flags & CIFS_SES_NT4))
455 rc = CIFSSMBSetTimes(xid, pTcon, full_path,
456 pinfo_buf,
737b758c
SF		 457 cifs_sb->local_nls,
458 cifs_sb->mnt_cifs_flags &
459 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 460 else
461 rc = -EOPNOTSUPP;
462
463 if (rc == -EOPNOTSUPP) {
464 int oplock = FALSE;
465 __u16 netfid;
466 /* rc = CIFSSMBSetAttrLegacy(xid, pTcon,
467 full_path,
468 (__u16)ATTR_NORMAL,
469 cifs_sb->local_nls);
470 For some strange reason it seems that NT4 eats the
471 old setattr call without actually setting the
472 attributes so on to the third attempted workaround
473 */
474
475 /* BB could scan to see if we already have it open
476 and pass in pid of opener to function */
477 rc = CIFSSMBOpen(xid, pTcon, full_path,
478 FILE_OPEN, SYNCHRONIZE |
479 FILE_WRITE_ATTRIBUTES, 0,
480 &netfid, &oplock, NULL,
737b758c
SF		 481 cifs_sb->local_nls,
482 cifs_sb->mnt_cifs_flags &
483 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 484 if (rc==0) {
485 rc = CIFSSMBSetFileTimes(xid, pTcon,
486 pinfo_buf,
487 netfid);
488 CIFSSMBClose(xid, pTcon, netfid);
489 }
490 }
491 kfree(pinfo_buf);
492 }
493 if (rc==0) {
737b758c
SF		 494 rc = CIFSSMBDelFile(xid, pTcon, full_path,
495 cifs_sb->local_nls,
496 cifs_sb->mnt_cifs_flags &
497 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4 498 if (!rc) {
b2aeb9d5
SF		 499 if(direntry->d_inode)
500 direntry->d_inode->i_nlink--;
1da177e4
LT		 501 } else if (rc == -ETXTBSY) {
502 int oplock = FALSE;
503 __u16 netfid;
504
505 rc = CIFSSMBOpen(xid, pTcon, full_path,
506 FILE_OPEN, DELETE,
507 CREATE_NOT_DIR |
508 CREATE_DELETE_ON_CLOSE,
509 &netfid, &oplock, NULL,
737b758c
SF		 510 cifs_sb->local_nls,
511 cifs_sb->mnt_cifs_flags &
512 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 513 if (rc==0) {
514 CIFSSMBRenameOpenFile(xid, pTcon,
515 netfid, NULL,
737b758c
SF		 516 cifs_sb->local_nls,
517 cifs_sb->mnt_cifs_flags &
518 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4 519 CIFSSMBClose(xid, pTcon, netfid);
b2aeb9d5
SF		 520 if(direntry->d_inode)
521 direntry->d_inode->i_nlink--;
1da177e4
LT		 522 }
523 /* BB if rc = -ETXTBUSY goto the rename logic BB */
524 }
525 }
526 }
b2aeb9d5
SF		 527 if(direntry->d_inode) {
528 cifsInode = CIFS_I(direntry->d_inode);
529 cifsInode->time = 0; /* will force revalidate to get info
530 when needed */
531 direntry->d_inode->i_ctime = current_fs_time(inode->i_sb);
532 }
533 inode->i_ctime = inode->i_mtime = current_fs_time(inode->i_sb);
1da177e4
LT		 534 cifsInode = CIFS_I(inode);
535 cifsInode->time = 0; /* force revalidate of dir as well */
536
537 kfree(full_path);
538 FreeXid(xid);
539 return rc;
540}
541
542int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
543{
544 int rc = 0;
545 int xid;
546 struct cifs_sb_info *cifs_sb;
547 struct cifsTconInfo *pTcon;
548 char *full_path = NULL;
549 struct inode *newinode = NULL;
550
551 cFYI(1, ("In cifs_mkdir, mode = 0x%x inode = 0x%p ", mode, inode));
552
553 xid = GetXid();
554
555 cifs_sb = CIFS_SB(inode->i_sb);
556 pTcon = cifs_sb->tcon;
557
558 down(&inode->i_sb->s_vfs_rename_sem);
559 full_path = build_path_from_dentry(direntry);
560 up(&inode->i_sb->s_vfs_rename_sem);
561 if (full_path == NULL) {
562 FreeXid(xid);
563 return -ENOMEM;
564 }
565 /* BB add setting the equivalent of mode via CreateX w/ACLs */
737b758c
SF		 566 rc = CIFSSMBMkDir(xid, pTcon, full_path, cifs_sb->local_nls,
567 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 568 if (rc) {
569 cFYI(1, ("cifs_mkdir returned 0x%x ", rc));
570 d_drop(direntry);
571 } else {
572 inode->i_nlink++;
573 if (pTcon->ses->capabilities & CAP_UNIX)
574 rc = cifs_get_inode_info_unix(&newinode, full_path,
575 inode->i_sb,xid);
576 else
577 rc = cifs_get_inode_info(&newinode, full_path, NULL,
578 inode->i_sb,xid);
579
580 direntry->d_op = &cifs_dentry_ops;
581 d_instantiate(direntry, newinode);
582 if (direntry->d_inode)
583 direntry->d_inode->i_nlink = 2;
584 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX)
585 if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
586 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
587 mode,
588 (__u64)current->euid,
589 (__u64)current->egid,
590 0 /* dev_t */,
737b758c
SF		 591 cifs_sb->local_nls,
592 cifs_sb->mnt_cifs_flags &
593 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 594 } else {
595 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
596 mode, (__u64)-1,
597 (__u64)-1, 0 /* dev_t */,
737b758c
SF		 598 cifs_sb->local_nls,
599 cifs_sb->mnt_cifs_flags &
600 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 601 }
602 else {
603 /* BB to be implemented via Windows secrty descriptors
604 eg CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
605 -1, -1, local_nls); */
606 }
607 }
608 kfree(full_path);
609 FreeXid(xid);
610 return rc;
611}
612
613int cifs_rmdir(struct inode *inode, struct dentry *direntry)
614{
615 int rc = 0;
616 int xid;
617 struct cifs_sb_info *cifs_sb;
618 struct cifsTconInfo *pTcon;
619 char *full_path = NULL;
620 struct cifsInodeInfo *cifsInode;
621
622 cFYI(1, (" cifs_rmdir, inode = 0x%p with ", inode));
623
624 xid = GetXid();
625
626 cifs_sb = CIFS_SB(inode->i_sb);
627 pTcon = cifs_sb->tcon;
628
629 down(&inode->i_sb->s_vfs_rename_sem);
630 full_path = build_path_from_dentry(direntry);
631 up(&inode->i_sb->s_vfs_rename_sem);
632 if (full_path == NULL) {
633 FreeXid(xid);
634 return -ENOMEM;
635 }
636
737b758c
SF		 637 rc = CIFSSMBRmDir(xid, pTcon, full_path, cifs_sb->local_nls,
638 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 639
640 if (!rc) {
641 inode->i_nlink--;
642 i_size_write(direntry->d_inode,0);
643 direntry->d_inode->i_nlink = 0;
644 }
645
646 cifsInode = CIFS_I(direntry->d_inode);
647 cifsInode->time = 0; /* force revalidate to go get info when
648 needed */
649 direntry->d_inode->i_ctime = inode->i_ctime = inode->i_mtime =
650 current_fs_time(inode->i_sb);
651
652 kfree(full_path);
653 FreeXid(xid);
654 return rc;
655}
656
657int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
658 struct inode *target_inode, struct dentry *target_direntry)
659{
660 char *fromName;
661 char *toName;
662 struct cifs_sb_info *cifs_sb_source;
663 struct cifs_sb_info *cifs_sb_target;
664 struct cifsTconInfo *pTcon;
665 int xid;
666 int rc = 0;
667
668 xid = GetXid();
669
670 cifs_sb_target = CIFS_SB(target_inode->i_sb);
671 cifs_sb_source = CIFS_SB(source_inode->i_sb);
672 pTcon = cifs_sb_source->tcon;
673
674 if (pTcon != cifs_sb_target->tcon) {
675 FreeXid(xid);
676 return -EXDEV; /* BB actually could be allowed if same server,
677 but different share.
678 Might eventually add support for this */
679 }
680
681 /* we already have the rename sem so we do not need to grab it again
682 here to protect the path integrity */
683 fromName = build_path_from_dentry(source_direntry);
684 toName = build_path_from_dentry(target_direntry);
685 if ((fromName == NULL) || (toName == NULL)) {
686 rc = -ENOMEM;
687 goto cifs_rename_exit;
688 }
689
690 rc = CIFSSMBRename(xid, pTcon, fromName, toName,
737b758c
SF		 691 cifs_sb_source->local_nls,
692 cifs_sb_source->mnt_cifs_flags &
693 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 694 if (rc == -EEXIST) {
695 /* check if they are the same file because rename of hardlinked
696 files is a noop */
697 FILE_UNIX_BASIC_INFO *info_buf_source;
698 FILE_UNIX_BASIC_INFO *info_buf_target;
699
700 info_buf_source =
701 kmalloc(2 * sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
702 if (info_buf_source != NULL) {
703 info_buf_target = info_buf_source + 1;
704 rc = CIFSSMBUnixQPathInfo(xid, pTcon, fromName,
737b758c
SF		 705 info_buf_source, cifs_sb_source->local_nls,
706 cifs_sb_source->mnt_cifs_flags &
707 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 708 if (rc == 0) {
709 rc = CIFSSMBUnixQPathInfo(xid, pTcon, toName,
710 info_buf_target,
737b758c
SF		 711 cifs_sb_target->local_nls,
712 /* remap based on source sb */
713 cifs_sb_source->mnt_cifs_flags &
714 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 715 }
716 if ((rc == 0) &&
717 (info_buf_source->UniqueId ==
718 info_buf_target->UniqueId)) {
719 /* do not rename since the files are hardlinked which
720 is a noop */
721 } else {
722 /* we either can not tell the files are hardlinked
723 (as with Windows servers) or files are not
724 hardlinked so delete the target manually before
725 renaming to follow POSIX rather than Windows
726 semantics */
727 cifs_unlink(target_inode, target_direntry);
728 rc = CIFSSMBRename(xid, pTcon, fromName,
729 toName,
737b758c
SF		 730 cifs_sb_source->local_nls,
731 cifs_sb_source->mnt_cifs_flags
732 & CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 733 }
734 kfree(info_buf_source);
735 } /* if we can not get memory just leave rc as EEXIST */
736 }
737
738 if (rc) {
739 cFYI(1, ("rename rc %d", rc));
740 }
741
742 if ((rc == -EIO) || (rc == -EEXIST)) {
743 int oplock = FALSE;
744 __u16 netfid;
745
746 /* BB FIXME Is Generic Read correct for rename? */
747 /* if renaming directory - we should not say CREATE_NOT_DIR,
748 need to test renaming open directory, also GENERIC_READ
749 might not right be right access to request */
750 rc = CIFSSMBOpen(xid, pTcon, fromName, FILE_OPEN, GENERIC_READ,
751 CREATE_NOT_DIR, &netfid, &oplock, NULL,
737b758c
SF		 752 cifs_sb_source->local_nls,
753 cifs_sb_source->mnt_cifs_flags &
754 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 755 if (rc==0) {
756 CIFSSMBRenameOpenFile(xid, pTcon, netfid, toName,
737b758c
SF		 757 cifs_sb_source->local_nls,
758 cifs_sb_source->mnt_cifs_flags &
759 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 760 CIFSSMBClose(xid, pTcon, netfid);
761 }
762 }
763
764cifs_rename_exit:
765 kfree(fromName);
766 kfree(toName);
767 FreeXid(xid);
768 return rc;
769}
770
771int cifs_revalidate(struct dentry *direntry)
772{
773 int xid;
774 int rc = 0;
775 char *full_path;
776 struct cifs_sb_info *cifs_sb;
777 struct cifsInodeInfo *cifsInode;
778 loff_t local_size;
779 struct timespec local_mtime;
780 int invalidate_inode = FALSE;
781
782 if (direntry->d_inode == NULL)
783 return -ENOENT;
784
785 cifsInode = CIFS_I(direntry->d_inode);
786
787 if (cifsInode == NULL)
788 return -ENOENT;
789
790 /* no sense revalidating inode info on file that no one can write */
791 if (CIFS_I(direntry->d_inode)->clientCanCacheRead)
792 return rc;
793
794 xid = GetXid();
795
796 cifs_sb = CIFS_SB(direntry->d_sb);
797
798 /* can not safely grab the rename sem here if rename calls revalidate
799 since that would deadlock */
800 full_path = build_path_from_dentry(direntry);
801 if (full_path == NULL) {
802 FreeXid(xid);
803 return -ENOMEM;
804 }
805 cFYI(1, ("Revalidate: %s inode 0x%p count %d dentry: 0x%p d_time %ld "
806 "jiffies %ld", full_path, direntry->d_inode,
807 direntry->d_inode->i_count.counter, direntry,
808 direntry->d_time, jiffies));
809
810 if (cifsInode->time == 0) {
811 /* was set to zero previously to force revalidate */
812 } else if (time_before(jiffies, cifsInode->time + HZ) &&
813 lookupCacheEnabled) {
814 if ((S_ISREG(direntry->d_inode->i_mode) == 0) ||
815 (direntry->d_inode->i_nlink == 1)) {
816 kfree(full_path);
817 FreeXid(xid);
818 return rc;
819 } else {
820 cFYI(1, ("Have to revalidate file due to hardlinks"));
821 }
822 }
823
824 /* save mtime and size */
825 local_mtime = direntry->d_inode->i_mtime;
826 local_size = direntry->d_inode->i_size;
827
828 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
829 rc = cifs_get_inode_info_unix(&direntry->d_inode, full_path,
830 direntry->d_sb,xid);
831 if (rc) {
832 cFYI(1, ("error on getting revalidate info %d", rc));
833/* if (rc != -ENOENT)
834 rc = 0; */ /* BB should we cache info on
835 certain errors? */
836 }
837 } else {
838 rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
839 direntry->d_sb,xid);
840 if (rc) {
841 cFYI(1, ("error on getting revalidate info %d", rc));
842/* if (rc != -ENOENT)
843 rc = 0; */ /* BB should we cache info on
844 certain errors? */
845 }
846 }
847 /* should we remap certain errors, access denied?, to zero */
848
849 /* if not oplocked, we invalidate inode pages if mtime or file size
850 had changed on server */
851
852 if (timespec_equal(&local_mtime,&direntry->d_inode->i_mtime) &&
853 (local_size == direntry->d_inode->i_size)) {
854 cFYI(1, ("cifs_revalidate - inode unchanged"));
855 } else {
856 /* file may have changed on server */
857 if (cifsInode->clientCanCacheRead) {
858 /* no need to invalidate inode pages since we were the
859 only ones who could have modified the file and the
860 server copy is staler than ours */
861 } else {
862 invalidate_inode = TRUE;
863 }
864 }
865
866 /* can not grab this sem since kernel filesys locking documentation
867 indicates i_sem may be taken by the kernel on lookup and rename
868 which could deadlock if we grab the i_sem here as well */
869/* down(&direntry->d_inode->i_sem);*/
870 /* need to write out dirty pages here */
871 if (direntry->d_inode->i_mapping) {
872 /* do we need to lock inode until after invalidate completes
873 below? */
874 filemap_fdatawrite(direntry->d_inode->i_mapping);
875 }
876 if (invalidate_inode) {
877 if (direntry->d_inode->i_mapping)
878 filemap_fdatawait(direntry->d_inode->i_mapping);
879 /* may eventually have to do this for open files too */
880 if (list_empty(&(cifsInode->openFileList))) {
881 /* Has changed on server - flush read ahead pages */
882 cFYI(1, ("Invalidating read ahead data on "
883 "closed file"));
884 invalidate_remote_inode(direntry->d_inode);
885 }
886 }
887/* up(&direntry->d_inode->i_sem); */
888
889 kfree(full_path);
890 FreeXid(xid);
891 return rc;
892}
893
894int cifs_getattr(struct vfsmount *mnt, struct dentry *dentry,
895 struct kstat *stat)
896{
897 int err = cifs_revalidate(dentry);
898 if (!err)
899 generic_fillattr(dentry->d_inode, stat);
900 return err;
901}
902
903static int cifs_truncate_page(struct address_space *mapping, loff_t from)
904{
905 pgoff_t index = from >> PAGE_CACHE_SHIFT;
906 unsigned offset = from & (PAGE_CACHE_SIZE - 1);
907 struct page *page;
908 char *kaddr;
909 int rc = 0;
910
911 page = grab_cache_page(mapping, index);
912 if (!page)
913 return -ENOMEM;
914
915 kaddr = kmap_atomic(page, KM_USER0);
916 memset(kaddr + offset, 0, PAGE_CACHE_SIZE - offset);
917 flush_dcache_page(page);
918 kunmap_atomic(kaddr, KM_USER0);
919 unlock_page(page);
920 page_cache_release(page);
921 return rc;
922}
923
924int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
925{
926 int xid;
927 struct cifs_sb_info *cifs_sb;
928 struct cifsTconInfo *pTcon;
929 char *full_path = NULL;
930 int rc = -EACCES;
931 int found = FALSE;
932 struct cifsFileInfo *open_file = NULL;
933 FILE_BASIC_INFO time_buf;
934 int set_time = FALSE;
935 __u64 mode = 0xFFFFFFFFFFFFFFFFULL;
936 __u64 uid = 0xFFFFFFFFFFFFFFFFULL;
937 __u64 gid = 0xFFFFFFFFFFFFFFFFULL;
938 struct cifsInodeInfo *cifsInode;
939 struct list_head *tmp;
940
941 xid = GetXid();
942
943 cFYI(1, (" In cifs_setattr, name = %s attrs->iavalid 0x%x ",
944 direntry->d_name.name, attrs->ia_valid));
945 cifs_sb = CIFS_SB(direntry->d_inode->i_sb);
946 pTcon = cifs_sb->tcon;
947
948 down(&direntry->d_sb->s_vfs_rename_sem);
949 full_path = build_path_from_dentry(direntry);
950 up(&direntry->d_sb->s_vfs_rename_sem);
951 if (full_path == NULL) {
952 FreeXid(xid);
953 return -ENOMEM;
954 }
955 cifsInode = CIFS_I(direntry->d_inode);
956
957 /* BB check if we need to refresh inode from server now ? BB */
958
959 /* need to flush data before changing file size on server */
960 filemap_fdatawrite(direntry->d_inode->i_mapping);
961 filemap_fdatawait(direntry->d_inode->i_mapping);
962
963 if (attrs->ia_valid & ATTR_SIZE) {
964 read_lock(&GlobalSMBSeslock);
965 /* To avoid spurious oplock breaks from server, in the case of
966 inodes that we already have open, avoid doing path based
967 setting of file size if we can do it by handle.
968 This keeps our caching token (oplock) and avoids timeouts
969 when the local oplock break takes longer to flush
970 writebehind data than the SMB timeout for the SetPathInfo
971 request would allow */
972 list_for_each(tmp, &cifsInode->openFileList) {
973 open_file = list_entry(tmp, struct cifsFileInfo,
974 flist);
975 /* We check if file is open for writing first */
976 if ((open_file->pfile) &&
977 ((open_file->pfile->f_flags & O_RDWR) ||
978 (open_file->pfile->f_flags & O_WRONLY))) {
979 if (open_file->invalidHandle == FALSE) {
980 /* we found a valid, writeable network
981 file handle to use to try to set the
982 file size */
983 __u16 nfid = open_file->netfid;
984 __u32 npid = open_file->pid;
985 read_unlock(&GlobalSMBSeslock);
986 found = TRUE;
987 rc = CIFSSMBSetFileSize(xid, pTcon,
988 attrs->ia_size, nfid, npid,
989 FALSE);
990 cFYI(1, ("SetFileSize by handle "
991 "(setattrs) rc = %d", rc));
992 /* Do not need reopen and retry on
993 EAGAIN since we will retry by
994 pathname below */
995
996 /* now that we found one valid file
997 handle no sense continuing to loop
998 trying others, so break here */
999 break;
1000 }
1001 }
1002 }
1003 if (found == FALSE)
1004 read_unlock(&GlobalSMBSeslock);
1005
1006 if (rc != 0) {
1007 /* Set file size by pathname rather than by handle
1008 either because no valid, writeable file handle for
1009 it was found or because there was an error setting
1010 it by handle */
1011 rc = CIFSSMBSetEOF(xid, pTcon, full_path,
1012 attrs->ia_size, FALSE,
737b758c
SF		 1013 cifs_sb->local_nls,
1014 cifs_sb->mnt_cifs_flags &
1015 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 1016 cFYI(1, (" SetEOF by path (setattrs) rc = %d", rc));
1017 }
1018
1019 /* Server is ok setting allocation size implicitly - no need
1020 to call:
1021 CIFSSMBSetEOF(xid, pTcon, full_path, attrs->ia_size, TRUE,
1022 cifs_sb->local_nls);
1023 */
1024
1025 if (rc == 0) {
1026 rc = vmtruncate(direntry->d_inode, attrs->ia_size);
1027 cifs_truncate_page(direntry->d_inode->i_mapping,
1028 direntry->d_inode->i_size);
1029 }
1030 }
1031 if (attrs->ia_valid & ATTR_UID) {
1032 cFYI(1, (" CIFS - UID changed to %d", attrs->ia_uid));
1033 uid = attrs->ia_uid;
1034 /* entry->uid = cpu_to_le16(attr->ia_uid); */
1035 }
1036 if (attrs->ia_valid & ATTR_GID) {
1037 cFYI(1, (" CIFS - GID changed to %d", attrs->ia_gid));
1038 gid = attrs->ia_gid;
1039 /* entry->gid = cpu_to_le16(attr->ia_gid); */
1040 }
1041
1042 time_buf.Attributes = 0;
1043 if (attrs->ia_valid & ATTR_MODE) {
1044 cFYI(1, (" CIFS - Mode changed to 0x%x", attrs->ia_mode));
1045 mode = attrs->ia_mode;
1046 /* entry->mode = cpu_to_le16(attr->ia_mode); */
1047 }
1048
1049 if ((cifs_sb->tcon->ses->capabilities & CAP_UNIX)
1050 && (attrs->ia_valid & (ATTR_MODE | ATTR_GID | ATTR_UID)))
1051 rc = CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode, uid, gid,
737b758c
SF		 1052 0 /* dev_t */, cifs_sb->local_nls,
1053 cifs_sb->mnt_cifs_flags &
1054 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 1055 else if (attrs->ia_valid & ATTR_MODE) {
1056 if ((mode & S_IWUGO) == 0) /* not writeable */ {
1057 if ((cifsInode->cifsAttrs & ATTR_READONLY) == 0)
1058 time_buf.Attributes =
1059 cpu_to_le32(cifsInode->cifsAttrs |
1060 ATTR_READONLY);
1061 } else if ((mode & S_IWUGO) == S_IWUGO) {
1062 if (cifsInode->cifsAttrs & ATTR_READONLY)
1063 time_buf.Attributes =
1064 cpu_to_le32(cifsInode->cifsAttrs &
1065 (~ATTR_READONLY));
1066 }
1067 /* BB to be implemented -
1068 via Windows security descriptors or streams */
1069 /* CIFSSMBWinSetPerms(xid, pTcon, full_path, mode, uid, gid,
1070 cifs_sb->local_nls); */
1071 }
1072
1073 if (attrs->ia_valid & ATTR_ATIME) {
1074 set_time = TRUE;
1075 time_buf.LastAccessTime =
1076 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_atime));
1077 } else
1078 time_buf.LastAccessTime = 0;
1079
1080 if (attrs->ia_valid & ATTR_MTIME) {
1081 set_time = TRUE;
1082 time_buf.LastWriteTime =
1083 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_mtime));
1084 } else
1085 time_buf.LastWriteTime = 0;
1086
1087 if (attrs->ia_valid & ATTR_CTIME) {
1088 set_time = TRUE;
1089 cFYI(1, (" CIFS - CTIME changed ")); /* BB probably no need */
1090 time_buf.ChangeTime =
1091 cpu_to_le64(cifs_UnixTimeToNT(attrs->ia_ctime));
1092 } else
1093 time_buf.ChangeTime = 0;
1094
1095 if (set_time || time_buf.Attributes) {
1096 /* BB what if setting one attribute fails (such as size) but
1097 time setting works? */
1098 time_buf.CreationTime = 0; /* do not change */
1099 /* In the future we should experiment - try setting timestamps
1100 via Handle (SetFileInfo) instead of by path */
1101 if (!(pTcon->ses->flags & CIFS_SES_NT4))
1102 rc = CIFSSMBSetTimes(xid, pTcon, full_path, &time_buf,
737b758c
SF		 1103 cifs_sb->local_nls,
1104 cifs_sb->mnt_cifs_flags &
1105 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 1106 else
1107 rc = -EOPNOTSUPP;
1108
1109 if (rc == -EOPNOTSUPP) {
1110 int oplock = FALSE;
1111 __u16 netfid;
1112
1113 cFYI(1, ("calling SetFileInfo since SetPathInfo for "
1114 "times not supported by this server"));
1115 /* BB we could scan to see if we already have it open
1116 and pass in pid of opener to function */
1117 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_OPEN,
1118 SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
1119 CREATE_NOT_DIR, &netfid, &oplock,
737b758c
SF		 1120 NULL, cifs_sb->local_nls,
1121 cifs_sb->mnt_cifs_flags &
1122 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 1123 if (rc==0) {
1124 rc = CIFSSMBSetFileTimes(xid, pTcon, &time_buf,
1125 netfid);
1126 CIFSSMBClose(xid, pTcon, netfid);
1127 } else {
1128 /* BB For even older servers we could convert time_buf
1129 into old DOS style which uses two second
1130 granularity */
1131
1132 /* rc = CIFSSMBSetTimesLegacy(xid, pTcon, full_path,
1133 &time_buf, cifs_sb->local_nls); */
1134 }
1135 }
1136 }
1137
1138 /* do not need local check to inode_check_ok since the server does
1139 that */
1140 if (!rc)
1141 rc = inode_setattr(direntry->d_inode, attrs);
1142 kfree(full_path);
1143 FreeXid(xid);
1144 return rc;
1145}
1146
1147void cifs_delete_inode(struct inode *inode)
1148{
1149 cFYI(1, ("In cifs_delete_inode, inode = 0x%p ", inode));
1150 /* may have to add back in if and when safe distributed caching of
1151 directories added e.g. via FindNotify */
1152}
kernel source for telekom puls (alcatel/mediatek)