Whamcloud - gitweb
It's been a good day: chmod/chown and friends now work for Lustre Light.
[fs/lustre-release.git] / lustre / include / linux / lustre_idl.h
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  *  Copyright (C) 2001 Cluster File Systems, Inc. <braam@clusterfs.com>
5  *
6  *   This file is part of Lustre, http://www.lustre.org.
7  *
8  *   Lustre is free software; you can redistribute it and/or
9  *   modify it under the terms of version 2 of the GNU General Public
10  *   License as published by the Free Software Foundation.
11  *
12  *   Lustre is distributed in the hope that it will be useful,
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *   GNU General Public License for more details.
16  *
17  *   You should have received a copy of the GNU General Public License
18  *   along with Lustre; if not, write to the Free Software
19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  *
21  * (Un)packing of OST requests
22  */
23
24 #ifndef __LUSTRE_IDL_H__
25 #define __LUSTRE_IDL_H__
26 #ifdef __KERNEL__
27 #include <linux/ioctl.h>
28 #include <asm/types.h>
29
30 #include <linux/types.h>
31 #else 
32 #define __KERNEL__
33 #include <linux/list.h>
34 #undef __KERNEL__
35 #include <stdint.h>
36 #endif
37 /* 
38  * this file contains all data structures used in Lustre interfaces:
39  * - obdo and obd_request records
40  * - mds_request records
41  * - ioctl's
42  */ 
43
44
45 /* 
46  *   OST requests: OBDO & OBD request records
47  */
48
49
50 /* opcodes */
51 #define OST_GET_INFO  6
52 #define OST_CONNECT  7
53 #define OST_DISCONNECT 8
54 #define OST_GETATTR  1
55 #define OST_SETATTR  2
56 #define OST_BRW      3
57 #define OST_CREATE   4
58 #define OST_DESTROY  5
59
60 /* packet types */
61 #define OST_TYPE_REQ 1
62 #define OST_TYPE_REP 2
63 #define OST_TYPE_ERR 3
64
65 struct ost_req_hdr { 
66         __u32 opc;
67         __u64 seqno;
68         __u32 status;
69         __u32 type;
70 };
71
72 struct ost_rep_hdr { 
73         __u32 opc;
74         __u64 seqno;
75         __u32 status;
76         __u32 type;
77 };
78
79 typedef uint64_t        obd_id;
80 typedef uint64_t        obd_gr;
81 typedef uint64_t        obd_time;
82 typedef uint64_t        obd_size;
83 typedef uint64_t        obd_off;
84 typedef uint64_t        obd_blocks;
85 typedef uint32_t        obd_blksize;
86 typedef uint32_t        obd_mode;
87 typedef uint32_t        obd_uid;
88 typedef uint32_t        obd_gid;
89 typedef uint32_t        obd_rdev;
90 typedef uint32_t        obd_flag;
91 typedef uint32_t        obd_count;
92
93 #define OBD_FL_INLINEDATA       (0x00000001UL)  
94 #define OBD_FL_OBDMDEXISTS      (0x00000002UL)
95
96 #define OBD_INLINESZ    60
97 #define OBD_OBDMDSZ     60
98 /* Note: 64-bit types are 64-bit aligned in structure */
99 struct obdo {
100         obd_id                  o_id;
101         obd_gr                  o_gr;
102         obd_time                o_atime;
103         obd_time                o_mtime;
104         obd_time                o_ctime;
105         obd_size                o_size;
106         obd_blocks              o_blocks;
107         obd_blksize             o_blksize;
108         obd_mode                o_mode;
109         obd_uid                 o_uid;
110         obd_gid                 o_gid;
111         obd_flag                o_flags;
112         obd_flag                o_obdflags;
113         obd_count               o_nlink;
114         obd_count               o_generation;
115         obd_flag                o_valid;        /* hot fields in this obdo */
116         char                    o_inline[OBD_INLINESZ];
117         char                    o_obdmd[OBD_OBDMDSZ];
118         struct list_head        o_list;
119         struct obd_ops          *o_op;
120 };
121
122 #define OBD_MD_FLALL    (~0UL)
123 #define OBD_MD_FLID     (0x00000001UL)
124 #define OBD_MD_FLATIME  (0x00000002UL)
125 #define OBD_MD_FLMTIME  (0x00000004UL)
126 #define OBD_MD_FLCTIME  (0x00000008UL)
127 #define OBD_MD_FLSIZE   (0x00000010UL)
128 #define OBD_MD_FLBLOCKS (0x00000020UL)
129 #define OBD_MD_FLBLKSZ  (0x00000040UL)
130 #define OBD_MD_FLMODE   (0x00000080UL)
131 #define OBD_MD_FLTYPE   (0x00000100UL)
132 #define OBD_MD_FLUID    (0x00000200UL)
133 #define OBD_MD_FLGID    (0x00000400UL)
134 #define OBD_MD_FLFLAGS  (0x00000800UL)
135 #define OBD_MD_FLOBDFLG (0x00001000UL)
136 #define OBD_MD_FLNLINK  (0x00002000UL)
137 #define OBD_MD_FLGENER  (0x00004000UL)
138 #define OBD_MD_FLINLINE (0x00008000UL)
139 #define OBD_MD_FLOBDMD  (0x00010000UL)
140 #define OBD_MD_FLNOTOBD (~(OBD_MD_FLOBDMD | OBD_MD_FLOBDFLG | OBD_MD_FLBLOCKS))
141
142 /* request structure for OST's */
143
144 #define OST_REQ_HAS_OA1  0x1
145
146 struct ost_req_packed { 
147         __u32   connid;
148         __u32   cmd; 
149         struct obdo oa;
150         __u32   buflen1;
151         __u32   buflen2;
152         __u32   bufoffset1;
153         __u32   bufoffset2;
154 };
155
156 struct ost_rep_packed {
157         __u32   result;
158         __u32   connid;
159         struct obdo oa;
160         __u32   buflen1;
161         __u32   buflen2;
162         __u32   bufoffset1;
163         __u32   bufoffset2;
164 };
165
166 struct obd_buf { 
167         __u64 addr;       // address 
168         __u64 handle;     // DMA handle
169         __u64 matchbits;  // portals match bits
170         __u32 offset;     // first bit after addr that is relevant
171         __u32 size;       // size from addr + offset that needs moving
172 };
173
174 struct obd_bufref { 
175         obd_id    obj_id;
176         obd_gr    obj_gr;
177         __u64     offset;
178         __u32     size; 
179         __u32     flags;
180 }; 
181
182 /* reply structure for OST's */
183
184
185
186
187
188 /* 
189  *   MDS REQ RECORDS
190  */
191
192
193 #define MDS_TYPE_REQ 1
194 #define MDS_TYPE_REP 2
195 #define MDS_TYPE_ERR 3
196
197 #define MDS_GETATTR   1
198 #define MDS_REINT     2
199 #define MDS_READPAGE  3
200
201 #define REINT_SETATTR 1
202
203 struct mds_req_hdr { 
204         __u32 opc;
205         __u64 seqno;
206         __u32 status;
207         __u32 type;
208 };
209
210 struct ll_fid { 
211         __u64 id;
212         __u32 generation;
213         __u32 f_type;
214 };
215
216 struct niobuf { 
217         __u64 addr;
218 };
219
220 struct mds_rep_hdr { 
221         __u32 opc;
222         __u64 seqno;
223         __u32 status;
224         __u32 type;
225 };
226
227 struct mds_req_packed {
228         struct ll_fid        fid1;
229         struct ll_fid        fid2;
230         int                        namelen;
231         int                        tgtlen;
232         __u32                       opcode;
233         __u32                       valid;
234         __u32                       mode;
235         __u32                       uid;
236         __u32                       gid;
237         __u64                       size;
238         __u32                       mtime;
239         __u32                       ctime;
240         __u32                       atime;
241         __u32                       flags;
242         __u32                       major;
243         __u32                       minor;
244         __u32                       ino;
245         __u32                       nlink;
246         __u32                       generation;
247 };
248
249 struct mds_rep_packed {
250         struct ll_fid        fid1;
251         struct ll_fid        fid2;
252         int                        namelen;
253         int                        tgtlen;
254         __u32                       valid;
255         __u32                       mode;
256         __u32                       uid;
257         __u32                       gid;
258         __u64                       size;
259         __u32                       mtime;
260         __u32                       ctime;
261         __u32                       atime;
262         __u32                       flags;
263         __u32                       major;
264         __u32                       minor;
265         __u32                       ino;
266         __u32                       nlink;
267         __u32                       generation;
268 };
269
270
271 struct mds_rec_setattr { 
272         __u32           sa_len;
273         __u32           sa_opcode;
274         struct ll_fid   sa_fid;
275         __u32           sa_valid;
276         __u32           sa_mode;
277         __u32           sa_uid;
278         __u32           sa_gid;
279         __u64           sa_size;
280         __u64           sa_atime;
281         __u64           sa_mtime;
282         __u64           sa_ctime;
283         __u32           sa_attr_flags;
284 };
285
286 #ifdef __KERNEL__ 
287
288 static inline void ll_ino2fid(struct ll_fid *fid, ino_t ino, __u32 generation, int type)
289 {
290         fid->id = HTON__u64((__u64)ino);
291         fid->generation = HTON__u32(generation);
292         fid->f_type = HTON__u32(type);
293 }
294
295 static inline void ll_inode2fid(struct ll_fid *fid, struct inode *inode)
296 {
297         fid->id = HTON__u64((__u64)inode->i_ino);
298         fid->generation = HTON__u32(inode->i_generation);
299         fid->f_type = HTON__u32(inode->i_mode & S_IFMT);
300 }
301
302 #endif 
303
304 /* 
305  *   OBD IOCTLS
306  */
307
308
309 #define OBD_IOCTL_VERSION 0x00010001
310
311 struct obd_ioctl_data { 
312         uint32_t ioc_len;
313         uint32_t ioc_version;
314         uint32_t ioc_conn1;
315         uint32_t ioc_conn2;
316         struct obdo ioc_obdo1;
317         struct obdo ioc_obdo2;
318         obd_size         ioc_count;
319         obd_off          ioc_offset;
320         uint32_t         ioc_dev;
321
322         /* buffers the kernel will treat as user pointers */
323         uint32_t ioc_plen1;
324         char    *ioc_pbuf1;
325         uint32_t ioc_plen2;
326         char    *ioc_pbuf2;
327
328         /* two inline buffers */
329         uint32_t ioc_inllen1;
330         char    *ioc_inlbuf1;
331         uint32_t ioc_inllen2;
332         char    *ioc_inlbuf2;
333
334         char    ioc_bulk[0];
335 };
336
337 struct obd_ioctl_hdr { 
338         uint32_t ioc_len;
339         uint32_t ioc_version;
340 };
341
342 static inline int obd_ioctl_packlen(struct obd_ioctl_data *data)
343 {
344         int len = sizeof(struct obd_ioctl_data);
345         len += size_round(data->ioc_inllen1);
346         len += size_round(data->ioc_inllen2);
347         return len;
348 }
349
350 static inline int obd_ioctl_is_invalid(struct obd_ioctl_data *data)
351 {
352         if (data->ioc_len > (1<<30)) { 
353                 printk("OBD ioctl: ioc_len larger than 1<<30\n");
354                 return 1;
355         }
356         if (data->ioc_inllen1 > (1<<30)) { 
357                 printk("OBD ioctl: ioc_inllen1 larger than 1<<30\n");
358                 return 1;
359         }
360         if (data->ioc_inllen2 > (1<<30)) { 
361                 printk("OBD ioctl: ioc_inllen2 larger than 1<<30\n");
362                 return 1;
363         }
364         if (data->ioc_inlbuf1 && !data->ioc_inllen1) {
365                 printk("OBD ioctl: inlbuf1 pointer but 0 length\n");
366                 return 1;
367         }
368         if (data->ioc_inlbuf2 && !data->ioc_inllen2) {
369                 printk("OBD ioctl: inlbuf2 pointer but 0 length\n");
370                 return 1;
371         }
372         if (data->ioc_pbuf1 && !data->ioc_plen1) {
373                 printk("OBD ioctl: pbuf1 pointer but 0 length\n");
374                 return 1;
375         }
376         if (data->ioc_pbuf2 && !data->ioc_plen2) {
377                 printk("OBD ioctl: pbuf2 pointer but 0 length\n");
378                 return 1;
379         }
380         if (obd_ioctl_packlen(data) != data->ioc_len ) {
381                 printk("OBD ioctl: packlen exceeds ioc_len\n");
382                 return 1;
383         }
384         if (data->ioc_inllen1 && 
385             data->ioc_bulk[data->ioc_inllen1 - 1] != '\0') { 
386                 printk("OBD ioctl: inlbuf1 not 0 terminated\n");
387                 return 1;
388         }
389         if (data->ioc_inllen2 && 
390             data->ioc_bulk[size_round(data->ioc_inllen1) + data->ioc_inllen2 - 1] != '\0') { 
391                 printk("OBD ioctl: inlbuf2 not 0 terminated\n");
392                 return 1;
393         }
394         return 0;
395 }
396
397 #ifndef __KERNEL__
398 static inline int obd_ioctl_pack(struct obd_ioctl_data *data, char **pbuf, int max)
399 {
400         char *ptr;
401         struct obd_ioctl_data *overlay;
402         data->ioc_len = obd_ioctl_packlen(data);
403         data->ioc_version = OBD_IOCTL_VERSION;
404
405         if (*pbuf && obd_ioctl_packlen(data) > max) 
406                 return 1;
407         if (*pbuf == NULL) { 
408                 *pbuf = malloc(data->ioc_len);
409         }
410         if (!*pbuf)
411                 return 1;
412         overlay = (struct obd_ioctl_data *)*pbuf;
413         memcpy(*pbuf, data, sizeof(*data));
414
415         ptr = overlay->ioc_bulk;
416         if (data->ioc_inlbuf1)
417                 LOGL(data->ioc_inlbuf1, data->ioc_inllen1, ptr);
418         if (data->ioc_inlbuf2)
419                 LOGL(data->ioc_inlbuf2, data->ioc_inllen2, ptr);
420         if (obd_ioctl_is_invalid(overlay))
421                 return 1;
422
423         return 0;
424 }
425 #else
426
427
428 /* buffer MUST be at least the size of obd_ioctl_hdr */
429 static inline int obd_ioctl_getdata(char *buf, char *end, void *arg)
430 {
431         struct obd_ioctl_hdr *hdr;
432         struct obd_ioctl_data *data;
433         int err;
434         ENTRY;
435
436         hdr = (struct obd_ioctl_hdr *)buf;
437         data = (struct obd_ioctl_data *)buf;
438
439         err = copy_from_user(buf, (void *)arg, sizeof(*hdr));
440         if ( err ) {
441                 EXIT;
442                 return err;
443         }
444
445         if (hdr->ioc_version != OBD_IOCTL_VERSION) { 
446                 printk("OBD: version mismatch kernel vs application\n");
447                 return -EINVAL;
448         }
449
450         if (hdr->ioc_len + buf >= end) { 
451                 printk("OBD: user buffer exceeds kernel buffer\n");
452                 return -EINVAL;
453         }
454
455
456         if (hdr->ioc_len < sizeof(struct obd_ioctl_data)) { 
457                 printk("OBD: user buffer too small for ioctl\n");
458                 return -EINVAL;
459         }
460
461         err = copy_from_user(buf, (void *)arg, hdr->ioc_len);
462         if ( err ) {
463                 EXIT;
464                 return err;
465         }
466
467         if (obd_ioctl_is_invalid(data)) { 
468                 printk("OBD: ioctl not correctly formatted\n");
469                 return -EINVAL;
470         }
471
472         if (data->ioc_inllen1) { 
473                 data->ioc_inlbuf1 = &data->ioc_bulk[0];
474         }
475
476         if (data->ioc_inllen2) { 
477                 data->ioc_inlbuf2 = &data->ioc_bulk[0] + size_round(data->ioc_inllen1);
478         }
479
480         EXIT;
481         return 0;
482 }
483 #endif
484
485
486 #define OBD_IOC_CREATE                 _IOR ('f',  3, long)
487 #define OBD_IOC_SETUP                  _IOW ('f',  4, long)
488 #define OBD_IOC_CLEANUP                _IO  ('f',  5      )
489 #define OBD_IOC_DESTROY                _IOW ('f',  6, long)
490 #define OBD_IOC_PREALLOCATE            _IOWR('f',  7, long)
491 #define OBD_IOC_DEC_USE_COUNT          _IO  ('f',  8      )
492 #define OBD_IOC_SETATTR                _IOW ('f',  9, long)
493 #define OBD_IOC_GETATTR                _IOR ('f', 10, long)
494 #define OBD_IOC_READ                   _IOWR('f', 11, long)
495 #define OBD_IOC_WRITE                  _IOWR('f', 12, long)
496 #define OBD_IOC_CONNECT                _IOR ('f', 13, long)
497 #define OBD_IOC_DISCONNECT             _IOW ('f', 14, long)
498 #define OBD_IOC_STATFS                 _IOWR('f', 15, long)
499 #define OBD_IOC_SYNC                   _IOR ('f', 16, long)
500 #define OBD_IOC_READ2                  _IOWR('f', 17, long)
501 #define OBD_IOC_FORMAT                 _IOWR('f', 18, long)
502 #define OBD_IOC_PARTITION              _IOWR('f', 19, long)
503 #define OBD_IOC_ATTACH                 _IOWR('f', 20, long)
504 #define OBD_IOC_DETACH                 _IOWR('f', 21, long)
505 #define OBD_IOC_COPY                   _IOWR('f', 22, long)
506 #define OBD_IOC_MIGR                   _IOWR('f', 23, long)
507 #define OBD_IOC_PUNCH                  _IOWR('f', 24, long)
508 #define OBD_IOC_DEVICE                 _IOWR('f', 25, long)
509
510 #define OBD_IOC_DEC_FS_USE_COUNT       _IO  ('f', 32      )
511
512
513
514 #endif