Loading...
1/*
2 * fs/cifs/dir.c
3 *
4 * vfs operations that deal with dentries
5 *
6 * Copyright (C) International Business Machines Corp., 2002,2009
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 *
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.
13 *
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.
18 *
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
22 */
23#include <linux/fs.h>
24#include <linux/stat.h>
25#include <linux/slab.h>
26#include <linux/namei.h>
27#include <linux/mount.h>
28#include <linux/file.h>
29#include "cifsfs.h"
30#include "cifspdu.h"
31#include "cifsglob.h"
32#include "cifsproto.h"
33#include "cifs_debug.h"
34#include "cifs_fs_sb.h"
35
36static void
37renew_parental_timestamps(struct dentry *direntry)
38{
39 /* BB check if there is a way to get the kernel to do this or if we
40 really need this */
41 do {
42 direntry->d_time = jiffies;
43 direntry = direntry->d_parent;
44 } while (!IS_ROOT(direntry));
45}
46
47/* Note: caller must free return buffer */
48char *
49build_path_from_dentry(struct dentry *direntry)
50{
51 struct dentry *temp;
52 int namelen;
53 int dfsplen;
54 char *full_path;
55 char dirsep;
56 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
57 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
58 unsigned seq;
59
60 dirsep = CIFS_DIR_SEP(cifs_sb);
61 if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
62 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
63 else
64 dfsplen = 0;
65cifs_bp_rename_retry:
66 namelen = dfsplen;
67 seq = read_seqbegin(&rename_lock);
68 rcu_read_lock();
69 for (temp = direntry; !IS_ROOT(temp);) {
70 namelen += (1 + temp->d_name.len);
71 temp = temp->d_parent;
72 if (temp == NULL) {
73 cERROR(1, "corrupt dentry");
74 rcu_read_unlock();
75 return NULL;
76 }
77 }
78 rcu_read_unlock();
79
80 full_path = kmalloc(namelen+1, GFP_KERNEL);
81 if (full_path == NULL)
82 return full_path;
83 full_path[namelen] = 0; /* trailing null */
84 rcu_read_lock();
85 for (temp = direntry; !IS_ROOT(temp);) {
86 spin_lock(&temp->d_lock);
87 namelen -= 1 + temp->d_name.len;
88 if (namelen < 0) {
89 spin_unlock(&temp->d_lock);
90 break;
91 } else {
92 full_path[namelen] = dirsep;
93 strncpy(full_path + namelen + 1, temp->d_name.name,
94 temp->d_name.len);
95 cFYI(0, "name: %s", full_path + namelen);
96 }
97 spin_unlock(&temp->d_lock);
98 temp = temp->d_parent;
99 if (temp == NULL) {
100 cERROR(1, "corrupt dentry");
101 rcu_read_unlock();
102 kfree(full_path);
103 return NULL;
104 }
105 }
106 rcu_read_unlock();
107 if (namelen != dfsplen || read_seqretry(&rename_lock, seq)) {
108 cFYI(1, "did not end path lookup where expected. namelen=%d "
109 "dfsplen=%d", namelen, dfsplen);
110 /* presumably this is only possible if racing with a rename
111 of one of the parent directories (we can not lock the dentries
112 above us to prevent this, but retrying should be harmless) */
113 kfree(full_path);
114 goto cifs_bp_rename_retry;
115 }
116 /* DIR_SEP already set for byte 0 / vs \ but not for
117 subsequent slashes in prepath which currently must
118 be entered the right way - not sure if there is an alternative
119 since the '\' is a valid posix character so we can not switch
120 those safely to '/' if any are found in the middle of the prepath */
121 /* BB test paths to Windows with '/' in the midst of prepath */
122
123 if (dfsplen) {
124 strncpy(full_path, tcon->treeName, dfsplen);
125 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
126 int i;
127 for (i = 0; i < dfsplen; i++) {
128 if (full_path[i] == '\\')
129 full_path[i] = '/';
130 }
131 }
132 }
133 return full_path;
134}
135
136/* Inode operations in similar order to how they appear in Linux file fs.h */
137
138int
139cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
140 struct nameidata *nd)
141{
142 int rc = -ENOENT;
143 int xid;
144 int create_options = CREATE_NOT_DIR;
145 __u32 oplock = 0;
146 int oflags;
147 /*
148 * BB below access is probably too much for mknod to request
149 * but we have to do query and setpathinfo so requesting
150 * less could fail (unless we want to request getatr and setatr
151 * permissions (only). At least for POSIX we do not have to
152 * request so much.
153 */
154 int desiredAccess = GENERIC_READ | GENERIC_WRITE;
155 __u16 fileHandle;
156 struct cifs_sb_info *cifs_sb;
157 struct tcon_link *tlink;
158 struct cifs_tcon *tcon;
159 char *full_path = NULL;
160 FILE_ALL_INFO *buf = NULL;
161 struct inode *newinode = NULL;
162 int disposition = FILE_OVERWRITE_IF;
163
164 xid = GetXid();
165
166 cifs_sb = CIFS_SB(inode->i_sb);
167 tlink = cifs_sb_tlink(cifs_sb);
168 if (IS_ERR(tlink)) {
169 FreeXid(xid);
170 return PTR_ERR(tlink);
171 }
172 tcon = tlink_tcon(tlink);
173
174 if (tcon->ses->server->oplocks)
175 oplock = REQ_OPLOCK;
176
177 if (nd)
178 oflags = nd->intent.open.file->f_flags;
179 else
180 oflags = O_RDONLY | O_CREAT;
181
182 full_path = build_path_from_dentry(direntry);
183 if (full_path == NULL) {
184 rc = -ENOMEM;
185 goto cifs_create_out;
186 }
187
188 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
189 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
190 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
191 rc = cifs_posix_open(full_path, &newinode,
192 inode->i_sb, mode, oflags, &oplock, &fileHandle, xid);
193 /* EIO could indicate that (posix open) operation is not
194 supported, despite what server claimed in capability
195 negotiation. EREMOTE indicates DFS junction, which is not
196 handled in posix open */
197
198 if (rc == 0) {
199 if (newinode == NULL) /* query inode info */
200 goto cifs_create_get_file_info;
201 else /* success, no need to query */
202 goto cifs_create_set_dentry;
203 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
204 (rc != -EOPNOTSUPP) && (rc != -EINVAL))
205 goto cifs_create_out;
206 /* else fallthrough to retry, using older open call, this is
207 case where server does not support this SMB level, and
208 falsely claims capability (also get here for DFS case
209 which should be rare for path not covered on files) */
210 }
211
212 if (nd) {
213 /* if the file is going to stay open, then we
214 need to set the desired access properly */
215 desiredAccess = 0;
216 if (OPEN_FMODE(oflags) & FMODE_READ)
217 desiredAccess |= GENERIC_READ; /* is this too little? */
218 if (OPEN_FMODE(oflags) & FMODE_WRITE)
219 desiredAccess |= GENERIC_WRITE;
220
221 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
222 disposition = FILE_CREATE;
223 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
224 disposition = FILE_OVERWRITE_IF;
225 else if ((oflags & O_CREAT) == O_CREAT)
226 disposition = FILE_OPEN_IF;
227 else
228 cFYI(1, "Create flag not set in create function");
229 }
230
231 /* BB add processing to set equivalent of mode - e.g. via CreateX with
232 ACLs */
233
234 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
235 if (buf == NULL) {
236 rc = -ENOMEM;
237 goto cifs_create_out;
238 }
239
240 /*
241 * if we're not using unix extensions, see if we need to set
242 * ATTR_READONLY on the create call
243 */
244 if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
245 create_options |= CREATE_OPTION_READONLY;
246
247 if (backup_cred(cifs_sb))
248 create_options |= CREATE_OPEN_BACKUP_INTENT;
249
250 if (tcon->ses->capabilities & CAP_NT_SMBS)
251 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
252 desiredAccess, create_options,
253 &fileHandle, &oplock, buf, cifs_sb->local_nls,
254 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
255 else
256 rc = -EIO; /* no NT SMB support fall into legacy open below */
257
258 if (rc == -EIO) {
259 /* old server, retry the open legacy style */
260 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
261 desiredAccess, create_options,
262 &fileHandle, &oplock, buf, cifs_sb->local_nls,
263 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
264 }
265 if (rc) {
266 cFYI(1, "cifs_create returned 0x%x", rc);
267 goto cifs_create_out;
268 }
269
270 /* If Open reported that we actually created a file
271 then we now have to set the mode if possible */
272 if ((tcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
273 struct cifs_unix_set_info_args args = {
274 .mode = mode,
275 .ctime = NO_CHANGE_64,
276 .atime = NO_CHANGE_64,
277 .mtime = NO_CHANGE_64,
278 .device = 0,
279 };
280
281 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
282 args.uid = (__u64) current_fsuid();
283 if (inode->i_mode & S_ISGID)
284 args.gid = (__u64) inode->i_gid;
285 else
286 args.gid = (__u64) current_fsgid();
287 } else {
288 args.uid = NO_CHANGE_64;
289 args.gid = NO_CHANGE_64;
290 }
291 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fileHandle,
292 current->tgid);
293 } else {
294 /* BB implement mode setting via Windows security
295 descriptors e.g. */
296 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
297
298 /* Could set r/o dos attribute if mode & 0222 == 0 */
299 }
300
301cifs_create_get_file_info:
302 /* server might mask mode so we have to query for it */
303 if (tcon->unix_ext)
304 rc = cifs_get_inode_info_unix(&newinode, full_path,
305 inode->i_sb, xid);
306 else {
307 rc = cifs_get_inode_info(&newinode, full_path, buf,
308 inode->i_sb, xid, &fileHandle);
309 if (newinode) {
310 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
311 newinode->i_mode = mode;
312 if ((oplock & CIFS_CREATE_ACTION) &&
313 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
314 newinode->i_uid = current_fsuid();
315 if (inode->i_mode & S_ISGID)
316 newinode->i_gid = inode->i_gid;
317 else
318 newinode->i_gid = current_fsgid();
319 }
320 }
321 }
322
323cifs_create_set_dentry:
324 if (rc == 0)
325 d_instantiate(direntry, newinode);
326 else
327 cFYI(1, "Create worked, get_inode_info failed rc = %d", rc);
328
329 if (newinode && nd) {
330 struct cifsFileInfo *pfile_info;
331 struct file *filp;
332
333 filp = lookup_instantiate_filp(nd, direntry, generic_file_open);
334 if (IS_ERR(filp)) {
335 rc = PTR_ERR(filp);
336 CIFSSMBClose(xid, tcon, fileHandle);
337 goto cifs_create_out;
338 }
339
340 pfile_info = cifs_new_fileinfo(fileHandle, filp, tlink, oplock);
341 if (pfile_info == NULL) {
342 fput(filp);
343 CIFSSMBClose(xid, tcon, fileHandle);
344 rc = -ENOMEM;
345 }
346 } else {
347 CIFSSMBClose(xid, tcon, fileHandle);
348 }
349
350cifs_create_out:
351 kfree(buf);
352 kfree(full_path);
353 cifs_put_tlink(tlink);
354 FreeXid(xid);
355 return rc;
356}
357
358int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
359 dev_t device_number)
360{
361 int rc = -EPERM;
362 int xid;
363 int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;
364 struct cifs_sb_info *cifs_sb;
365 struct tcon_link *tlink;
366 struct cifs_tcon *pTcon;
367 struct cifs_io_parms io_parms;
368 char *full_path = NULL;
369 struct inode *newinode = NULL;
370 int oplock = 0;
371 u16 fileHandle;
372 FILE_ALL_INFO *buf = NULL;
373 unsigned int bytes_written;
374 struct win_dev *pdev;
375
376 if (!old_valid_dev(device_number))
377 return -EINVAL;
378
379 cifs_sb = CIFS_SB(inode->i_sb);
380 tlink = cifs_sb_tlink(cifs_sb);
381 if (IS_ERR(tlink))
382 return PTR_ERR(tlink);
383
384 pTcon = tlink_tcon(tlink);
385
386 xid = GetXid();
387
388 full_path = build_path_from_dentry(direntry);
389 if (full_path == NULL) {
390 rc = -ENOMEM;
391 goto mknod_out;
392 }
393
394 if (pTcon->unix_ext) {
395 struct cifs_unix_set_info_args args = {
396 .mode = mode & ~current_umask(),
397 .ctime = NO_CHANGE_64,
398 .atime = NO_CHANGE_64,
399 .mtime = NO_CHANGE_64,
400 .device = device_number,
401 };
402 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
403 args.uid = (__u64) current_fsuid();
404 args.gid = (__u64) current_fsgid();
405 } else {
406 args.uid = NO_CHANGE_64;
407 args.gid = NO_CHANGE_64;
408 }
409 rc = CIFSSMBUnixSetPathInfo(xid, pTcon, full_path, &args,
410 cifs_sb->local_nls,
411 cifs_sb->mnt_cifs_flags &
412 CIFS_MOUNT_MAP_SPECIAL_CHR);
413 if (rc)
414 goto mknod_out;
415
416 rc = cifs_get_inode_info_unix(&newinode, full_path,
417 inode->i_sb, xid);
418
419 if (rc == 0)
420 d_instantiate(direntry, newinode);
421 goto mknod_out;
422 }
423
424 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
425 goto mknod_out;
426
427
428 cFYI(1, "sfu compat create special file");
429
430 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
431 if (buf == NULL) {
432 kfree(full_path);
433 rc = -ENOMEM;
434 FreeXid(xid);
435 return rc;
436 }
437
438 if (backup_cred(cifs_sb))
439 create_options |= CREATE_OPEN_BACKUP_INTENT;
440
441 rc = CIFSSMBOpen(xid, pTcon, full_path, FILE_CREATE,
442 GENERIC_WRITE, create_options,
443 &fileHandle, &oplock, buf, cifs_sb->local_nls,
444 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
445 if (rc)
446 goto mknod_out;
447
448 /* BB Do not bother to decode buf since no local inode yet to put
449 * timestamps in, but we can reuse it safely */
450
451 pdev = (struct win_dev *)buf;
452 io_parms.netfid = fileHandle;
453 io_parms.pid = current->tgid;
454 io_parms.tcon = pTcon;
455 io_parms.offset = 0;
456 io_parms.length = sizeof(struct win_dev);
457 if (S_ISCHR(mode)) {
458 memcpy(pdev->type, "IntxCHR", 8);
459 pdev->major =
460 cpu_to_le64(MAJOR(device_number));
461 pdev->minor =
462 cpu_to_le64(MINOR(device_number));
463 rc = CIFSSMBWrite(xid, &io_parms,
464 &bytes_written, (char *)pdev,
465 NULL, 0);
466 } else if (S_ISBLK(mode)) {
467 memcpy(pdev->type, "IntxBLK", 8);
468 pdev->major =
469 cpu_to_le64(MAJOR(device_number));
470 pdev->minor =
471 cpu_to_le64(MINOR(device_number));
472 rc = CIFSSMBWrite(xid, &io_parms,
473 &bytes_written, (char *)pdev,
474 NULL, 0);
475 } /* else if (S_ISFIFO) */
476 CIFSSMBClose(xid, pTcon, fileHandle);
477 d_drop(direntry);
478
479 /* FIXME: add code here to set EAs */
480
481mknod_out:
482 kfree(full_path);
483 kfree(buf);
484 FreeXid(xid);
485 cifs_put_tlink(tlink);
486 return rc;
487}
488
489struct dentry *
490cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
491 struct nameidata *nd)
492{
493 int xid;
494 int rc = 0; /* to get around spurious gcc warning, set to zero here */
495 __u32 oplock;
496 __u16 fileHandle = 0;
497 bool posix_open = false;
498 struct cifs_sb_info *cifs_sb;
499 struct tcon_link *tlink;
500 struct cifs_tcon *pTcon;
501 struct cifsFileInfo *cfile;
502 struct inode *newInode = NULL;
503 char *full_path = NULL;
504 struct file *filp;
505
506 xid = GetXid();
507
508 cFYI(1, "parent inode = 0x%p name is: %s and dentry = 0x%p",
509 parent_dir_inode, direntry->d_name.name, direntry);
510
511 /* check whether path exists */
512
513 cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
514 tlink = cifs_sb_tlink(cifs_sb);
515 if (IS_ERR(tlink)) {
516 FreeXid(xid);
517 return (struct dentry *)tlink;
518 }
519 pTcon = tlink_tcon(tlink);
520
521 oplock = pTcon->ses->server->oplocks ? REQ_OPLOCK : 0;
522
523 /*
524 * Don't allow the separator character in a path component.
525 * The VFS will not allow "/", but "\" is allowed by posix.
526 */
527 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
528 int i;
529 for (i = 0; i < direntry->d_name.len; i++)
530 if (direntry->d_name.name[i] == '\\') {
531 cFYI(1, "Invalid file name");
532 rc = -EINVAL;
533 goto lookup_out;
534 }
535 }
536
537 /*
538 * O_EXCL: optimize away the lookup, but don't hash the dentry. Let
539 * the VFS handle the create.
540 */
541 if (nd && (nd->flags & LOOKUP_EXCL)) {
542 d_instantiate(direntry, NULL);
543 rc = 0;
544 goto lookup_out;
545 }
546
547 /* can not grab the rename sem here since it would
548 deadlock in the cases (beginning of sys_rename itself)
549 in which we already have the sb rename sem */
550 full_path = build_path_from_dentry(direntry);
551 if (full_path == NULL) {
552 rc = -ENOMEM;
553 goto lookup_out;
554 }
555
556 if (direntry->d_inode != NULL) {
557 cFYI(1, "non-NULL inode in lookup");
558 } else {
559 cFYI(1, "NULL inode in lookup");
560 }
561 cFYI(1, "Full path: %s inode = 0x%p", full_path, direntry->d_inode);
562
563 /* Posix open is only called (at lookup time) for file create now.
564 * For opens (rather than creates), because we do not know if it
565 * is a file or directory yet, and current Samba no longer allows
566 * us to do posix open on dirs, we could end up wasting an open call
567 * on what turns out to be a dir. For file opens, we wait to call posix
568 * open till cifs_open. It could be added here (lookup) in the future
569 * but the performance tradeoff of the extra network request when EISDIR
570 * or EACCES is returned would have to be weighed against the 50%
571 * reduction in network traffic in the other paths.
572 */
573 if (pTcon->unix_ext) {
574 if (nd && !(nd->flags & LOOKUP_DIRECTORY) &&
575 (nd->flags & LOOKUP_OPEN) && !pTcon->broken_posix_open &&
576 (nd->intent.open.file->f_flags & O_CREAT)) {
577 rc = cifs_posix_open(full_path, &newInode,
578 parent_dir_inode->i_sb,
579 nd->intent.open.create_mode,
580 nd->intent.open.file->f_flags, &oplock,
581 &fileHandle, xid);
582 /*
583 * The check below works around a bug in POSIX
584 * open in samba versions 3.3.1 and earlier where
585 * open could incorrectly fail with invalid parameter.
586 * If either that or op not supported returned, follow
587 * the normal lookup.
588 */
589 switch (rc) {
590 case 0:
591 /*
592 * The server may allow us to open things like
593 * FIFOs, but the client isn't set up to deal
594 * with that. If it's not a regular file, just
595 * close it and proceed as if it were a normal
596 * lookup.
597 */
598 if (newInode && !S_ISREG(newInode->i_mode)) {
599 CIFSSMBClose(xid, pTcon, fileHandle);
600 break;
601 }
602 case -ENOENT:
603 posix_open = true;
604 case -EOPNOTSUPP:
605 break;
606 default:
607 pTcon->broken_posix_open = true;
608 }
609 }
610 if (!posix_open)
611 rc = cifs_get_inode_info_unix(&newInode, full_path,
612 parent_dir_inode->i_sb, xid);
613 } else
614 rc = cifs_get_inode_info(&newInode, full_path, NULL,
615 parent_dir_inode->i_sb, xid, NULL);
616
617 if ((rc == 0) && (newInode != NULL)) {
618 d_add(direntry, newInode);
619 if (posix_open) {
620 filp = lookup_instantiate_filp(nd, direntry,
621 generic_file_open);
622 if (IS_ERR(filp)) {
623 rc = PTR_ERR(filp);
624 CIFSSMBClose(xid, pTcon, fileHandle);
625 goto lookup_out;
626 }
627
628 cfile = cifs_new_fileinfo(fileHandle, filp, tlink,
629 oplock);
630 if (cfile == NULL) {
631 fput(filp);
632 CIFSSMBClose(xid, pTcon, fileHandle);
633 rc = -ENOMEM;
634 goto lookup_out;
635 }
636 }
637 /* since paths are not looked up by component - the parent
638 directories are presumed to be good here */
639 renew_parental_timestamps(direntry);
640
641 } else if (rc == -ENOENT) {
642 rc = 0;
643 direntry->d_time = jiffies;
644 d_add(direntry, NULL);
645 /* if it was once a directory (but how can we tell?) we could do
646 shrink_dcache_parent(direntry); */
647 } else if (rc != -EACCES) {
648 cERROR(1, "Unexpected lookup error %d", rc);
649 /* We special case check for Access Denied - since that
650 is a common return code */
651 }
652
653lookup_out:
654 kfree(full_path);
655 cifs_put_tlink(tlink);
656 FreeXid(xid);
657 return ERR_PTR(rc);
658}
659
660static int
661cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
662{
663 if (nd && (nd->flags & LOOKUP_RCU))
664 return -ECHILD;
665
666 if (direntry->d_inode) {
667 if (cifs_revalidate_dentry(direntry))
668 return 0;
669 else {
670 /*
671 * If the inode wasn't known to be a dfs entry when
672 * the dentry was instantiated, such as when created
673 * via ->readdir(), it needs to be set now since the
674 * attributes will have been updated by
675 * cifs_revalidate_dentry().
676 */
677 if (IS_AUTOMOUNT(direntry->d_inode) &&
678 !(direntry->d_flags & DCACHE_NEED_AUTOMOUNT)) {
679 spin_lock(&direntry->d_lock);
680 direntry->d_flags |= DCACHE_NEED_AUTOMOUNT;
681 spin_unlock(&direntry->d_lock);
682 }
683
684 return 1;
685 }
686 }
687
688 /*
689 * This may be nfsd (or something), anyway, we can't see the
690 * intent of this. So, since this can be for creation, drop it.
691 */
692 if (!nd)
693 return 0;
694
695 /*
696 * Drop the negative dentry, in order to make sure to use the
697 * case sensitive name which is specified by user if this is
698 * for creation.
699 */
700 if (nd->flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
701 return 0;
702
703 if (time_after(jiffies, direntry->d_time + HZ) || !lookupCacheEnabled)
704 return 0;
705
706 return 1;
707}
708
709/* static int cifs_d_delete(struct dentry *direntry)
710{
711 int rc = 0;
712
713 cFYI(1, "In cifs d_delete, name = %s", direntry->d_name.name);
714
715 return rc;
716} */
717
718const struct dentry_operations cifs_dentry_ops = {
719 .d_revalidate = cifs_d_revalidate,
720 .d_automount = cifs_dfs_d_automount,
721/* d_delete: cifs_d_delete, */ /* not needed except for debugging */
722};
723
724static int cifs_ci_hash(const struct dentry *dentry, const struct inode *inode,
725 struct qstr *q)
726{
727 struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
728 unsigned long hash;
729 int i;
730
731 hash = init_name_hash();
732 for (i = 0; i < q->len; i++)
733 hash = partial_name_hash(nls_tolower(codepage, q->name[i]),
734 hash);
735 q->hash = end_name_hash(hash);
736
737 return 0;
738}
739
740static int cifs_ci_compare(const struct dentry *parent,
741 const struct inode *pinode,
742 const struct dentry *dentry, const struct inode *inode,
743 unsigned int len, const char *str, const struct qstr *name)
744{
745 struct nls_table *codepage = CIFS_SB(pinode->i_sb)->local_nls;
746
747 if ((name->len == len) &&
748 (nls_strnicmp(codepage, name->name, str, len) == 0))
749 return 0;
750 return 1;
751}
752
753const struct dentry_operations cifs_ci_dentry_ops = {
754 .d_revalidate = cifs_d_revalidate,
755 .d_hash = cifs_ci_hash,
756 .d_compare = cifs_ci_compare,
757 .d_automount = cifs_dfs_d_automount,
758};
1/*
2 * fs/cifs/dir.c
3 *
4 * vfs operations that deal with dentries
5 *
6 * Copyright (C) International Business Machines Corp., 2002,2009
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 *
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.
13 *
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.
18 *
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
22 */
23#include <linux/fs.h>
24#include <linux/stat.h>
25#include <linux/slab.h>
26#include <linux/namei.h>
27#include <linux/mount.h>
28#include <linux/file.h>
29#include "cifsfs.h"
30#include "cifspdu.h"
31#include "cifsglob.h"
32#include "cifsproto.h"
33#include "cifs_debug.h"
34#include "cifs_fs_sb.h"
35#include "cifs_unicode.h"
36
37static void
38renew_parental_timestamps(struct dentry *direntry)
39{
40 /* BB check if there is a way to get the kernel to do this or if we
41 really need this */
42 do {
43 cifs_set_time(direntry, jiffies);
44 direntry = direntry->d_parent;
45 } while (!IS_ROOT(direntry));
46}
47
48char *
49cifs_build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
50 struct cifs_tcon *tcon, int add_treename)
51{
52 int pplen = vol->prepath ? strlen(vol->prepath) + 1 : 0;
53 int dfsplen;
54 char *full_path = NULL;
55
56 /* if no prefix path, simply set path to the root of share to "" */
57 if (pplen == 0) {
58 full_path = kzalloc(1, GFP_KERNEL);
59 return full_path;
60 }
61
62 if (add_treename)
63 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
64 else
65 dfsplen = 0;
66
67 full_path = kmalloc(dfsplen + pplen + 1, GFP_KERNEL);
68 if (full_path == NULL)
69 return full_path;
70
71 if (dfsplen)
72 strncpy(full_path, tcon->treeName, dfsplen);
73 full_path[dfsplen] = CIFS_DIR_SEP(cifs_sb);
74 strncpy(full_path + dfsplen + 1, vol->prepath, pplen);
75 convert_delimiter(full_path, CIFS_DIR_SEP(cifs_sb));
76 full_path[dfsplen + pplen] = 0; /* add trailing null */
77 return full_path;
78}
79
80/* Note: caller must free return buffer */
81char *
82build_path_from_dentry(struct dentry *direntry)
83{
84 struct dentry *temp;
85 int namelen;
86 int dfsplen;
87 int pplen = 0;
88 char *full_path;
89 char dirsep;
90 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
91 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
92 unsigned seq;
93
94 dirsep = CIFS_DIR_SEP(cifs_sb);
95 if (tcon->Flags & SMB_SHARE_IS_IN_DFS)
96 dfsplen = strnlen(tcon->treeName, MAX_TREE_SIZE + 1);
97 else
98 dfsplen = 0;
99
100 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_USE_PREFIX_PATH)
101 pplen = cifs_sb->prepath ? strlen(cifs_sb->prepath) + 1 : 0;
102
103cifs_bp_rename_retry:
104 namelen = dfsplen + pplen;
105 seq = read_seqbegin(&rename_lock);
106 rcu_read_lock();
107 for (temp = direntry; !IS_ROOT(temp);) {
108 namelen += (1 + temp->d_name.len);
109 temp = temp->d_parent;
110 if (temp == NULL) {
111 cifs_dbg(VFS, "corrupt dentry\n");
112 rcu_read_unlock();
113 return NULL;
114 }
115 }
116 rcu_read_unlock();
117
118 full_path = kmalloc(namelen+1, GFP_KERNEL);
119 if (full_path == NULL)
120 return full_path;
121 full_path[namelen] = 0; /* trailing null */
122 rcu_read_lock();
123 for (temp = direntry; !IS_ROOT(temp);) {
124 spin_lock(&temp->d_lock);
125 namelen -= 1 + temp->d_name.len;
126 if (namelen < 0) {
127 spin_unlock(&temp->d_lock);
128 break;
129 } else {
130 full_path[namelen] = dirsep;
131 strncpy(full_path + namelen + 1, temp->d_name.name,
132 temp->d_name.len);
133 cifs_dbg(FYI, "name: %s\n", full_path + namelen);
134 }
135 spin_unlock(&temp->d_lock);
136 temp = temp->d_parent;
137 if (temp == NULL) {
138 cifs_dbg(VFS, "corrupt dentry\n");
139 rcu_read_unlock();
140 kfree(full_path);
141 return NULL;
142 }
143 }
144 rcu_read_unlock();
145 if (namelen != dfsplen + pplen || read_seqretry(&rename_lock, seq)) {
146 cifs_dbg(FYI, "did not end path lookup where expected. namelen=%ddfsplen=%d\n",
147 namelen, dfsplen);
148 /* presumably this is only possible if racing with a rename
149 of one of the parent directories (we can not lock the dentries
150 above us to prevent this, but retrying should be harmless) */
151 kfree(full_path);
152 goto cifs_bp_rename_retry;
153 }
154 /* DIR_SEP already set for byte 0 / vs \ but not for
155 subsequent slashes in prepath which currently must
156 be entered the right way - not sure if there is an alternative
157 since the '\' is a valid posix character so we can not switch
158 those safely to '/' if any are found in the middle of the prepath */
159 /* BB test paths to Windows with '/' in the midst of prepath */
160
161 if (pplen) {
162 int i;
163
164 cifs_dbg(FYI, "using cifs_sb prepath <%s>\n", cifs_sb->prepath);
165 memcpy(full_path+dfsplen+1, cifs_sb->prepath, pplen-1);
166 full_path[dfsplen] = '\\';
167 for (i = 0; i < pplen-1; i++)
168 if (full_path[dfsplen+1+i] == '/')
169 full_path[dfsplen+1+i] = CIFS_DIR_SEP(cifs_sb);
170 }
171
172 if (dfsplen) {
173 strncpy(full_path, tcon->treeName, dfsplen);
174 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
175 int i;
176 for (i = 0; i < dfsplen; i++) {
177 if (full_path[i] == '\\')
178 full_path[i] = '/';
179 }
180 }
181 }
182 return full_path;
183}
184
185/*
186 * Don't allow the separator character in a path component.
187 * The VFS will not allow "/", but "\" is allowed by posix.
188 */
189static int
190check_name(struct dentry *direntry)
191{
192 struct cifs_sb_info *cifs_sb = CIFS_SB(direntry->d_sb);
193 int i;
194
195 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)) {
196 for (i = 0; i < direntry->d_name.len; i++) {
197 if (direntry->d_name.name[i] == '\\') {
198 cifs_dbg(FYI, "Invalid file name\n");
199 return -EINVAL;
200 }
201 }
202 }
203 return 0;
204}
205
206
207/* Inode operations in similar order to how they appear in Linux file fs.h */
208
209static int
210cifs_do_create(struct inode *inode, struct dentry *direntry, unsigned int xid,
211 struct tcon_link *tlink, unsigned oflags, umode_t mode,
212 __u32 *oplock, struct cifs_fid *fid)
213{
214 int rc = -ENOENT;
215 int create_options = CREATE_NOT_DIR;
216 int desired_access;
217 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
218 struct cifs_tcon *tcon = tlink_tcon(tlink);
219 char *full_path = NULL;
220 FILE_ALL_INFO *buf = NULL;
221 struct inode *newinode = NULL;
222 int disposition;
223 struct TCP_Server_Info *server = tcon->ses->server;
224 struct cifs_open_parms oparms;
225
226 *oplock = 0;
227 if (tcon->ses->server->oplocks)
228 *oplock = REQ_OPLOCK;
229
230 full_path = build_path_from_dentry(direntry);
231 if (full_path == NULL) {
232 rc = -ENOMEM;
233 goto out;
234 }
235
236 if (tcon->unix_ext && cap_unix(tcon->ses) && !tcon->broken_posix_open &&
237 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
238 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
239 rc = cifs_posix_open(full_path, &newinode, inode->i_sb, mode,
240 oflags, oplock, &fid->netfid, xid);
241 switch (rc) {
242 case 0:
243 if (newinode == NULL) {
244 /* query inode info */
245 goto cifs_create_get_file_info;
246 }
247
248 if (S_ISDIR(newinode->i_mode)) {
249 CIFSSMBClose(xid, tcon, fid->netfid);
250 iput(newinode);
251 rc = -EISDIR;
252 goto out;
253 }
254
255 if (!S_ISREG(newinode->i_mode)) {
256 /*
257 * The server may allow us to open things like
258 * FIFOs, but the client isn't set up to deal
259 * with that. If it's not a regular file, just
260 * close it and proceed as if it were a normal
261 * lookup.
262 */
263 CIFSSMBClose(xid, tcon, fid->netfid);
264 goto cifs_create_get_file_info;
265 }
266 /* success, no need to query */
267 goto cifs_create_set_dentry;
268
269 case -ENOENT:
270 goto cifs_create_get_file_info;
271
272 case -EIO:
273 case -EINVAL:
274 /*
275 * EIO could indicate that (posix open) operation is not
276 * supported, despite what server claimed in capability
277 * negotiation.
278 *
279 * POSIX open in samba versions 3.3.1 and earlier could
280 * incorrectly fail with invalid parameter.
281 */
282 tcon->broken_posix_open = true;
283 break;
284
285 case -EREMOTE:
286 case -EOPNOTSUPP:
287 /*
288 * EREMOTE indicates DFS junction, which is not handled
289 * in posix open. If either that or op not supported
290 * returned, follow the normal lookup.
291 */
292 break;
293
294 default:
295 goto out;
296 }
297 /*
298 * fallthrough to retry, using older open call, this is case
299 * where server does not support this SMB level, and falsely
300 * claims capability (also get here for DFS case which should be
301 * rare for path not covered on files)
302 */
303 }
304
305 desired_access = 0;
306 if (OPEN_FMODE(oflags) & FMODE_READ)
307 desired_access |= GENERIC_READ; /* is this too little? */
308 if (OPEN_FMODE(oflags) & FMODE_WRITE)
309 desired_access |= GENERIC_WRITE;
310
311 disposition = FILE_OVERWRITE_IF;
312 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
313 disposition = FILE_CREATE;
314 else if ((oflags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
315 disposition = FILE_OVERWRITE_IF;
316 else if ((oflags & O_CREAT) == O_CREAT)
317 disposition = FILE_OPEN_IF;
318 else
319 cifs_dbg(FYI, "Create flag not set in create function\n");
320
321 /*
322 * BB add processing to set equivalent of mode - e.g. via CreateX with
323 * ACLs
324 */
325
326 if (!server->ops->open) {
327 rc = -ENOSYS;
328 goto out;
329 }
330
331 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
332 if (buf == NULL) {
333 rc = -ENOMEM;
334 goto out;
335 }
336
337 /*
338 * if we're not using unix extensions, see if we need to set
339 * ATTR_READONLY on the create call
340 */
341 if (!tcon->unix_ext && (mode & S_IWUGO) == 0)
342 create_options |= CREATE_OPTION_READONLY;
343
344 if (backup_cred(cifs_sb))
345 create_options |= CREATE_OPEN_BACKUP_INTENT;
346
347 oparms.tcon = tcon;
348 oparms.cifs_sb = cifs_sb;
349 oparms.desired_access = desired_access;
350 oparms.create_options = create_options;
351 oparms.disposition = disposition;
352 oparms.path = full_path;
353 oparms.fid = fid;
354 oparms.reconnect = false;
355
356 rc = server->ops->open(xid, &oparms, oplock, buf);
357 if (rc) {
358 cifs_dbg(FYI, "cifs_create returned 0x%x\n", rc);
359 goto out;
360 }
361
362 /*
363 * If Open reported that we actually created a file then we now have to
364 * set the mode if possible.
365 */
366 if ((tcon->unix_ext) && (*oplock & CIFS_CREATE_ACTION)) {
367 struct cifs_unix_set_info_args args = {
368 .mode = mode,
369 .ctime = NO_CHANGE_64,
370 .atime = NO_CHANGE_64,
371 .mtime = NO_CHANGE_64,
372 .device = 0,
373 };
374
375 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
376 args.uid = current_fsuid();
377 if (inode->i_mode & S_ISGID)
378 args.gid = inode->i_gid;
379 else
380 args.gid = current_fsgid();
381 } else {
382 args.uid = INVALID_UID; /* no change */
383 args.gid = INVALID_GID; /* no change */
384 }
385 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid->netfid,
386 current->tgid);
387 } else {
388 /*
389 * BB implement mode setting via Windows security
390 * descriptors e.g.
391 */
392 /* CIFSSMBWinSetPerms(xid,tcon,path,mode,-1,-1,nls);*/
393
394 /* Could set r/o dos attribute if mode & 0222 == 0 */
395 }
396
397cifs_create_get_file_info:
398 /* server might mask mode so we have to query for it */
399 if (tcon->unix_ext)
400 rc = cifs_get_inode_info_unix(&newinode, full_path, inode->i_sb,
401 xid);
402 else {
403 rc = cifs_get_inode_info(&newinode, full_path, buf, inode->i_sb,
404 xid, fid);
405 if (newinode) {
406 if (server->ops->set_lease_key)
407 server->ops->set_lease_key(newinode, fid);
408 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
409 newinode->i_mode = mode;
410 if ((*oplock & CIFS_CREATE_ACTION) &&
411 (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
412 newinode->i_uid = current_fsuid();
413 if (inode->i_mode & S_ISGID)
414 newinode->i_gid = inode->i_gid;
415 else
416 newinode->i_gid = current_fsgid();
417 }
418 }
419 }
420
421cifs_create_set_dentry:
422 if (rc != 0) {
423 cifs_dbg(FYI, "Create worked, get_inode_info failed rc = %d\n",
424 rc);
425 goto out_err;
426 }
427
428 if (S_ISDIR(newinode->i_mode)) {
429 rc = -EISDIR;
430 goto out_err;
431 }
432
433 d_drop(direntry);
434 d_add(direntry, newinode);
435
436out:
437 kfree(buf);
438 kfree(full_path);
439 return rc;
440
441out_err:
442 if (server->ops->close)
443 server->ops->close(xid, tcon, fid);
444 if (newinode)
445 iput(newinode);
446 goto out;
447}
448
449int
450cifs_atomic_open(struct inode *inode, struct dentry *direntry,
451 struct file *file, unsigned oflags, umode_t mode,
452 int *opened)
453{
454 int rc;
455 unsigned int xid;
456 struct tcon_link *tlink;
457 struct cifs_tcon *tcon;
458 struct TCP_Server_Info *server;
459 struct cifs_fid fid;
460 struct cifs_pending_open open;
461 __u32 oplock;
462 struct cifsFileInfo *file_info;
463
464 /*
465 * Posix open is only called (at lookup time) for file create now. For
466 * opens (rather than creates), because we do not know if it is a file
467 * or directory yet, and current Samba no longer allows us to do posix
468 * open on dirs, we could end up wasting an open call on what turns out
469 * to be a dir. For file opens, we wait to call posix open till
470 * cifs_open. It could be added to atomic_open in the future but the
471 * performance tradeoff of the extra network request when EISDIR or
472 * EACCES is returned would have to be weighed against the 50% reduction
473 * in network traffic in the other paths.
474 */
475 if (!(oflags & O_CREAT)) {
476 struct dentry *res;
477
478 /*
479 * Check for hashed negative dentry. We have already revalidated
480 * the dentry and it is fine. No need to perform another lookup.
481 */
482 if (!d_in_lookup(direntry))
483 return -ENOENT;
484
485 res = cifs_lookup(inode, direntry, 0);
486 if (IS_ERR(res))
487 return PTR_ERR(res);
488
489 return finish_no_open(file, res);
490 }
491
492 rc = check_name(direntry);
493 if (rc)
494 return rc;
495
496 xid = get_xid();
497
498 cifs_dbg(FYI, "parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
499 inode, direntry, direntry);
500
501 tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));
502 if (IS_ERR(tlink)) {
503 rc = PTR_ERR(tlink);
504 goto out_free_xid;
505 }
506
507 tcon = tlink_tcon(tlink);
508 server = tcon->ses->server;
509
510 if (server->ops->new_lease_key)
511 server->ops->new_lease_key(&fid);
512
513 cifs_add_pending_open(&fid, tlink, &open);
514
515 rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode,
516 &oplock, &fid);
517
518 if (rc) {
519 cifs_del_pending_open(&open);
520 goto out;
521 }
522
523 if ((oflags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
524 *opened |= FILE_CREATED;
525
526 rc = finish_open(file, direntry, generic_file_open, opened);
527 if (rc) {
528 if (server->ops->close)
529 server->ops->close(xid, tcon, &fid);
530 cifs_del_pending_open(&open);
531 goto out;
532 }
533
534 if (file->f_flags & O_DIRECT &&
535 CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
536 if (CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
537 file->f_op = &cifs_file_direct_nobrl_ops;
538 else
539 file->f_op = &cifs_file_direct_ops;
540 }
541
542 file_info = cifs_new_fileinfo(&fid, file, tlink, oplock);
543 if (file_info == NULL) {
544 if (server->ops->close)
545 server->ops->close(xid, tcon, &fid);
546 cifs_del_pending_open(&open);
547 fput(file);
548 rc = -ENOMEM;
549 }
550
551out:
552 cifs_put_tlink(tlink);
553out_free_xid:
554 free_xid(xid);
555 return rc;
556}
557
558int cifs_create(struct inode *inode, struct dentry *direntry, umode_t mode,
559 bool excl)
560{
561 int rc;
562 unsigned int xid = get_xid();
563 /*
564 * BB below access is probably too much for mknod to request
565 * but we have to do query and setpathinfo so requesting
566 * less could fail (unless we want to request getatr and setatr
567 * permissions (only). At least for POSIX we do not have to
568 * request so much.
569 */
570 unsigned oflags = O_EXCL | O_CREAT | O_RDWR;
571 struct tcon_link *tlink;
572 struct cifs_tcon *tcon;
573 struct TCP_Server_Info *server;
574 struct cifs_fid fid;
575 __u32 oplock;
576
577 cifs_dbg(FYI, "cifs_create parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
578 inode, direntry, direntry);
579
580 tlink = cifs_sb_tlink(CIFS_SB(inode->i_sb));
581 rc = PTR_ERR(tlink);
582 if (IS_ERR(tlink))
583 goto out_free_xid;
584
585 tcon = tlink_tcon(tlink);
586 server = tcon->ses->server;
587
588 if (server->ops->new_lease_key)
589 server->ops->new_lease_key(&fid);
590
591 rc = cifs_do_create(inode, direntry, xid, tlink, oflags, mode,
592 &oplock, &fid);
593 if (!rc && server->ops->close)
594 server->ops->close(xid, tcon, &fid);
595
596 cifs_put_tlink(tlink);
597out_free_xid:
598 free_xid(xid);
599 return rc;
600}
601
602int cifs_mknod(struct inode *inode, struct dentry *direntry, umode_t mode,
603 dev_t device_number)
604{
605 int rc = -EPERM;
606 unsigned int xid;
607 int create_options = CREATE_NOT_DIR | CREATE_OPTION_SPECIAL;
608 struct cifs_sb_info *cifs_sb;
609 struct tcon_link *tlink;
610 struct cifs_tcon *tcon;
611 struct cifs_io_parms io_parms;
612 char *full_path = NULL;
613 struct inode *newinode = NULL;
614 __u32 oplock = 0;
615 struct cifs_fid fid;
616 struct cifs_open_parms oparms;
617 FILE_ALL_INFO *buf = NULL;
618 unsigned int bytes_written;
619 struct win_dev *pdev;
620 struct kvec iov[2];
621
622 if (!old_valid_dev(device_number))
623 return -EINVAL;
624
625 cifs_sb = CIFS_SB(inode->i_sb);
626 tlink = cifs_sb_tlink(cifs_sb);
627 if (IS_ERR(tlink))
628 return PTR_ERR(tlink);
629
630 tcon = tlink_tcon(tlink);
631
632 xid = get_xid();
633
634 full_path = build_path_from_dentry(direntry);
635 if (full_path == NULL) {
636 rc = -ENOMEM;
637 goto mknod_out;
638 }
639
640 if (tcon->unix_ext) {
641 struct cifs_unix_set_info_args args = {
642 .mode = mode & ~current_umask(),
643 .ctime = NO_CHANGE_64,
644 .atime = NO_CHANGE_64,
645 .mtime = NO_CHANGE_64,
646 .device = device_number,
647 };
648 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
649 args.uid = current_fsuid();
650 args.gid = current_fsgid();
651 } else {
652 args.uid = INVALID_UID; /* no change */
653 args.gid = INVALID_GID; /* no change */
654 }
655 rc = CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
656 cifs_sb->local_nls,
657 cifs_remap(cifs_sb));
658 if (rc)
659 goto mknod_out;
660
661 rc = cifs_get_inode_info_unix(&newinode, full_path,
662 inode->i_sb, xid);
663
664 if (rc == 0)
665 d_instantiate(direntry, newinode);
666 goto mknod_out;
667 }
668
669 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL))
670 goto mknod_out;
671
672
673 cifs_dbg(FYI, "sfu compat create special file\n");
674
675 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
676 if (buf == NULL) {
677 kfree(full_path);
678 rc = -ENOMEM;
679 free_xid(xid);
680 return rc;
681 }
682
683 if (backup_cred(cifs_sb))
684 create_options |= CREATE_OPEN_BACKUP_INTENT;
685
686 oparms.tcon = tcon;
687 oparms.cifs_sb = cifs_sb;
688 oparms.desired_access = GENERIC_WRITE;
689 oparms.create_options = create_options;
690 oparms.disposition = FILE_CREATE;
691 oparms.path = full_path;
692 oparms.fid = &fid;
693 oparms.reconnect = false;
694
695 if (tcon->ses->server->oplocks)
696 oplock = REQ_OPLOCK;
697 else
698 oplock = 0;
699 rc = tcon->ses->server->ops->open(xid, &oparms, &oplock, buf);
700 if (rc)
701 goto mknod_out;
702
703 /*
704 * BB Do not bother to decode buf since no local inode yet to put
705 * timestamps in, but we can reuse it safely.
706 */
707
708 pdev = (struct win_dev *)buf;
709 io_parms.pid = current->tgid;
710 io_parms.tcon = tcon;
711 io_parms.offset = 0;
712 io_parms.length = sizeof(struct win_dev);
713 iov[1].iov_base = buf;
714 iov[1].iov_len = sizeof(struct win_dev);
715 if (S_ISCHR(mode)) {
716 memcpy(pdev->type, "IntxCHR", 8);
717 pdev->major = cpu_to_le64(MAJOR(device_number));
718 pdev->minor = cpu_to_le64(MINOR(device_number));
719 rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
720 &bytes_written, iov, 1);
721 } else if (S_ISBLK(mode)) {
722 memcpy(pdev->type, "IntxBLK", 8);
723 pdev->major = cpu_to_le64(MAJOR(device_number));
724 pdev->minor = cpu_to_le64(MINOR(device_number));
725 rc = tcon->ses->server->ops->sync_write(xid, &fid, &io_parms,
726 &bytes_written, iov, 1);
727 } /* else if (S_ISFIFO) */
728 tcon->ses->server->ops->close(xid, tcon, &fid);
729 d_drop(direntry);
730
731 /* FIXME: add code here to set EAs */
732
733mknod_out:
734 kfree(full_path);
735 kfree(buf);
736 free_xid(xid);
737 cifs_put_tlink(tlink);
738 return rc;
739}
740
741struct dentry *
742cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
743 unsigned int flags)
744{
745 unsigned int xid;
746 int rc = 0; /* to get around spurious gcc warning, set to zero here */
747 struct cifs_sb_info *cifs_sb;
748 struct tcon_link *tlink;
749 struct cifs_tcon *pTcon;
750 struct inode *newInode = NULL;
751 char *full_path = NULL;
752
753 xid = get_xid();
754
755 cifs_dbg(FYI, "parent inode = 0x%p name is: %pd and dentry = 0x%p\n",
756 parent_dir_inode, direntry, direntry);
757
758 /* check whether path exists */
759
760 cifs_sb = CIFS_SB(parent_dir_inode->i_sb);
761 tlink = cifs_sb_tlink(cifs_sb);
762 if (IS_ERR(tlink)) {
763 free_xid(xid);
764 return (struct dentry *)tlink;
765 }
766 pTcon = tlink_tcon(tlink);
767
768 rc = check_name(direntry);
769 if (rc)
770 goto lookup_out;
771
772 /* can not grab the rename sem here since it would
773 deadlock in the cases (beginning of sys_rename itself)
774 in which we already have the sb rename sem */
775 full_path = build_path_from_dentry(direntry);
776 if (full_path == NULL) {
777 rc = -ENOMEM;
778 goto lookup_out;
779 }
780
781 if (d_really_is_positive(direntry)) {
782 cifs_dbg(FYI, "non-NULL inode in lookup\n");
783 } else {
784 cifs_dbg(FYI, "NULL inode in lookup\n");
785 }
786 cifs_dbg(FYI, "Full path: %s inode = 0x%p\n",
787 full_path, d_inode(direntry));
788
789 if (pTcon->unix_ext) {
790 rc = cifs_get_inode_info_unix(&newInode, full_path,
791 parent_dir_inode->i_sb, xid);
792 } else {
793 rc = cifs_get_inode_info(&newInode, full_path, NULL,
794 parent_dir_inode->i_sb, xid, NULL);
795 }
796
797 if ((rc == 0) && (newInode != NULL)) {
798 d_add(direntry, newInode);
799 /* since paths are not looked up by component - the parent
800 directories are presumed to be good here */
801 renew_parental_timestamps(direntry);
802
803 } else if (rc == -ENOENT) {
804 rc = 0;
805 cifs_set_time(direntry, jiffies);
806 d_add(direntry, NULL);
807 /* if it was once a directory (but how can we tell?) we could do
808 shrink_dcache_parent(direntry); */
809 } else if (rc != -EACCES) {
810 cifs_dbg(FYI, "Unexpected lookup error %d\n", rc);
811 /* We special case check for Access Denied - since that
812 is a common return code */
813 }
814
815lookup_out:
816 kfree(full_path);
817 cifs_put_tlink(tlink);
818 free_xid(xid);
819 return ERR_PTR(rc);
820}
821
822static int
823cifs_d_revalidate(struct dentry *direntry, unsigned int flags)
824{
825 if (flags & LOOKUP_RCU)
826 return -ECHILD;
827
828 if (d_really_is_positive(direntry)) {
829 if (cifs_revalidate_dentry(direntry))
830 return 0;
831 else {
832 /*
833 * If the inode wasn't known to be a dfs entry when
834 * the dentry was instantiated, such as when created
835 * via ->readdir(), it needs to be set now since the
836 * attributes will have been updated by
837 * cifs_revalidate_dentry().
838 */
839 if (IS_AUTOMOUNT(d_inode(direntry)) &&
840 !(direntry->d_flags & DCACHE_NEED_AUTOMOUNT)) {
841 spin_lock(&direntry->d_lock);
842 direntry->d_flags |= DCACHE_NEED_AUTOMOUNT;
843 spin_unlock(&direntry->d_lock);
844 }
845
846 return 1;
847 }
848 }
849
850 /*
851 * This may be nfsd (or something), anyway, we can't see the
852 * intent of this. So, since this can be for creation, drop it.
853 */
854 if (!flags)
855 return 0;
856
857 /*
858 * Drop the negative dentry, in order to make sure to use the
859 * case sensitive name which is specified by user if this is
860 * for creation.
861 */
862 if (flags & (LOOKUP_CREATE | LOOKUP_RENAME_TARGET))
863 return 0;
864
865 if (time_after(jiffies, cifs_get_time(direntry) + HZ) || !lookupCacheEnabled)
866 return 0;
867
868 return 1;
869}
870
871/* static int cifs_d_delete(struct dentry *direntry)
872{
873 int rc = 0;
874
875 cifs_dbg(FYI, "In cifs d_delete, name = %pd\n", direntry);
876
877 return rc;
878} */
879
880const struct dentry_operations cifs_dentry_ops = {
881 .d_revalidate = cifs_d_revalidate,
882 .d_automount = cifs_dfs_d_automount,
883/* d_delete: cifs_d_delete, */ /* not needed except for debugging */
884};
885
886static int cifs_ci_hash(const struct dentry *dentry, struct qstr *q)
887{
888 struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
889 unsigned long hash;
890 wchar_t c;
891 int i, charlen;
892
893 hash = init_name_hash(dentry);
894 for (i = 0; i < q->len; i += charlen) {
895 charlen = codepage->char2uni(&q->name[i], q->len - i, &c);
896 /* error out if we can't convert the character */
897 if (unlikely(charlen < 0))
898 return charlen;
899 hash = partial_name_hash(cifs_toupper(c), hash);
900 }
901 q->hash = end_name_hash(hash);
902
903 return 0;
904}
905
906static int cifs_ci_compare(const struct dentry *dentry,
907 unsigned int len, const char *str, const struct qstr *name)
908{
909 struct nls_table *codepage = CIFS_SB(dentry->d_sb)->local_nls;
910 wchar_t c1, c2;
911 int i, l1, l2;
912
913 /*
914 * We make the assumption here that uppercase characters in the local
915 * codepage are always the same length as their lowercase counterparts.
916 *
917 * If that's ever not the case, then this will fail to match it.
918 */
919 if (name->len != len)
920 return 1;
921
922 for (i = 0; i < len; i += l1) {
923 /* Convert characters in both strings to UTF-16. */
924 l1 = codepage->char2uni(&str[i], len - i, &c1);
925 l2 = codepage->char2uni(&name->name[i], name->len - i, &c2);
926
927 /*
928 * If we can't convert either character, just declare it to
929 * be 1 byte long and compare the original byte.
930 */
931 if (unlikely(l1 < 0 && l2 < 0)) {
932 if (str[i] != name->name[i])
933 return 1;
934 l1 = 1;
935 continue;
936 }
937
938 /*
939 * Here, we again ass|u|me that upper/lowercase versions of
940 * a character are the same length in the local NLS.
941 */
942 if (l1 != l2)
943 return 1;
944
945 /* Now compare uppercase versions of these characters */
946 if (cifs_toupper(c1) != cifs_toupper(c2))
947 return 1;
948 }
949
950 return 0;
951}
952
953const struct dentry_operations cifs_ci_dentry_ops = {
954 .d_revalidate = cifs_d_revalidate,
955 .d_hash = cifs_ci_hash,
956 .d_compare = cifs_ci_compare,
957 .d_automount = cifs_dfs_d_automount,
958};