4 * vfs operations that deal with dentries
6 * Copyright (C) International Business Machines Corp., 2002,2008
7 * Author(s): Steve French (sfrench@us.ibm.com)
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/stat.h>
25 #include <linux/slab.h>
26 #include <linux/namei.h>
30 #include "cifsproto.h"
31 #include "cifs_debug.h"
32 #include "cifs_fs_sb.h"
35 renew_parental_timestamps(struct dentry
*direntry
)
37 /* BB check if there is a way to get the kernel to do this or if we
40 direntry
->d_time
= jiffies
;
41 direntry
= direntry
->d_parent
;
42 } while (!IS_ROOT(direntry
));
45 /* Note: caller must free return buffer */
47 build_path_from_dentry(struct dentry
*direntry
)
56 return NULL
; /* not much we can do if dentry is freed and
57 we need to reopen the file after it was closed implicitly
58 when the server crashed */
60 dirsep
= CIFS_DIR_SEP(CIFS_SB(direntry
->d_sb
));
61 pplen
= CIFS_SB(direntry
->d_sb
)->prepathlen
;
64 for (temp
= direntry
; !IS_ROOT(temp
);) {
65 namelen
+= (1 + temp
->d_name
.len
);
66 temp
= temp
->d_parent
;
68 cERROR(1, ("corrupt dentry"));
73 full_path
= kmalloc(namelen
+1, GFP_KERNEL
);
74 if (full_path
== NULL
)
76 full_path
[namelen
] = 0; /* trailing null */
77 for (temp
= direntry
; !IS_ROOT(temp
);) {
78 namelen
-= 1 + temp
->d_name
.len
;
82 full_path
[namelen
] = dirsep
;
83 strncpy(full_path
+ namelen
+ 1, temp
->d_name
.name
,
85 cFYI(0, ("name: %s", full_path
+ namelen
));
87 temp
= temp
->d_parent
;
89 cERROR(1, ("corrupt dentry"));
94 if (namelen
!= pplen
) {
96 ("did not end path lookup where expected namelen is %d",
98 /* presumably this is only possible if racing with a rename
99 of one of the parent directories (we can not lock the dentries
100 above us to prevent this, but retrying should be harmless) */
102 goto cifs_bp_rename_retry
;
104 /* DIR_SEP already set for byte 0 / vs \ but not for
105 subsequent slashes in prepath which currently must
106 be entered the right way - not sure if there is an alternative
107 since the '\' is a valid posix character so we can not switch
108 those safely to '/' if any are found in the middle of the prepath */
109 /* BB test paths to Windows with '/' in the midst of prepath */
110 strncpy(full_path
, CIFS_SB(direntry
->d_sb
)->prepath
, pplen
);
114 /* Inode operations in similar order to how they appear in Linux file fs.h */
117 cifs_create(struct inode
*inode
, struct dentry
*direntry
, int mode
,
118 struct nameidata
*nd
)
122 int create_options
= CREATE_NOT_DIR
;
124 int desiredAccess
= GENERIC_READ
| GENERIC_WRITE
;
126 struct cifs_sb_info
*cifs_sb
;
127 struct cifsTconInfo
*pTcon
;
128 char *full_path
= NULL
;
129 FILE_ALL_INFO
*buf
= NULL
;
130 struct inode
*newinode
= NULL
;
131 struct cifsFileInfo
*pCifsFile
= NULL
;
132 struct cifsInodeInfo
*pCifsInode
;
133 int disposition
= FILE_OVERWRITE_IF
;
134 bool write_only
= false;
138 cifs_sb
= CIFS_SB(inode
->i_sb
);
139 pTcon
= cifs_sb
->tcon
;
141 full_path
= build_path_from_dentry(direntry
);
142 if (full_path
== NULL
) {
147 if (nd
&& (nd
->flags
& LOOKUP_OPEN
)) {
148 int oflags
= nd
->intent
.open
.flags
;
151 if (oflags
& FMODE_READ
)
152 desiredAccess
|= GENERIC_READ
;
153 if (oflags
& FMODE_WRITE
) {
154 desiredAccess
|= GENERIC_WRITE
;
155 if (!(oflags
& FMODE_READ
))
159 if ((oflags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
160 disposition
= FILE_CREATE
;
161 else if ((oflags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
162 disposition
= FILE_OVERWRITE_IF
;
163 else if ((oflags
& O_CREAT
) == O_CREAT
)
164 disposition
= FILE_OPEN_IF
;
166 cFYI(1, ("Create flag not set in create function"));
169 /* BB add processing to set equivalent of mode - e.g. via CreateX with
174 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
181 mode
&= ~current
->fs
->umask
;
184 * if we're not using unix extensions, see if we need to set
185 * ATTR_READONLY on the create call
187 if (!pTcon
->unix_ext
&& (mode
& S_IWUGO
) == 0)
188 create_options
|= CREATE_OPTION_READONLY
;
190 if (cifs_sb
->tcon
->ses
->capabilities
& CAP_NT_SMBS
)
191 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
, disposition
,
192 desiredAccess
, create_options
,
193 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
194 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
196 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
199 /* old server, retry the open legacy style */
200 rc
= SMBLegacyOpen(xid
, pTcon
, full_path
, disposition
,
201 desiredAccess
, create_options
,
202 &fileHandle
, &oplock
, buf
, cifs_sb
->local_nls
,
203 cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MAP_SPECIAL_CHR
);
206 cFYI(1, ("cifs_create returned 0x%x", rc
));
208 /* If Open reported that we actually created a file
209 then we now have to set the mode if possible */
210 if ((pTcon
->unix_ext
) && (oplock
& CIFS_CREATE_ACTION
)) {
211 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
212 CIFSSMBUnixSetPerms(xid
, pTcon
, full_path
, mode
,
213 (__u64
)current
->fsuid
,
214 (__u64
)current
->fsgid
,
217 cifs_sb
->mnt_cifs_flags
&
218 CIFS_MOUNT_MAP_SPECIAL_CHR
);
220 CIFSSMBUnixSetPerms(xid
, pTcon
, full_path
, mode
,
225 cifs_sb
->mnt_cifs_flags
&
226 CIFS_MOUNT_MAP_SPECIAL_CHR
);
229 /* BB implement mode setting via Windows security
231 /* CIFSSMBWinSetPerms(xid,pTcon,path,mode,-1,-1,nls);*/
233 /* Could set r/o dos attribute if mode & 0222 == 0 */
236 /* server might mask mode so we have to query for it */
238 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
241 rc
= cifs_get_inode_info(&newinode
, full_path
,
242 buf
, inode
->i_sb
, xid
,
245 newinode
->i_mode
= mode
;
246 if ((oplock
& CIFS_CREATE_ACTION
) &&
247 (cifs_sb
->mnt_cifs_flags
&
248 CIFS_MOUNT_SET_UID
)) {
249 newinode
->i_uid
= current
->fsuid
;
250 newinode
->i_gid
= current
->fsgid
;
257 ("Create worked but get_inode_info failed rc = %d",
261 direntry
->d_op
= &cifs_ci_dentry_ops
;
263 direntry
->d_op
= &cifs_dentry_ops
;
264 d_instantiate(direntry
, newinode
);
266 if ((nd
== NULL
/* nfsd case - nfs srv does not set nd */) ||
267 (!(nd
->flags
& LOOKUP_OPEN
))) {
268 /* mknod case - do not leave file open */
269 CIFSSMBClose(xid
, pTcon
, fileHandle
);
270 } else if (newinode
) {
272 kzalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
274 if (pCifsFile
== NULL
)
275 goto cifs_create_out
;
276 pCifsFile
->netfid
= fileHandle
;
277 pCifsFile
->pid
= current
->tgid
;
278 pCifsFile
->pInode
= newinode
;
279 pCifsFile
->invalidHandle
= false;
280 pCifsFile
->closePend
= false;
281 init_MUTEX(&pCifsFile
->fh_sem
);
282 mutex_init(&pCifsFile
->lock_mutex
);
283 INIT_LIST_HEAD(&pCifsFile
->llist
);
284 atomic_set(&pCifsFile
->wrtPending
, 0);
286 /* set the following in open now
287 pCifsFile->pfile = file; */
288 write_lock(&GlobalSMBSeslock
);
289 list_add(&pCifsFile
->tlist
, &pTcon
->openFileList
);
290 pCifsInode
= CIFS_I(newinode
);
292 /* if readable file instance put first in list*/
294 list_add_tail(&pCifsFile
->flist
,
295 &pCifsInode
->openFileList
);
297 list_add(&pCifsFile
->flist
,
298 &pCifsInode
->openFileList
);
300 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
301 pCifsInode
->clientCanCacheAll
= true;
302 pCifsInode
->clientCanCacheRead
= true;
303 cFYI(1, ("Exclusive Oplock inode %p",
305 } else if ((oplock
& 0xF) == OPLOCK_READ
)
306 pCifsInode
->clientCanCacheRead
= true;
308 write_unlock(&GlobalSMBSeslock
);
318 int cifs_mknod(struct inode
*inode
, struct dentry
*direntry
, int mode
,
323 struct cifs_sb_info
*cifs_sb
;
324 struct cifsTconInfo
*pTcon
;
325 char *full_path
= NULL
;
326 struct inode
*newinode
= NULL
;
328 if (!old_valid_dev(device_number
))
333 cifs_sb
= CIFS_SB(inode
->i_sb
);
334 pTcon
= cifs_sb
->tcon
;
336 full_path
= build_path_from_dentry(direntry
);
337 if (full_path
== NULL
)
339 else if (pTcon
->unix_ext
) {
340 mode
&= ~current
->fs
->umask
;
341 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_SET_UID
) {
342 rc
= CIFSSMBUnixSetPerms(xid
, pTcon
, full_path
,
343 mode
, (__u64
)current
->fsuid
,
344 (__u64
)current
->fsgid
,
345 device_number
, cifs_sb
->local_nls
,
346 cifs_sb
->mnt_cifs_flags
&
347 CIFS_MOUNT_MAP_SPECIAL_CHR
);
349 rc
= CIFSSMBUnixSetPerms(xid
, pTcon
,
350 full_path
, mode
, (__u64
)-1, (__u64
)-1,
351 device_number
, cifs_sb
->local_nls
,
352 cifs_sb
->mnt_cifs_flags
&
353 CIFS_MOUNT_MAP_SPECIAL_CHR
);
357 rc
= cifs_get_inode_info_unix(&newinode
, full_path
,
360 direntry
->d_op
= &cifs_ci_dentry_ops
;
362 direntry
->d_op
= &cifs_dentry_ops
;
364 d_instantiate(direntry
, newinode
);
367 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_UNX_EMUL
) {
372 cFYI(1, ("sfu compat create special file"));
374 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
381 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
,
382 FILE_CREATE
, /* fail if exists */
383 GENERIC_WRITE
/* BB would
384 WRITE_OWNER | WRITE_DAC be better? */,
385 /* Create a file and set the
386 file attribute to SYSTEM */
387 CREATE_NOT_DIR
| CREATE_OPTION_SPECIAL
,
388 &fileHandle
, &oplock
, buf
,
390 cifs_sb
->mnt_cifs_flags
&
391 CIFS_MOUNT_MAP_SPECIAL_CHR
);
393 /* BB FIXME - add handling for backlevel servers
394 which need legacy open and check for all
395 calls to SMBOpen for fallback to SMBLeagcyOpen */
397 /* BB Do not bother to decode buf since no
398 local inode yet to put timestamps in,
399 but we can reuse it safely */
400 unsigned int bytes_written
;
401 struct win_dev
*pdev
;
402 pdev
= (struct win_dev
*)buf
;
404 memcpy(pdev
->type
, "IntxCHR", 8);
406 cpu_to_le64(MAJOR(device_number
));
408 cpu_to_le64(MINOR(device_number
));
409 rc
= CIFSSMBWrite(xid
, pTcon
,
411 sizeof(struct win_dev
),
412 0, &bytes_written
, (char *)pdev
,
414 } else if (S_ISBLK(mode
)) {
415 memcpy(pdev
->type
, "IntxBLK", 8);
417 cpu_to_le64(MAJOR(device_number
));
419 cpu_to_le64(MINOR(device_number
));
420 rc
= CIFSSMBWrite(xid
, pTcon
,
422 sizeof(struct win_dev
),
423 0, &bytes_written
, (char *)pdev
,
425 } /* else if(S_ISFIFO */
426 CIFSSMBClose(xid
, pTcon
, fileHandle
);
430 /* add code here to set EAs */
441 cifs_lookup(struct inode
*parent_dir_inode
, struct dentry
*direntry
,
442 struct nameidata
*nd
)
445 int rc
= 0; /* to get around spurious gcc warning, set to zero here */
446 struct cifs_sb_info
*cifs_sb
;
447 struct cifsTconInfo
*pTcon
;
448 struct inode
*newInode
= NULL
;
449 char *full_path
= NULL
;
453 cFYI(1, (" parent inode = 0x%p name is: %s and dentry = 0x%p",
454 parent_dir_inode
, direntry
->d_name
.name
, direntry
));
456 /* check whether path exists */
458 cifs_sb
= CIFS_SB(parent_dir_inode
->i_sb
);
459 pTcon
= cifs_sb
->tcon
;
462 * Don't allow the separator character in a path component.
463 * The VFS will not allow "/", but "\" is allowed by posix.
465 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_POSIX_PATHS
)) {
467 for (i
= 0; i
< direntry
->d_name
.len
; i
++)
468 if (direntry
->d_name
.name
[i
] == '\\') {
469 cFYI(1, ("Invalid file name"));
471 return ERR_PTR(-EINVAL
);
475 /* can not grab the rename sem here since it would
476 deadlock in the cases (beginning of sys_rename itself)
477 in which we already have the sb rename sem */
478 full_path
= build_path_from_dentry(direntry
);
479 if (full_path
== NULL
) {
481 return ERR_PTR(-ENOMEM
);
484 if (direntry
->d_inode
!= NULL
) {
485 cFYI(1, (" non-NULL inode in lookup"));
487 cFYI(1, (" NULL inode in lookup"));
490 (" Full path: %s inode = 0x%p", full_path
, direntry
->d_inode
));
493 rc
= cifs_get_inode_info_unix(&newInode
, full_path
,
494 parent_dir_inode
->i_sb
, xid
);
496 rc
= cifs_get_inode_info(&newInode
, full_path
, NULL
,
497 parent_dir_inode
->i_sb
, xid
, NULL
);
499 if ((rc
== 0) && (newInode
!= NULL
)) {
501 direntry
->d_op
= &cifs_ci_dentry_ops
;
503 direntry
->d_op
= &cifs_dentry_ops
;
504 d_add(direntry
, newInode
);
506 /* since paths are not looked up by component - the parent
507 directories are presumed to be good here */
508 renew_parental_timestamps(direntry
);
510 } else if (rc
== -ENOENT
) {
512 direntry
->d_time
= jiffies
;
514 direntry
->d_op
= &cifs_ci_dentry_ops
;
516 direntry
->d_op
= &cifs_dentry_ops
;
517 d_add(direntry
, NULL
);
518 /* if it was once a directory (but how can we tell?) we could do
519 shrink_dcache_parent(direntry); */
520 } else if (rc
!= -EACCES
) {
521 cERROR(1, ("Unexpected lookup error %d", rc
));
522 /* We special case check for Access Denied - since that
523 is a common return code */
532 cifs_d_revalidate(struct dentry
*direntry
, struct nameidata
*nd
)
536 if (direntry
->d_inode
) {
537 if (cifs_revalidate(direntry
))
540 cFYI(1, ("neg dentry 0x%p name = %s",
541 direntry
, direntry
->d_name
.name
));
542 if (time_after(jiffies
, direntry
->d_time
+ HZ
) ||
543 !lookupCacheEnabled
) {
552 /* static int cifs_d_delete(struct dentry *direntry)
556 cFYI(1, ("In cifs d_delete, name = %s", direntry->d_name.name));
561 struct dentry_operations cifs_dentry_ops
= {
562 .d_revalidate
= cifs_d_revalidate
,
563 /* d_delete: cifs_d_delete, */ /* not needed except for debugging */
566 static int cifs_ci_hash(struct dentry
*dentry
, struct qstr
*q
)
568 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
572 hash
= init_name_hash();
573 for (i
= 0; i
< q
->len
; i
++)
574 hash
= partial_name_hash(nls_tolower(codepage
, q
->name
[i
]),
576 q
->hash
= end_name_hash(hash
);
581 static int cifs_ci_compare(struct dentry
*dentry
, struct qstr
*a
,
584 struct nls_table
*codepage
= CIFS_SB(dentry
->d_inode
->i_sb
)->local_nls
;
586 if ((a
->len
== b
->len
) &&
587 (nls_strnicmp(codepage
, a
->name
, b
->name
, a
->len
) == 0)) {
589 * To preserve case, don't let an existing negative dentry's
590 * case take precedence. If a is not a negative dentry, this
591 * should have no side effects
593 memcpy(a
->name
, b
->name
, a
->len
);
599 struct dentry_operations cifs_ci_dentry_ops
= {
600 .d_revalidate
= cifs_d_revalidate
,
601 .d_hash
= cifs_ci_hash
,
602 .d_compare
= cifs_ci_compare
,