1 /*
2 * linux/fs/open.c
3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds
5 */
6
7 #include <linux/string.h>
8 #include <linux/mm.h>
9 #include <linux/utime.h>
10 #include <linux/file.h>
11 #include <linux/smp_lock.h>
12 #include <linux/quotaops.h>
13 #include <linux/dnotify.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16
17 #include <asm/uaccess.h>
18
19 #define special_file(m) (S_ISCHR(m)||S_ISBLK(m)||S_ISFIFO(m)||S_ISSOCK(m))
20
21 int vfs_statfs(struct super_block *sb, struct statfs *buf)
22 {
23 int retval = -ENODEV;
24
25 if (sb) {
26 retval = -ENOSYS;
27 if (sb->s_op && sb->s_op->statfs) {
28 memset(buf, 0, sizeof(struct statfs));
29 lock_kernel();
30 retval = sb->s_op->statfs(sb, buf);
31 unlock_kernel();
32 }
33 }
34 return retval;
35 }
36
37
38 asmlinkage long sys_statfs(const char * path, struct statfs * buf)
39 {
40 struct nameidata nd;
41 int error;
42
43 error = user_path_walk(path, &nd);
44 if (!error) {
45 struct statfs tmp;
46 error = vfs_statfs(nd.dentry->d_inode->i_sb, &tmp);
47 if (!error && copy_to_user(buf, &tmp, sizeof(struct statfs)))
48 error = -EFAULT;
49 path_release(&nd);
50 }
51 return error;
52 }
53
54 asmlinkage long sys_fstatfs(unsigned int fd, struct statfs * buf)
55 {
56 struct file * file;
57 struct statfs tmp;
58 int error;
59
60 error = -EBADF;
61 file = fget(fd);
62 if (!file)
63 goto out;
64 error = vfs_statfs(file->f_dentry->d_inode->i_sb, &tmp);
65 if (!error && copy_to_user(buf, &tmp, sizeof(struct statfs)))
66 error = -EFAULT;
67 fput(file);
68 out:
69 return error;
70 }
71
72 int do_truncate(struct dentry *dentry, loff_t length)
73 {
74 struct inode *inode = dentry->d_inode;
75 int error;
76 struct iattr newattrs;
77
78 /* Not pretty: "inode->i_size" shouldn't really be signed. But it is. */
79 if (length < 0)
80 return -EINVAL;
81
82 down(&inode->i_sem);
83 newattrs.ia_size = length;
84 newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
85 error = notify_change(dentry, &newattrs);
86 up(&inode->i_sem);
87 return error;
88 }
89
90 static inline long do_sys_truncate(const char * path, loff_t length)
91 {
92 struct nameidata nd;
93 struct inode * inode;
94 int error;
95
96 error = -EINVAL;
97 if (length < 0) /* sorry, but loff_t says... */
98 goto out;
99
100 error = user_path_walk(path, &nd);
101 if (error)
102 goto out;
103 inode = nd.dentry->d_inode;
104
105 error = -EACCES;
106 if (!S_ISREG(inode->i_mode))
107 goto dput_and_out;
108
109 error = permission(inode,MAY_WRITE);
110 if (error)
111 goto dput_and_out;
112
113 error = -EROFS;
114 if (IS_RDONLY(inode))
115 goto dput_and_out;
116
117 error = -EPERM;
118 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
119 goto dput_and_out;
120
121 /*
122 * Make sure that there are no leases.
123 */
124 error = get_lease(inode, FMODE_WRITE);
125 if (error)
126 goto dput_and_out;
127
128 error = get_write_access(inode);
129 if (error)
130 goto dput_and_out;
131
132 error = locks_verify_truncate(inode, NULL, length);
133 if (!error) {
134 DQUOT_INIT(inode);
135 error = do_truncate(nd.dentry, length);
136 }
137 put_write_access(inode);
138
139 dput_and_out:
140 path_release(&nd);
141 out:
142 return error;
143 }
144
145 asmlinkage long sys_truncate(const char * path, unsigned long length)
146 {
147 return do_sys_truncate(path, length);
148 }
149
150 static inline long do_sys_ftruncate(unsigned int fd, loff_t length)
151 {
152 struct inode * inode;
153 struct dentry *dentry;
154 struct file * file;
155 int error;
156
157 error = -EINVAL;
158 if (length < 0)
159 goto out;
160 error = -EBADF;
161 file = fget(fd);
162 if (!file)
163 goto out;
164 dentry = file->f_dentry;
165 inode = dentry->d_inode;
166 error = -EACCES;
167 if (!S_ISREG(inode->i_mode) || !(file->f_mode & FMODE_WRITE))
168 goto out_putf;
169 error = -EPERM;
170 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
171 goto out_putf;
172
173 error = locks_verify_truncate(inode, file, length);
174 if (!error)
175 error = do_truncate(dentry, length);
176 out_putf:
177 fput(file);
178 out:
179 return error;
180 }
181
182 asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length)
183 {
184 return do_sys_ftruncate(fd, length);
185 }
186
187 /* LFS versions of truncate are only needed on 32 bit machines */
188 #if BITS_PER_LONG == 32
189 asmlinkage long sys_truncate64(const char * path, loff_t length)
190 {
191 return do_sys_truncate(path, length);
192 }
193
194 asmlinkage long sys_ftruncate64(unsigned int fd, loff_t length)
195 {
196 return do_sys_ftruncate(fd, length);
197 }
198 #endif
199
200 #if !(defined(__alpha__) || defined(__ia64__))
201
202 /*
203 * sys_utime() can be implemented in user-level using sys_utimes().
204 * Is this for backwards compatibility? If so, why not move it
205 * into the appropriate arch directory (for those architectures that
206 * need it).
207 */
208
209 /* If times==NULL, set access and modification to current time,
210 * must be owner or have write permission.
211 * Else, update from *times, must be owner or super user.
212 */
213 asmlinkage long sys_utime(char * filename, struct utimbuf * times)
214 {
215 int error;
216 struct nameidata nd;
217 struct inode * inode;
218 struct iattr newattrs;
219
220 error = user_path_walk(filename, &nd);
221 if (error)
222 goto out;
223 inode = nd.dentry->d_inode;
224
225 error = -EROFS;
226 if (IS_RDONLY(inode))
227 goto dput_and_out;
228
229 /* Don't worry, the checks are done in inode_change_ok() */
230 newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
231 if (times) {
232 error = get_user(newattrs.ia_atime, ×->actime);
233 if (!error)
234 error = get_user(newattrs.ia_mtime, ×->modtime);
235 if (error)
236 goto dput_and_out;
237
238 newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
239 } else {
240 if (current->fsuid != inode->i_uid &&
241 (error = permission(inode,MAY_WRITE)) != 0)
242 goto dput_and_out;
243 }
244 error = notify_change(nd.dentry, &newattrs);
245 dput_and_out:
246 path_release(&nd);
247 out:
248 return error;
249 }
250
251 #endif
252
253 /* If times==NULL, set access and modification to current time,
254 * must be owner or have write permission.
255 * Else, update from *times, must be owner or super user.
256 */
257 asmlinkage long sys_utimes(char * filename, struct timeval * utimes)
258 {
259 int error;
260 struct nameidata nd;
261 struct inode * inode;
262 struct iattr newattrs;
263
264 error = user_path_walk(filename, &nd);
265
266 if (error)
267 goto out;
268 inode = nd.dentry->d_inode;
269
270 error = -EROFS;
271 if (IS_RDONLY(inode))
272 goto dput_and_out;
273
274 /* Don't worry, the checks are done in inode_change_ok() */
275 newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
276 if (utimes) {
277 struct timeval times[2];
278 error = -EFAULT;
279 if (copy_from_user(×, utimes, sizeof(times)))
280 goto dput_and_out;
281 newattrs.ia_atime = times[0].tv_sec;
282 newattrs.ia_mtime = times[1].tv_sec;
283 newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
284 } else {
285 if ((error = permission(inode,MAY_WRITE)) != 0)
286 goto dput_and_out;
287 }
288 error = notify_change(nd.dentry, &newattrs);
289 dput_and_out:
290 path_release(&nd);
291 out:
292 return error;
293 }
294
295 /*
296 * access() needs to use the real uid/gid, not the effective uid/gid.
297 * We do this by temporarily clearing all FS-related capabilities and
298 * switching the fsuid/fsgid around to the real ones.
299 */
300 asmlinkage long sys_access(const char * filename, int mode)
301 {
302 struct nameidata nd;
303 int old_fsuid, old_fsgid;
304 kernel_cap_t old_cap;
305 int res;
306
307 if (mode & ~S_IRWXO) /* where's F_OK, X_OK, W_OK, R_OK? */
308 return -EINVAL;
309
310 old_fsuid = current->fsuid;
311 old_fsgid = current->fsgid;
312 old_cap = current->cap_effective;
313
314 current->fsuid = current->uid;
315 current->fsgid = current->gid;
316
317 /* Clear the capabilities if we switch to a non-root user */
318 if (current->uid)
319 cap_clear(current->cap_effective);
320 else
321 current->cap_effective = current->cap_permitted;
322
323 res = user_path_walk(filename, &nd);
324 if (!res) {
325 res = permission(nd.dentry->d_inode, mode);
326 /* SuS v2 requires we report a read only fs too */
327 if(!res && (mode & S_IWOTH) && IS_RDONLY(nd.dentry->d_inode)
328 && !special_file(nd.dentry->d_inode->i_mode))
329 res = -EROFS;
330 path_release(&nd);
331 }
332
333 current->fsuid = old_fsuid;
334 current->fsgid = old_fsgid;
335 current->cap_effective = old_cap;
336
337 return res;
338 }
339
340 asmlinkage long sys_chdir(const char * filename)
341 {
342 int error;
343 struct nameidata nd;
344 char *name;
345
346 name = getname(filename);
347 error = PTR_ERR(name);
348 if (IS_ERR(name))
349 goto out;
350
351 error = 0;
352 if (path_init(name,LOOKUP_POSITIVE|LOOKUP_FOLLOW|LOOKUP_DIRECTORY,&nd))
353 error = path_walk(name, &nd);
354 putname(name);
355 if (error)
356 goto out;
357
358 error = permission(nd.dentry->d_inode,MAY_EXEC);
359 if (error)
360 goto dput_and_out;
361
362 set_fs_pwd(current->fs, nd.mnt, nd.dentry);
363
364 dput_and_out:
365 path_release(&nd);
366 out:
367 return error;
368 }
369
370 asmlinkage long sys_fchdir(unsigned int fd)
371 {
372 struct file *file;
373 struct dentry *dentry;
374 struct inode *inode;
375 struct vfsmount *mnt;
376 int error;
377
378 error = -EBADF;
379 file = fget(fd);
380 if (!file)
381 goto out;
382
383 dentry = file->f_dentry;
384 mnt = file->f_vfsmnt;
385 inode = dentry->d_inode;
386
387 error = -ENOTDIR;
388 if (!S_ISDIR(inode->i_mode))
389 goto out_putf;
390
391 error = permission(inode, MAY_EXEC);
392 if (!error)
393 set_fs_pwd(current->fs, mnt, dentry);
394 out_putf:
395 fput(file);
396 out:
397 return error;
398 }
399
400 asmlinkage long sys_chroot(const char * filename)
401 {
402 int error;
403 struct nameidata nd;
404 char *name;
405
406 name = getname(filename);
407 error = PTR_ERR(name);
408 if (IS_ERR(name))
409 goto out;
410
411 path_init(name, LOOKUP_POSITIVE | LOOKUP_FOLLOW |
412 LOOKUP_DIRECTORY | LOOKUP_NOALT, &nd);
413 error = path_walk(name, &nd);
414 putname(name);
415 if (error)
416 goto out;
417
418 error = permission(nd.dentry->d_inode,MAY_EXEC);
419 if (error)
420 goto dput_and_out;
421
422 error = -EPERM;
423 if (!capable(CAP_SYS_CHROOT))
424 goto dput_and_out;
425
426 set_fs_root(current->fs, nd.mnt, nd.dentry);
427 set_fs_altroot();
428 error = 0;
429 dput_and_out:
430 path_release(&nd);
431 out:
432 return error;
433 }
434
435 asmlinkage long sys_fchmod(unsigned int fd, mode_t mode)
436 {
437 struct inode * inode;
438 struct dentry * dentry;
439 struct file * file;
440 int err = -EBADF;
441 struct iattr newattrs;
442
443 file = fget(fd);
444 if (!file)
445 goto out;
446
447 dentry = file->f_dentry;
448 inode = dentry->d_inode;
449
450 err = -EROFS;
451 if (IS_RDONLY(inode))
452 goto out_putf;
453 err = -EPERM;
454 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
455 goto out_putf;
456 if (mode == (mode_t) -1)
457 mode = inode->i_mode;
458 newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
459 newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
460 err = notify_change(dentry, &newattrs);
461
462 out_putf:
463 fput(file);
464 out:
465 return err;
466 }
467
468 asmlinkage long sys_chmod(const char * filename, mode_t mode)
469 {
470 struct nameidata nd;
471 struct inode * inode;
472 int error;
473 struct iattr newattrs;
474
475 error = user_path_walk(filename, &nd);
476 if (error)
477 goto out;
478 inode = nd.dentry->d_inode;
479
480 error = -EROFS;
481 if (IS_RDONLY(inode))
482 goto dput_and_out;
483
484 error = -EPERM;
485 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
486 goto dput_and_out;
487
488 if (mode == (mode_t) -1)
489 mode = inode->i_mode;
490 newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
491 newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
492 error = notify_change(nd.dentry, &newattrs);
493
494 dput_and_out:
495 path_release(&nd);
496 out:
497 return error;
498 }
499
500 static int chown_common(struct dentry * dentry, uid_t user, gid_t group)
501 {
502 struct inode * inode;
503 int error;
504 struct iattr newattrs;
505
506 error = -ENOENT;
507 if (!(inode = dentry->d_inode)) {
508 printk("chown_common: NULL inode\n");
509 goto out;
510 }
511 error = -EROFS;
512 if (IS_RDONLY(inode))
513 goto out;
514 error = -EPERM;
515 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
516 goto out;
517 if (user == (uid_t) -1)
518 user = inode->i_uid;
519 if (group == (gid_t) -1)
520 group = inode->i_gid;
521 newattrs.ia_mode = inode->i_mode;
522 newattrs.ia_uid = user;
523 newattrs.ia_gid = group;
524 newattrs.ia_valid = ATTR_UID | ATTR_GID | ATTR_CTIME;
525 /*
526 * If the user or group of a non-directory has been changed by a
527 * non-root user, remove the setuid bit.
528 * 19981026 David C Niemi <niemi@tux.org>
529 *
530 * Changed this to apply to all users, including root, to avoid
531 * some races. This is the behavior we had in 2.0. The check for
532 * non-root was definitely wrong for 2.2 anyway, as it should
533 * have been using CAP_FSETID rather than fsuid -- 19990830 SD.
534 */
535 if ((inode->i_mode & S_ISUID) == S_ISUID &&
536 !S_ISDIR(inode->i_mode))
537 {
538 newattrs.ia_mode &= ~S_ISUID;
539 newattrs.ia_valid |= ATTR_MODE;
540 }
541 /*
542 * Likewise, if the user or group of a non-directory has been changed
543 * by a non-root user, remove the setgid bit UNLESS there is no group
544 * execute bit (this would be a file marked for mandatory locking).
545 * 19981026 David C Niemi <niemi@tux.org>
546 *
547 * Removed the fsuid check (see the comment above) -- 19990830 SD.
548 */
549 if (((inode->i_mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP))
550 && !S_ISDIR(inode->i_mode))
551 {
552 newattrs.ia_mode &= ~S_ISGID;
553 newattrs.ia_valid |= ATTR_MODE;
554 }
555 error = DQUOT_TRANSFER(dentry, &newattrs);
556 out:
557 return error;
558 }
559
560 asmlinkage long sys_chown(const char * filename, uid_t user, gid_t group)
561 {
562 struct nameidata nd;
563 int error;
564
565 error = user_path_walk(filename, &nd);
566 if (!error) {
567 error = chown_common(nd.dentry, user, group);
568 path_release(&nd);
569 }
570 return error;
571 }
572
573 asmlinkage long sys_lchown(const char * filename, uid_t user, gid_t group)
574 {
575 struct nameidata nd;
576 int error;
577
578 error = user_path_walk_link(filename, &nd);
579 if (!error) {
580 error = chown_common(nd.dentry, user, group);
581 path_release(&nd);
582 }
583 return error;
584 }
585
586
587 asmlinkage long sys_fchown(unsigned int fd, uid_t user, gid_t group)
588 {
589 struct file * file;
590 int error = -EBADF;
591
592 file = fget(fd);
593 if (file) {
594 error = chown_common(file->f_dentry, user, group);
595 fput(file);
596 }
597 return error;
598 }
599
600 /*
601 * Note that while the flag value (low two bits) for sys_open means:
602 * 00 - read-only
603 * 01 - write-only
604 * 10 - read-write
605 * 11 - special
606 * it is changed into
607 * 00 - no permissions needed
608 * 01 - read-permission
609 * 10 - write-permission
610 * 11 - read-write
611 * for the internal routines (ie open_namei()/follow_link() etc). 00 is
612 * used by symlinks.
613 */
614 struct file *filp_open(const char * filename, int flags, int mode)
615 {
616 int namei_flags, error;
617 struct nameidata nd;
618
619 namei_flags = flags;
620 if ((namei_flags+1) & O_ACCMODE)
621 namei_flags++;
622 if (namei_flags & O_TRUNC)
623 namei_flags |= 2;
624
625 error = open_namei(filename, namei_flags, mode, &nd);
626 if (!error)
627 return dentry_open(nd.dentry, nd.mnt, flags);
628
629 return ERR_PTR(error);
630 }
631
632 struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags)
633 {
634 struct file * f;
635 struct inode *inode;
636 int error;
637
638 error = -ENFILE;
639 f = get_empty_filp();
640 if (!f)
641 goto cleanup_dentry;
642 f->f_flags = flags;
643 f->f_mode = (flags+1) & O_ACCMODE;
644 inode = dentry->d_inode;
645 if (f->f_mode & FMODE_WRITE) {
646 error = get_write_access(inode);
647 if (error)
648 goto cleanup_file;
649 }
650
651 f->f_dentry = dentry;
652 f->f_vfsmnt = mnt;
653 f->f_pos = 0;
654 f->f_reada = 0;
655 f->f_op = fops_get(inode->i_fop);
656 if (inode->i_sb)
657 file_move(f, &inode->i_sb->s_files);
658 if (f->f_op && f->f_op->open) {
659 error = f->f_op->open(inode,f);
660 if (error)
661 goto cleanup_all;
662 }
663 f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);
664
665 return f;
666
667 cleanup_all:
668 fops_put(f->f_op);
669 if (f->f_mode & FMODE_WRITE)
670 put_write_access(inode);
671 f->f_dentry = NULL;
672 f->f_vfsmnt = NULL;
673 cleanup_file:
674 put_filp(f);
675 cleanup_dentry:
676 dput(dentry);
677 mntput(mnt);
678 return ERR_PTR(error);
679 }
680
681 /*
682 * Find an empty file descriptor entry, and mark it busy.
683 */
684 int get_unused_fd(void)
685 {
686 struct files_struct * files = current->files;
687 int fd, error;
688
689 error = -EMFILE;
690 write_lock(&files->file_lock);
691
692 repeat:
693 fd = find_next_zero_bit(files->open_fds,
694 files->max_fdset,
695 files->next_fd);
696
697 /*
698 * N.B. For clone tasks sharing a files structure, this test
699 * will limit the total number of files that can be opened.
700 */
701 if (fd >= current->rlim[RLIMIT_NOFILE].rlim_cur)
702 goto out;
703
704 /* Do we need to expand the fdset array? */
705 if (fd >= files->max_fdset) {
706 error = expand_fdset(files, fd);
707 if (!error) {
708 error = -EMFILE;
709 goto repeat;
710 }
711 goto out;
712 }
713
714 /*
715 * Check whether we need to expand the fd array.
716 */
717 if (fd >= files->max_fds) {
718 error = expand_fd_array(files, fd);
719 if (!error) {
720 error = -EMFILE;
721 goto repeat;
722 }
723 goto out;
724 }
725
726 FD_SET(fd, files->open_fds);
727 FD_CLR(fd, files->close_on_exec);
728 files->next_fd = fd + 1;
729 #if 1
730 /* Sanity check */
731 if (files->fd[fd] != NULL) {
732 printk("get_unused_fd: slot %d not NULL!\n", fd);
733 files->fd[fd] = NULL;
734 }
735 #endif
736 error = fd;
737
738 out:
739 write_unlock(&files->file_lock);
740 return error;
741 }
742
743 asmlinkage long sys_open(const char * filename, int flags, int mode)
744 {
745 char * tmp;
746 int fd, error;
747
748 #if BITS_PER_LONG != 32
749 flags |= O_LARGEFILE;
750 #endif
751 tmp = getname(filename);
752 fd = PTR_ERR(tmp);
753 if (!IS_ERR(tmp)) {
754 fd = get_unused_fd();
755 if (fd >= 0) {
756 struct file *f = filp_open(tmp, flags, mode);
757 error = PTR_ERR(f);
758 if (IS_ERR(f))
759 goto out_error;
760 fd_install(fd, f);
761 }
762 out:
763 putname(tmp);
764 }
765 return fd;
766
767 out_error:
768 put_unused_fd(fd);
769 fd = error;
770 goto out;
771 }
772
773 #ifndef __alpha__
774
775 /*
776 * For backward compatibility? Maybe this should be moved
777 * into arch/i386 instead?
778 */
779 asmlinkage long sys_creat(const char * pathname, int mode)
780 {
781 return sys_open(pathname, O_CREAT | O_WRONLY | O_TRUNC, mode);
782 }
783
784 #endif
785
786 /*
787 * "id" is the POSIX thread ID. We use the
788 * files pointer for this..
789 */
790 int filp_close(struct file *filp, fl_owner_t id)
791 {
792 int retval;
793
794 if (!file_count(filp)) {
795 printk("VFS: Close: file count is 0\n");
796 return 0;
797 }
798 retval = 0;
799 if (filp->f_op && filp->f_op->flush) {
800 lock_kernel();
801 retval = filp->f_op->flush(filp);
802 unlock_kernel();
803 }
804 fcntl_dirnotify(0, filp, 0);
805 locks_remove_posix(filp, id);
806 fput(filp);
807 return retval;
808 }
809
810 /*
811 * Careful here! We test whether the file pointer is NULL before
812 * releasing the fd. This ensures that one clone task can't release
813 * an fd while another clone is opening it.
814 */
815 asmlinkage long sys_close(unsigned int fd)
816 {
817 struct file * filp;
818 struct files_struct *files = current->files;
819
820 write_lock(&files->file_lock);
821 if (fd >= files->max_fds)
822 goto out_unlock;
823 filp = files->fd[fd];
824 if (!filp)
825 goto out_unlock;
826 files->fd[fd] = NULL;
827 FD_CLR(fd, files->close_on_exec);
828 __put_unused_fd(files, fd);
829 write_unlock(&files->file_lock);
830 return filp_close(filp, files);
831
832 out_unlock:
833 write_unlock(&files->file_lock);
834 return -EBADF;
835 }
836
837 /*
838 * This routine simulates a hangup on the tty, to arrange that users
839 * are given clean terminals at login time.
840 */
841 asmlinkage long sys_vhangup(void)
842 {
843 if (capable(CAP_SYS_TTY_CONFIG)) {
844 tty_vhangup(current->tty);
845 return 0;
846 }
847 return -EPERM;
848 }
849
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.