Commit 1c710c896eb461895d3c399e15bb5f20b39c9073

Authored by Ulrich Drepper
Committed by Linus Torvalds
1 parent ade5fb818f

utimensat implementation

Implement utimensat(2) which is an extension to futimesat(2) in that it

a) supports nano-second resolution for the timestamps
b) allows to selectively ignore the atime/mtime value
c) allows to selectively use the current time for either atime or mtime
d) supports changing the atime/mtime of a symlink itself along the lines
   of the BSD lutimes(3) functions

For this change the internally used do_utimes() functions was changed to
accept a timespec time value and an additional flags parameter.

Additionally the sys_utime function was changed to match compat_sys_utime
which already use do_utimes instead of duplicating the work.

Also, the completely missing futimensat() functionality is added.  We have
such a function in glibc but we have to resort to using /proc/self/fd/* which
not everybody likes (chroot etc).

Test application (the syscall number will need per-arch editing):

#include <errno.h>
#include <fcntl.h>
#include <time.h>
#include <sys/time.h>
#include <stddef.h>
#include <syscall.h>

#define __NR_utimensat 280

#define UTIME_NOW       ((1l << 30) - 1l)
#define UTIME_OMIT      ((1l << 30) - 2l)

int
main(void)
{
  int status = 0;

  int fd = open("ttt", O_RDWR|O_CREAT|O_EXCL, 0666);
  if (fd == -1)
    error (1, errno, "failed to create test file \"ttt\"");

  struct stat64 st1;
  if (fstat64 (fd, &st1) != 0)
    error (1, errno, "fstat failed");

  struct timespec t[2];
  t[0].tv_sec = 0;
  t[0].tv_nsec = 0;
  t[1].tv_sec = 0;
  t[1].tv_nsec = 0;
  if (syscall(__NR_utimensat, AT_FDCWD, "ttt", t, 0) != 0)
    error (1, errno, "utimensat failed");

  struct stat64 st2;
  if (fstat64 (fd, &st2) != 0)
    error (1, errno, "fstat failed");

  if (st2.st_atim.tv_sec != 0 || st2.st_atim.tv_nsec != 0)
    {
      puts ("atim not reset to zero");
      status = 1;
    }
  if (st2.st_mtim.tv_sec != 0 || st2.st_mtim.tv_nsec != 0)
    {
      puts ("mtim not reset to zero");
      status = 1;
    }
  if (status != 0)
    goto out;

  t[0] = st1.st_atim;
  t[1].tv_sec = 0;
  t[1].tv_nsec = UTIME_OMIT;
  if (syscall(__NR_utimensat, AT_FDCWD, "ttt", t, 0) != 0)
    error (1, errno, "utimensat failed");

  if (fstat64 (fd, &st2) != 0)
    error (1, errno, "fstat failed");

  if (st2.st_atim.tv_sec != st1.st_atim.tv_sec
      || st2.st_atim.tv_nsec != st1.st_atim.tv_nsec)
    {
      puts ("atim not set");
      status = 1;
    }
  if (st2.st_mtim.tv_sec != 0 || st2.st_mtim.tv_nsec != 0)
    {
      puts ("mtim changed from zero");
      status = 1;
    }
  if (status != 0)
    goto out;

  t[0].tv_sec = 0;
  t[0].tv_nsec = UTIME_OMIT;
  t[1] = st1.st_mtim;
  if (syscall(__NR_utimensat, AT_FDCWD, "ttt", t, 0) != 0)
    error (1, errno, "utimensat failed");

  if (fstat64 (fd, &st2) != 0)
    error (1, errno, "fstat failed");

  if (st2.st_atim.tv_sec != st1.st_atim.tv_sec
      || st2.st_atim.tv_nsec != st1.st_atim.tv_nsec)
    {
      puts ("mtim changed from original time");
      status = 1;
    }
  if (st2.st_mtim.tv_sec != st1.st_mtim.tv_sec
      || st2.st_mtim.tv_nsec != st1.st_mtim.tv_nsec)
    {
      puts ("mtim not set");
      status = 1;
    }
  if (status != 0)
    goto out;

  sleep (2);

  t[0].tv_sec = 0;
  t[0].tv_nsec = UTIME_NOW;
  t[1].tv_sec = 0;
  t[1].tv_nsec = UTIME_NOW;
  if (syscall(__NR_utimensat, AT_FDCWD, "ttt", t, 0) != 0)
    error (1, errno, "utimensat failed");

  if (fstat64 (fd, &st2) != 0)
    error (1, errno, "fstat failed");

  struct timeval tv;
  gettimeofday(&tv,NULL);

  if (st2.st_atim.tv_sec <= st1.st_atim.tv_sec
      || st2.st_atim.tv_sec > tv.tv_sec)
    {
      puts ("atim not set to NOW");
      status = 1;
    }
  if (st2.st_mtim.tv_sec <= st1.st_mtim.tv_sec
      || st2.st_mtim.tv_sec > tv.tv_sec)
    {
      puts ("mtim not set to NOW");
      status = 1;
    }

  if (symlink ("ttt", "tttsym") != 0)
    error (1, errno, "cannot create symlink");

  t[0].tv_sec = 0;
  t[0].tv_nsec = 0;
  t[1].tv_sec = 0;
  t[1].tv_nsec = 0;
  if (syscall(__NR_utimensat, AT_FDCWD, "tttsym", t, AT_SYMLINK_NOFOLLOW) != 0)
    error (1, errno, "utimensat failed");

  if (lstat64 ("tttsym", &st2) != 0)
    error (1, errno, "lstat failed");

  if (st2.st_atim.tv_sec != 0 || st2.st_atim.tv_nsec != 0)
    {
      puts ("symlink atim not reset to zero");
      status = 1;
    }
  if (st2.st_mtim.tv_sec != 0 || st2.st_mtim.tv_nsec != 0)
    {
      puts ("symlink mtim not reset to zero");
      status = 1;
    }
  if (status != 0)
    goto out;

  t[0].tv_sec = 1;
  t[0].tv_nsec = 0;
  t[1].tv_sec = 1;
  t[1].tv_nsec = 0;
  if (syscall(__NR_utimensat, fd, NULL, t, 0) != 0)
    error (1, errno, "utimensat failed");

  if (fstat64 (fd, &st2) != 0)
    error (1, errno, "fstat failed");

  if (st2.st_atim.tv_sec != 1 || st2.st_atim.tv_nsec != 0)
    {
      puts ("atim not reset to one");
      status = 1;
    }
  if (st2.st_mtim.tv_sec != 1 || st2.st_mtim.tv_nsec != 0)
    {
      puts ("mtim not reset to one");
      status = 1;
    }

  if (status == 0)
     puts ("all OK");

 out:
  close (fd);
  unlink ("ttt");
  unlink ("tttsym");

  return status;
}

[akpm@linux-foundation.org: add missing i386 syscall table entry]
Signed-off-by: Ulrich Drepper <drepper@redhat.com>
Cc: Alexey Dobriyan <adobriyan@openvz.org>
Cc: Michael Kerrisk <mtk-manpages@gmx.net>
Cc: <linux-arch@vger.kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 10 changed files with 172 additions and 75 deletions Side-by-side Diff

arch/alpha/kernel/osf_sys.c
... ... @@ -953,15 +953,25 @@
953 953 asmlinkage int
954 954 osf_utimes(char __user *filename, struct timeval32 __user *tvs)
955 955 {
956   - struct timeval ktvs[2];
  956 + struct timespec tv[2];
957 957  
958 958 if (tvs) {
  959 + struct timeval ktvs[2];
959 960 if (get_tv32(&ktvs[0], &tvs[0]) ||
960 961 get_tv32(&ktvs[1], &tvs[1]))
961 962 return -EFAULT;
  963 +
  964 + if (ktvs[0].tv_usec < 0 || ktvs[0].tv_usec >= 1000000 ||
  965 + ktvs[1].tv_usec < 0 || ktvs[1].tv_usec >= 1000000)
  966 + return -EINVAL;
  967 +
  968 + tv[0].tv_sec = ktvs[0].tv_sec;
  969 + tv[0].tv_nsec = 1000 * ktvs[0].tv_usec;
  970 + tv[1].tv_sec = ktvs[1].tv_sec;
  971 + tv[1].tv_nsec = 1000 * ktvs[1].tv_usec;
962 972 }
963 973  
964   - return do_utimes(AT_FDCWD, filename, tvs ? ktvs : NULL);
  974 + return do_utimes(AT_FDCWD, filename, tvs ? tv : NULL, 0);
965 975 }
966 976  
967 977 #define MAX_SELECT_SECONDS \
arch/i386/kernel/syscall_table.S
... ... @@ -319,4 +319,5 @@
319 319 .long sys_move_pages
320 320 .long sys_getcpu
321 321 .long sys_epoll_pwait
  322 + .long sys_utimensat /* 320 */
arch/sparc64/kernel/sys_sparc32.c
... ... @@ -775,15 +775,25 @@
775 775 asmlinkage long sys32_utimes(char __user *filename,
776 776 struct compat_timeval __user *tvs)
777 777 {
778   - struct timeval ktvs[2];
  778 + struct timespec tv[2];
779 779  
780 780 if (tvs) {
  781 + struct timeval ktvs[2];
781 782 if (get_tv32(&ktvs[0], tvs) ||
782 783 get_tv32(&ktvs[1], 1+tvs))
783 784 return -EFAULT;
  785 +
  786 + if (ktvs[0].tv_usec < 0 || ktvs[0].tv_usec >= 1000000 ||
  787 + ktvs[1].tv_usec < 0 || ktvs[1].tv_usec >= 1000000)
  788 + return -EINVAL;
  789 +
  790 + tv[0].tv_sec = ktvs[0].tv_sec;
  791 + tv[0].tv_nsec = 1000 * ktvs[0].tv_usec;
  792 + tv[1].tv_sec = ktvs[1].tv_sec;
  793 + tv[1].tv_nsec = 1000 * ktvs[1].tv_usec;
784 794 }
785 795  
786   - return do_utimes(AT_FDCWD, filename, (tvs ? &ktvs[0] : NULL));
  796 + return do_utimes(AT_FDCWD, filename, tvs ? tv : NULL);
787 797 }
788 798  
789 799 /* These are here just in case some old sparc32 binary calls it. */
arch/x86_64/ia32/ia32entry.S
... ... @@ -710,10 +710,11 @@
710 710 .quad compat_sys_get_robust_list
711 711 .quad sys_splice
712 712 .quad sys_sync_file_range
713   - .quad sys_tee
  713 + .quad sys_tee /* 315 */
714 714 .quad compat_sys_vmsplice
715 715 .quad compat_sys_move_pages
716 716 .quad sys_getcpu
717 717 .quad sys_epoll_pwait
  718 + .quad compat_sys_utimensat /* 320 */
718 719 ia32_syscall_end:
... ... @@ -77,30 +77,57 @@
77 77 */
78 78 asmlinkage long compat_sys_utime(char __user *filename, struct compat_utimbuf __user *t)
79 79 {
80   - struct timeval tv[2];
  80 + struct timespec tv[2];
81 81  
82 82 if (t) {
83 83 if (get_user(tv[0].tv_sec, &t->actime) ||
84 84 get_user(tv[1].tv_sec, &t->modtime))
85 85 return -EFAULT;
86   - tv[0].tv_usec = 0;
87   - tv[1].tv_usec = 0;
  86 + tv[0].tv_nsec = 0;
  87 + tv[1].tv_nsec = 0;
88 88 }
89   - return do_utimes(AT_FDCWD, filename, t ? tv : NULL);
  89 + return do_utimes(AT_FDCWD, filename, t ? tv : NULL, 0);
90 90 }
91 91  
  92 +asmlinkage long compat_sys_utimensat(unsigned int dfd, char __user *filename, struct compat_timespec __user *t, int flags)
  93 +{
  94 + struct timespec tv[2];
  95 +
  96 + if (t) {
  97 + if (get_compat_timespec(&tv[0], &t[0]) ||
  98 + get_compat_timespec(&tv[1], &t[1]))
  99 + return -EFAULT;
  100 +
  101 + if ((tv[0].tv_nsec == UTIME_OMIT || tv[0].tv_nsec == UTIME_NOW)
  102 + && tv[0].tv_sec != 0)
  103 + return -EINVAL;
  104 + if ((tv[1].tv_nsec == UTIME_OMIT || tv[1].tv_nsec == UTIME_NOW)
  105 + && tv[1].tv_sec != 0)
  106 + return -EINVAL;
  107 +
  108 + if (tv[0].tv_nsec == UTIME_OMIT && tv[1].tv_nsec == UTIME_OMIT)
  109 + return 0;
  110 + }
  111 + return do_utimes(dfd, filename, t ? tv : NULL, flags);
  112 +}
  113 +
92 114 asmlinkage long compat_sys_futimesat(unsigned int dfd, char __user *filename, struct compat_timeval __user *t)
93 115 {
94   - struct timeval tv[2];
  116 + struct timespec tv[2];
95 117  
96 118 if (t) {
97 119 if (get_user(tv[0].tv_sec, &t[0].tv_sec) ||
98   - get_user(tv[0].tv_usec, &t[0].tv_usec) ||
  120 + get_user(tv[0].tv_nsec, &t[0].tv_usec) ||
99 121 get_user(tv[1].tv_sec, &t[1].tv_sec) ||
100   - get_user(tv[1].tv_usec, &t[1].tv_usec))
  122 + get_user(tv[1].tv_nsec, &t[1].tv_usec))
101 123 return -EFAULT;
  124 + if (tv[0].tv_nsec >= 1000000 || tv[0].tv_nsec < 0 ||
  125 + tv[1].tv_nsec >= 1000000 || tv[1].tv_nsec < 0)
  126 + return -EINVAL;
  127 + tv[0].tv_nsec *= 1000;
  128 + tv[1].tv_nsec *= 1000;
102 129 }
103   - return do_utimes(dfd, filename, t ? tv : NULL);
  130 + return do_utimes(dfd, filename, t ? tv : NULL, 0);
104 131 }
105 132  
106 133 asmlinkage long compat_sys_utimes(char __user *filename, struct compat_timeval __user *t)
1 1 #include <linux/compiler.h>
  2 +#include <linux/file.h>
2 3 #include <linux/fs.h>
3 4 #include <linux/linkage.h>
4 5 #include <linux/namei.h>
5 6 #include <linux/sched.h>
  7 +#include <linux/stat.h>
6 8 #include <linux/utime.h>
7 9 #include <asm/uaccess.h>
8 10 #include <asm/unistd.h>
9 11  
10 12  
11 13  
12 14  
... ... @@ -20,54 +22,18 @@
20 22 * must be owner or have write permission.
21 23 * Else, update from *times, must be owner or super user.
22 24 */
23   -asmlinkage long sys_utime(char __user * filename, struct utimbuf __user * times)
  25 +asmlinkage long sys_utime(char __user *filename, struct utimbuf __user *times)
24 26 {
25   - int error;
26   - struct nameidata nd;
27   - struct inode * inode;
28   - struct iattr newattrs;
  27 + struct timespec tv[2];
29 28  
30   - error = user_path_walk(filename, &nd);
31   - if (error)
32   - goto out;
33   - inode = nd.dentry->d_inode;
34   -
35   - error = -EROFS;
36   - if (IS_RDONLY(inode))
37   - goto dput_and_out;
38   -
39   - /* Don't worry, the checks are done in inode_change_ok() */
40   - newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
41 29 if (times) {
42   - error = -EPERM;
43   - if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
44   - goto dput_and_out;
45   -
46   - error = get_user(newattrs.ia_atime.tv_sec, &times->actime);
47   - newattrs.ia_atime.tv_nsec = 0;
48   - if (!error)
49   - error = get_user(newattrs.ia_mtime.tv_sec, &times->modtime);
50   - newattrs.ia_mtime.tv_nsec = 0;
51   - if (error)
52   - goto dput_and_out;
53   -
54   - newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
55   - } else {
56   - error = -EACCES;
57   - if (IS_IMMUTABLE(inode))
58   - goto dput_and_out;
59   -
60   - if (current->fsuid != inode->i_uid &&
61   - (error = vfs_permission(&nd, MAY_WRITE)) != 0)
62   - goto dput_and_out;
  30 + if (get_user(tv[0].tv_sec, &times->actime) ||
  31 + get_user(tv[1].tv_sec, &times->modtime))
  32 + return -EFAULT;
  33 + tv[0].tv_nsec = 0;
  34 + tv[1].tv_nsec = 0;
63 35 }
64   - mutex_lock(&inode->i_mutex);
65   - error = notify_change(nd.dentry, &newattrs);
66   - mutex_unlock(&inode->i_mutex);
67   -dput_and_out:
68   - path_release(&nd);
69   -out:
70   - return error;
  36 + return do_utimes(AT_FDCWD, filename, times ? tv : NULL, 0);
71 37 }
72 38  
73 39 #endif
74 40  
75 41  
76 42  
77 43  
78 44  
... ... @@ -76,19 +42,39 @@
76 42 * must be owner or have write permission.
77 43 * Else, update from *times, must be owner or super user.
78 44 */
79   -long do_utimes(int dfd, char __user *filename, struct timeval *times)
  45 +long do_utimes(int dfd, char __user *filename, struct timespec *times, int flags)
80 46 {
81 47 int error;
82 48 struct nameidata nd;
83   - struct inode * inode;
  49 + struct dentry *dentry;
  50 + struct inode *inode;
84 51 struct iattr newattrs;
  52 + struct file *f = NULL;
85 53  
86   - error = __user_walk_fd(dfd, filename, LOOKUP_FOLLOW, &nd);
87   -
88   - if (error)
  54 + error = -EINVAL;
  55 + if (flags & ~AT_SYMLINK_NOFOLLOW)
89 56 goto out;
90   - inode = nd.dentry->d_inode;
91 57  
  58 + if (filename == NULL && dfd != AT_FDCWD) {
  59 + error = -EINVAL;
  60 + if (flags & AT_SYMLINK_NOFOLLOW)
  61 + goto out;
  62 +
  63 + error = -EBADF;
  64 + f = fget(dfd);
  65 + if (!f)
  66 + goto out;
  67 + dentry = f->f_path.dentry;
  68 + } else {
  69 + error = __user_walk_fd(dfd, filename, (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW, &nd);
  70 + if (error)
  71 + goto out;
  72 +
  73 + dentry = nd.dentry;
  74 + }
  75 +
  76 + inode = dentry->d_inode;
  77 +
92 78 error = -EROFS;
93 79 if (IS_RDONLY(inode))
94 80 goto dput_and_out;
... ... @@ -100,11 +86,21 @@
100 86 if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
101 87 goto dput_and_out;
102 88  
103   - newattrs.ia_atime.tv_sec = times[0].tv_sec;
104   - newattrs.ia_atime.tv_nsec = times[0].tv_usec * 1000;
105   - newattrs.ia_mtime.tv_sec = times[1].tv_sec;
106   - newattrs.ia_mtime.tv_nsec = times[1].tv_usec * 1000;
107   - newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
  89 + if (times[0].tv_nsec == UTIME_OMIT)
  90 + newattrs.ia_valid &= ~ATTR_ATIME;
  91 + else if (times[0].tv_nsec != UTIME_NOW) {
  92 + newattrs.ia_atime.tv_sec = times[0].tv_sec;
  93 + newattrs.ia_atime.tv_nsec = times[0].tv_nsec;
  94 + newattrs.ia_valid |= ATTR_ATIME_SET;
  95 + }
  96 +
  97 + if (times[1].tv_nsec == UTIME_OMIT)
  98 + newattrs.ia_valid &= ~ATTR_MTIME;
  99 + else if (times[1].tv_nsec != UTIME_NOW) {
  100 + newattrs.ia_mtime.tv_sec = times[1].tv_sec;
  101 + newattrs.ia_mtime.tv_nsec = times[1].tv_nsec;
  102 + newattrs.ia_valid |= ATTR_MTIME_SET;
  103 + }
108 104 } else {
109 105 error = -EACCES;
110 106 if (IS_IMMUTABLE(inode))
111 107  
112 108  
113 109  
114 110  
... ... @@ -115,21 +111,67 @@
115 111 goto dput_and_out;
116 112 }
117 113 mutex_lock(&inode->i_mutex);
118   - error = notify_change(nd.dentry, &newattrs);
  114 + error = notify_change(dentry, &newattrs);
119 115 mutex_unlock(&inode->i_mutex);
120 116 dput_and_out:
121   - path_release(&nd);
  117 + if (f)
  118 + fput(f);
  119 + else
  120 + path_release(&nd);
122 121 out:
123 122 return error;
124 123 }
125 124  
  125 +asmlinkage long sys_utimensat(int dfd, char __user *filename, struct timespec __user *utimes, int flags)
  126 +{
  127 + struct timespec tstimes[2];
  128 +
  129 + if (utimes) {
  130 + if (copy_from_user(&tstimes, utimes, sizeof(tstimes)))
  131 + return -EFAULT;
  132 + if ((tstimes[0].tv_nsec == UTIME_OMIT ||
  133 + tstimes[0].tv_nsec == UTIME_NOW) &&
  134 + tstimes[0].tv_sec != 0)
  135 + return -EINVAL;
  136 + if ((tstimes[1].tv_nsec == UTIME_OMIT ||
  137 + tstimes[1].tv_nsec == UTIME_NOW) &&
  138 + tstimes[1].tv_sec != 0)
  139 + return -EINVAL;
  140 +
  141 + /* Nothing to do, we must not even check the path. */
  142 + if (tstimes[0].tv_nsec == UTIME_OMIT &&
  143 + tstimes[1].tv_nsec == UTIME_OMIT)
  144 + return 0;
  145 + }
  146 +
  147 + return do_utimes(dfd, filename, utimes ? tstimes : NULL, flags);
  148 +}
  149 +
126 150 asmlinkage long sys_futimesat(int dfd, char __user *filename, struct timeval __user *utimes)
127 151 {
128 152 struct timeval times[2];
  153 + struct timespec tstimes[2];
129 154  
130   - if (utimes && copy_from_user(&times, utimes, sizeof(times)))
131   - return -EFAULT;
132   - return do_utimes(dfd, filename, utimes ? times : NULL);
  155 + if (utimes) {
  156 + if (copy_from_user(&times, utimes, sizeof(times)))
  157 + return -EFAULT;
  158 +
  159 + /* This test is needed to catch all invalid values. If we
  160 + would test only in do_utimes we would miss those invalid
  161 + values truncated by the multiplication with 1000. Note
  162 + that we also catch UTIME_{NOW,OMIT} here which are only
  163 + valid for utimensat. */
  164 + if (times[0].tv_usec >= 1000000 || times[0].tv_usec < 0 ||
  165 + times[1].tv_usec >= 1000000 || times[1].tv_usec < 0)
  166 + return -EINVAL;
  167 +
  168 + tstimes[0].tv_sec = times[0].tv_sec;
  169 + tstimes[0].tv_nsec = 1000 * times[0].tv_usec;
  170 + tstimes[1].tv_sec = times[1].tv_sec;
  171 + tstimes[1].tv_nsec = 1000 * times[1].tv_usec;
  172 + }
  173 +
  174 + return do_utimes(dfd, filename, utimes ? tstimes : NULL, 0);
133 175 }
134 176  
135 177 asmlinkage long sys_utimes(char __user *filename, struct timeval __user *utimes)
include/asm-i386/unistd.h
... ... @@ -325,10 +325,11 @@
325 325 #define __NR_move_pages 317
326 326 #define __NR_getcpu 318
327 327 #define __NR_epoll_pwait 319
  328 +#define __NR_utimensat 320
328 329  
329 330 #ifdef __KERNEL__
330 331  
331   -#define NR_syscalls 320
  332 +#define NR_syscalls 321
332 333  
333 334 #define __ARCH_WANT_IPC_PARSE_VERSION
334 335 #define __ARCH_WANT_OLD_READDIR
include/asm-x86_64/unistd.h
... ... @@ -619,6 +619,8 @@
619 619 __SYSCALL(__NR_vmsplice, sys_vmsplice)
620 620 #define __NR_move_pages 279
621 621 __SYSCALL(__NR_move_pages, sys_move_pages)
  622 +#define __NR_utimensat 280
  623 +__SYSCALL(__NR_utimensat, sys_utimensat)
622 624  
623 625 #ifndef __NO_STUBS
624 626 #define __ARCH_WANT_OLD_READDIR
include/linux/stat.h
... ... @@ -53,6 +53,9 @@
53 53 #define S_IWUGO (S_IWUSR|S_IWGRP|S_IWOTH)
54 54 #define S_IXUGO (S_IXUSR|S_IXGRP|S_IXOTH)
55 55  
  56 +#define UTIME_NOW ((1l << 30) - 1l)
  57 +#define UTIME_OMIT ((1l << 30) - 2l)
  58 +
56 59 #include <linux/types.h>
57 60 #include <linux/time.h>
58 61  
include/linux/time.h
... ... @@ -109,7 +109,7 @@
109 109 extern int do_settimeofday(struct timespec *tv);
110 110 extern int do_sys_settimeofday(struct timespec *tv, struct timezone *tz);
111 111 #define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
112   -extern long do_utimes(int dfd, char __user *filename, struct timeval *times);
  112 +extern long do_utimes(int dfd, char __user *filename, struct timespec *times, int flags);
113 113 struct itimerval;
114 114 extern int do_setitimer(int which, struct itimerval *value,
115 115 struct itimerval *ovalue);