QA source updates and some associated test changes
[xfstests-dev.git] / src / feature.c
1 /*
2  * Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
3  * 
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of version 2 of the GNU General Public License as
6  * published by the Free Software Foundation.
7  * 
8  * This program is distributed in the hope that it would be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
11  * 
12  * Further, this software is distributed without any warranty that it is
13  * free of the rightful claim of any third person regarding infringement
14  * or the like.  Any license provided herein, whether implied or
15  * otherwise, applies only to this software file.  Patent licenses, if
16  * any, provided herein do not apply to combinations of this program with
17  * other software, or any other product whatsoever.
18  * 
19  * You should have received a copy of the GNU General Public License along
20  * with this program; if not, write the Free Software Foundation, Inc., 59
21  * Temple Place - Suite 330, Boston MA 02111-1307, USA.
22  * 
23  * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy,
24  * Mountain View, CA  94043, or:
25  * 
26  * http://www.sgi.com 
27  * 
28  * For further information regarding this notice, see: 
29  * 
30  * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/
31  */
32
33 /*
34  * Test for filesystem features on given mount point or device
35  *   -c  test for 32bit chown support (via libc)
36  *   -t  test for working rlimit/ftruncate64 (via libc)
37  *   -q  test for quota support (kernel compile option)
38  *   -u  test for user quota enforcement support (mount option)
39  *   -g  test for group quota enforcement support (mount option)
40  *   -U  test for user quota accounting support (mount option)
41  *   -G  test for group quota accounting support (mount option)
42  * Return code: 0 is true, anything else is error/not supported
43  */
44
45 #include <xfs/libxfs.h>
46 #include <sys/quota.h>
47 #include <sys/resource.h>
48 #include <signal.h>
49 #include <xfs/xqm.h>
50
51 int verbose = 0;
52
53 void
54 usage(void)
55 {
56         fprintf(stderr, "Usage: feature [-v] -<q|u|g|U|G> <filesystem>\n");
57         fprintf(stderr, "       feature [-v] -c <file>\n");
58         fprintf(stderr, "       feature [-v] -t <file>\n");
59         exit(1);
60 }
61
62 int check_big_ID(char *filename)
63 {
64         struct stat64   sbuf;
65
66         memset(&sbuf, 0, sizeof(struct stat64));
67         if (lstat64(filename, &sbuf) < 0) {
68                 fprintf(stderr, "lstat64 failed on ");
69                 perror(filename);
70                 return(1);
71         }
72
73         /* 98789 is greater than 2^16 (65536) */
74         if ((__u32)sbuf.st_uid == 98789 || (__u32)sbuf.st_gid == 98789)
75                 return(0);
76         if (verbose)
77                 fprintf(stderr, "lstat64 on %s gave uid=%d, gid=%d\n",
78                         filename, sbuf.st_uid, sbuf.st_gid);
79         return(1);
80 }
81
82 int
83 haschown32(char *filename)
84 {
85         if (check_big_ID(filename) == 0)
86                 return(0);
87
88         if (chown(filename, 98789, 98789) < 0) {
89                 fprintf(stderr, "chown failed on ");
90                 perror(filename);
91                 return(1);
92         }
93
94         if (check_big_ID(filename) == 0)
95                 return(0);
96         return (1);
97 }
98
99 int
100 hastruncate64(char *filename)
101 {
102         struct rlimit64 rlimit64;
103         off64_t bigoff = 4294967307;    /* > 2^32 */
104         struct stat64 bigst;
105         int fd;
106
107         getrlimit64(RLIMIT_FSIZE, &rlimit64);
108         rlimit64.rlim_cur = RLIM64_INFINITY;
109         setrlimit64(RLIMIT_FSIZE, &rlimit64);
110
111         signal(SIGXFSZ, SIG_IGN);
112
113         if ((fd = open(filename, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR)) < 0) {
114                 fprintf(stderr, "open failed on ");
115                 perror(filename);
116                 return(1);
117         }
118
119         if (ftruncate64(fd, bigoff) < 0)
120                 return(1);
121
122         if (fstat64(fd, &bigst) < 0) {
123                 fprintf(stderr, "fstat64 failed on ");
124                 perror(filename);
125                 return(1);
126         }
127
128         if (verbose)
129                 fprintf(stderr, "fstat64 on %s gave sz=%lld (truncsz=%lld)\n",
130                         filename, bigst.st_size, bigoff);
131
132         if (bigst.st_size != bigoff)
133                 return(1);
134         return(0);
135 }
136
137 int
138 hasxfsquota(int type, int q, char *device)
139 {
140         fs_quota_stat_t qstat;
141         int             qcmd;
142
143         if (q == 0)
144                 return (access("/proc/fs/xfs/xqm", F_OK) < 0);
145
146         memset(&qstat, 0, sizeof(fs_quota_stat_t));
147         qcmd = QCMD(Q_XGETQSTAT, type);
148         if (quotactl(qcmd, device, 0, (caddr_t)&qstat) < 0) {
149                 if (verbose)
150                         perror("quotactl");
151                 return (1);
152         }
153         else if (q == XFS_QUOTA_UDQ_ENFD && qstat.qs_flags & XFS_QUOTA_UDQ_ENFD)
154                 return (0);
155         else if (q == XFS_QUOTA_GDQ_ENFD && qstat.qs_flags & XFS_QUOTA_GDQ_ENFD)
156                 return (0);
157         else if (q == XFS_QUOTA_UDQ_ACCT && qstat.qs_flags & XFS_QUOTA_UDQ_ACCT)
158                 return (0);
159         else if (q == XFS_QUOTA_GDQ_ACCT && qstat.qs_flags & XFS_QUOTA_GDQ_ACCT)
160                 return (0);
161         if (verbose)
162                 fprintf(stderr, "quota type (%d) not available\n", q);
163         return (1);
164 }
165
166 int
167 main(int argc, char **argv)
168 {
169         int     c;
170         int     cflag = 0;
171         int     tflag = 0;
172         int     gflag = 0;
173         int     Gflag = 0;
174         int     qflag = 0;
175         int     uflag = 0;
176         int     Uflag = 0;
177         char    *fs;
178
179         while ((c = getopt(argc, argv, "ctgGquUv")) != EOF) {
180                 switch (c) {
181                 case 'c':
182                         cflag++;
183                         break;
184                 case 't':
185                         tflag++;
186                         break;
187                 case 'g':
188                         gflag++;
189                         break;
190                 case 'G':
191                         Gflag++;
192                         break;
193                 case 'q':
194                         qflag++;
195                         break;
196                 case 'u':
197                         uflag++;
198                         break;
199                 case 'U':
200                         Uflag++;
201                         break;
202                 case 'v':
203                         verbose++;
204                         break;
205                 default:
206                         usage();
207                 }
208         }
209
210         if (!cflag && !tflag && !uflag && !gflag && !qflag && !Uflag && !Gflag)
211                 usage();
212         if (optind != argc-1)
213                 usage();
214         fs = argv[argc-1];
215
216         if (cflag)
217                 return(haschown32(fs));
218         if (tflag)
219                 return(hastruncate64(fs));
220         if (qflag)
221                 return(hasxfsquota(0, 0, fs));
222         if (gflag)
223                 return(hasxfsquota(GRPQUOTA, XFS_QUOTA_GDQ_ENFD, fs));
224         if (uflag)
225                 return(hasxfsquota(USRQUOTA, XFS_QUOTA_UDQ_ENFD, fs));
226         if (Gflag)
227                 return(hasxfsquota(GRPQUOTA, XFS_QUOTA_GDQ_ACCT, fs));
228         if (Uflag)
229                 return(hasxfsquota(USRQUOTA, XFS_QUOTA_UDQ_ACCT, fs));
230
231         fprintf(stderr, "feature: dunno what you're doing?\n");
232         return(1);
233 }