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