Rename ioctl.c to xfsctl.c manually.
[xfstests-dev.git] / src / xfsctl.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 #include <xfs/libxfs.h>
34 #include <xfs/jdm.h>
35
36 /* simple test program to try out a bunch of xfsctls:
37  *     XFS_IOC_FSCOUNTS
38  *     XFS_IOC_GET_RESBLKS
39  *     XFS_IOC_SET_RESBLKS
40  *     XFS_IOC_PATH_TO_FSHANDLE
41  *     XFS_IOC_PATH_TO_HANDLE
42  *     XFS_IOC_FD_TO_HANDLE
43  *     XFS_IOC_OPEN_BY_HANDLE
44  *     XFS_IOC_READLINK_BY_HANDLE
45 */
46
47     
48 void fscounts(char *fname, int fsfd)
49 {
50     xfs_fsop_counts_t   counts;
51     int                 ret;
52     
53     ret=xfsctl(fname, fsfd, XFS_IOC_FSCOUNTS, &counts);
54     if (ret) {
55         perror("xfsctl(XFS_IOC_FSCOUNTS)");
56         exit(1);
57     }
58
59     printf("XFS_IOC_FSCOUNTS-\n    freedata: %lld freertx: %lld freeino: %lld allocino: %lld\n",
60             counts.freedata, counts.freertx, counts.freeino, counts.allocino);
61 }
62     
63 __u64 getresblks(char *fname, int fsfd)
64 {
65     xfs_fsop_resblks_t  res;
66     int                 ret;
67     
68     ret=xfsctl(fname, fsfd, XFS_IOC_GET_RESBLKS, &res);
69     if (ret) {
70         perror("xfsctl(XFS_IOC_GET_RESBLKS)");
71         exit(1);
72     }
73     
74     printf("XFS_IOC_GET_RESBLKS-\n    resblks: %lld blksavail: %lld\n",
75             res.resblks, res.resblks_avail);
76     
77     return res.resblks;
78 }
79     
80 __u64 setresblks(char *fname, int fsfd, __u64 blks)
81 {
82     xfs_fsop_resblks_t  res;
83     int                 ret;
84     
85     res.resblks=blks;
86     ret=xfsctl(fname, fsfd, XFS_IOC_SET_RESBLKS, &res);
87     if (ret) {
88         perror("xfsctl(XFS_IOC_SET_RESBLKS)");
89         exit(1);
90     }
91     
92     printf("XFS_IOC_SET_RESBLKS-\n    resblks: %lld blksavail: %lld\n",
93             res.resblks, res.resblks_avail);
94     
95     return res.resblks;
96 }
97
98 void handle_print(void *handle, int handlen)
99 {
100     char *p=handle;
101     if (!handle||!handlen) {
102         printf("%s",handle?"<zero len>":"<NULL>");
103         return;
104     };
105     
106     printf("#");
107     while (handlen--)
108         printf("%02x", *p++);   
109 }
110
111 void stat_print(int fd)
112 {
113     struct stat buf;
114     
115     if (fstat(fd, &buf)) {
116         perror("stat");
117         exit(1);
118     }
119     printf("dev: %llu ino: %llu mode: %o\n",
120             (__u64)buf.st_dev, (__u64)buf.st_ino, buf.st_mode);
121 }
122     
123
124 void handle(char *fname, int fsfd, char *path)
125 {
126     xfs_fsop_handlereq_t    handle;
127     char                    buffer[1024];
128     char                    link[1024];
129     int                     ret;
130     __u32                   len;
131     __u32                   linklen;
132     int                     fd;
133     
134     handle.path=path;
135     handle.ohandle=buffer;
136     handle.ohandlen=&len;
137     ret=xfsctl(fname, fsfd, XFS_IOC_PATH_TO_FSHANDLE, &handle);
138     if (ret) {
139         perror("xfsctl(XFS_IOC_PATH_TO_FSHANDLE)");
140         exit(1);
141     }
142     printf("XFS_IOC_PATH_TO_FSHANDLE-\n    handle: ");
143     handle_print(handle.ohandle, *handle.ohandlen);
144     printf("\n");
145     
146     fd=open(path,O_RDONLY);
147     if (fd<0) {
148         perror("open");
149         exit(1);
150     }
151     handle.path=NULL;
152     handle.fd=fd;
153     handle.ohandle=buffer;
154     handle.ohandlen=&len;
155     ret=xfsctl(fname, fsfd, XFS_IOC_FD_TO_HANDLE, &handle);
156     if (ret) {
157         perror("ioctl(XFS_IOC_FD_TO_HANDLE)");
158         exit(1);
159     }
160     
161     printf("XFS_IOC_FD_TO_HANDLE-\n    path: %s\n    handle: ", path);
162     handle_print(handle.ohandle, *handle.ohandlen);
163     printf("\n");
164     
165     close(fd);
166     
167     handle.path=NULL;
168     handle.fd=-1;
169     handle.ihandle=buffer;
170     handle.ihandlen=len;
171     handle.ohandle=NULL;
172     handle.ohandlen=NULL;
173     ret=xfsctl(fname, fsfd, XFS_IOC_OPEN_BY_HANDLE, &handle);
174     if (ret<0) {
175         perror("xfsctl(XFS_IOC_OPEN_BY_HANDLE)");
176         exit(1);
177     }
178     printf("XFS_IOC_OPEN_BY_HANDLE-\n    handle: ");
179     handle_print(handle.ihandle, handle.ihandlen);
180     printf("\n    fd: %d\n    stat- ", ret);
181     stat_print(ret);
182     close(ret);
183     
184     handle.path=path;
185     handle.ohandle=buffer;
186     handle.ohandlen=&len;
187     ret=xfsctl(fname, fsfd, XFS_IOC_PATH_TO_HANDLE, &handle);
188     if (ret) {
189         perror("xfsctl(XFS_IOC_PATH_TO_HANDLE)");
190         exit(1);
191     }
192     printf("XFS_IOC_PATH_TO_HANDLE-\n    path: %s\n    handle: ", path);
193     handle_print(handle.ohandle, *handle.ohandlen);
194     printf("\n");
195
196     handle.path=NULL;
197     handle.fd=-1;
198     handle.ihandle=buffer;
199     handle.ihandlen=len;
200     handle.ohandle=link;
201     linklen=sizeof(link);
202     handle.ohandlen=&linklen;
203     ret=xfsctl(fname, fsfd, XFS_IOC_READLINK_BY_HANDLE, &handle);
204     if (ret<0) {
205         perror("xfsctl(XFS_IOC_READLINK_BY_HANDLE)");
206         fprintf(stderr,"ERROR IGNORED\n");
207     } else {
208         printf("XFS_IOC_READLINK_BY_HANDLE-\n    handle: ");
209         handle_print(handle.ihandle, handle.ihandlen);
210         printf("\n    link=\"%*.*s\"\n", 
211                 ret, ret, (char*)handle.ohandle);
212     }
213 }
214
215 int
216 main(int argc, char **argv)
217 {
218     int                 fsfd;
219     
220     if (argc != 3) {
221         fprintf(stderr,"usage: %s <filesystem> <file/link in FS>\n",
222                 argv[0]);
223         exit(0);
224     }
225
226     fsfd = open(argv[1], O_RDONLY);
227     if (fsfd < 0) {
228         perror("open");
229         exit(1);
230     }
231     
232     /* XFS_IOC_FSCOUNTS */
233     fscounts(argv[0], fsfd);
234     /* XFS_IOC_GET_RESBLKS & XFS_IOC_SET_RESBLKS */
235     getresblks(argv[0], fsfd);
236     setresblks(argv[0], fsfd, 1000);
237     getresblks(argv[0], fsfd);
238     setresblks(argv[0], fsfd, 0);
239     /* TODO - XFS_IOC_FSINUMBERS */
240
241     /* XFS_IOC_PATH_TO_FSHANDLE */
242     /* XFS_IOC_PATH_TO_HANDLE */
243     /* XFS_IOC_FD_TO_HANDLE */
244     /* XFS_IOC_OPEN_BY_HANDLE */
245     /* XFS_IOC_READLINK_BY_HANDLE */
246     handle(argv[0], fsfd, argv[2]);
247     
248     return 0;
249 }