Whamcloud - gitweb
More 'rpc_register_service' removal
[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  * - ldlm data
42  * - ioctl's
43  */ 
44
45 struct lustre_msg { 
46         __u32 opc;
47         __u32 xid;
48         __u32 status;
49         __u32 type;
50         __u32   connid;
51         __u32   bufcount;
52         __u32   buflens[0];
53 };
54
55 struct ptlreq_hdr { 
56         __u32 opc;
57         __u32 xid;
58         __u32 status;
59         __u32 type;
60         __u32   connid;
61         __u32   bufcount;
62         __u32   buflens[0];
63 };
64
65 struct ptlrep_hdr { 
66         __u32 opc;
67         __u32 xid;
68         __u32 status;
69         __u32 type;
70         __u32   connid;
71         __u32   bufcount;
72         __u32   buflens[0];
73 };
74
75 /* 
76  *   OST requests: OBDO & OBD request records
77  */
78
79 /* opcodes */
80 #define OST_GETATTR    1
81 #define OST_SETATTR    2
82 #define OST_BRW        3
83 #define OST_CREATE     4
84 #define OST_DESTROY    5
85 #define OST_GET_INFO   6
86 #define OST_CONNECT    7
87 #define OST_DISCONNECT 8
88 #define OST_PUNCH      9
89 #define OST_OPEN      10
90 #define OST_CLOSE     11
91
92
93 typedef uint64_t        obd_id;
94 typedef uint64_t        obd_gr;
95 typedef uint64_t        obd_time;
96 typedef uint64_t        obd_size;
97 typedef uint64_t        obd_off;
98 typedef uint64_t        obd_blocks;
99 typedef uint32_t        obd_blksize;
100 typedef uint32_t        obd_mode;
101 typedef uint32_t        obd_uid;
102 typedef uint32_t        obd_gid;
103 typedef uint32_t        obd_rdev;
104 typedef uint32_t        obd_flag;
105 typedef uint32_t        obd_count;
106
107 #define OBD_FL_INLINEDATA       (0x00000001UL)  
108 #define OBD_FL_OBDMDEXISTS      (0x00000002UL)
109
110 #define OBD_INLINESZ    60
111 #define OBD_OBDMDSZ     60
112 /* Note: 64-bit types are 64-bit aligned in structure */
113 struct obdo {
114         obd_id                  o_id;
115         obd_gr                  o_gr;
116         obd_time                o_atime;
117         obd_time                o_mtime;
118         obd_time                o_ctime;
119         obd_size                o_size;
120         obd_blocks              o_blocks;
121         obd_blksize             o_blksize;
122         obd_mode                o_mode;
123         obd_uid                 o_uid;
124         obd_gid                 o_gid;
125         obd_flag                o_flags;
126         obd_flag                o_obdflags;
127         obd_count               o_nlink;
128         obd_count               o_generation;
129         obd_flag                o_valid;        /* hot fields in this obdo */
130         char                    o_inline[OBD_INLINESZ];
131         char                    o_obdmd[OBD_OBDMDSZ];
132         struct list_head        o_list;
133         struct obd_ops          *o_op;
134 };
135
136 #define OBD_MD_FLALL    (~0UL)
137 #define OBD_MD_FLID     (0x00000001UL)
138 #define OBD_MD_FLATIME  (0x00000002UL)
139 #define OBD_MD_FLMTIME  (0x00000004UL)
140 #define OBD_MD_FLCTIME  (0x00000008UL)
141 #define OBD_MD_FLSIZE   (0x00000010UL)
142 #define OBD_MD_FLBLOCKS (0x00000020UL)
143 #define OBD_MD_FLBLKSZ  (0x00000040UL)
144 #define OBD_MD_FLMODE   (0x00000080UL)
145 #define OBD_MD_FLTYPE   (0x00000100UL)
146 #define OBD_MD_FLUID    (0x00000200UL)
147 #define OBD_MD_FLGID    (0x00000400UL)
148 #define OBD_MD_FLFLAGS  (0x00000800UL)
149 #define OBD_MD_FLOBDFLG (0x00001000UL)
150 #define OBD_MD_FLNLINK  (0x00002000UL)
151 #define OBD_MD_FLGENER  (0x00004000UL)
152 #define OBD_MD_FLINLINE (0x00008000UL)
153 #define OBD_MD_FLOBDMD  (0x00010000UL)
154 #define OBD_MD_FLOBJID  (0x00020000UL)
155 #define OBD_MD_FLNOTOBD (~(OBD_MD_FLOBDMD | OBD_MD_FLOBDFLG | OBD_MD_FLBLOCKS))
156
157 /* request structure for OST's */
158
159 #define OST_REQ_HAS_OA1  0x1
160
161 struct ost_req { 
162         __u32   connid;
163         __u32   cmd; 
164         struct  obdo oa;
165         __u32   buflen1;
166         __u32   buflen2;
167 };
168
169 struct ost_rep {
170         __u32   result;
171         __u32   connid;
172         struct  obdo oa;
173         __u32   buflen1;
174         __u32   buflen2;
175 };
176
177 struct obd_ioobj { 
178         obd_id    ioo_id;
179         obd_gr    ioo_gr;
180         __u32     ioo_type;
181         __u32     ioo_bufcnt;
182 };
183
184
185 /* 
186  *   MDS REQ RECORDS
187  */
188
189 #define MDS_GETATTR   1
190 #define MDS_OPEN      2
191 #define MDS_CLOSE     3
192 #define MDS_REINT     4
193 #define MDS_READPAGE  5
194
195 #define REINT_SETATTR 0
196 #define REINT_CREATE  1
197 #define REINT_LINK    2
198 #define REINT_UNLINK  3
199 #define REINT_RENAME  4
200 #define REINT_MAX     4
201
202 struct ll_fid { 
203         __u64 id;
204         __u32 generation;
205         __u32 f_type;
206 };
207
208 struct niobuf { 
209         __u64 addr;
210         __u64 offset; 
211         __u32 len;
212         __u32 flags;
213         __u32 xid;
214         void *page;
215 };
216
217 struct mds_req {
218         struct ll_fid        fid1;
219         struct ll_fid        fid2;
220         __u32                       namelen;
221         __u32                       tgtlen;
222         __u32                       opcode;
223         __u32                       valid;
224         __u32                       mode;
225         __u32                       uid;
226         __u32                       gid;
227         __u64                       objid;
228         __u64                       size;
229         __u32                       mtime;
230         __u32                       ctime;
231         __u32                       atime;
232         __u32                       flags;
233         __u32                       major;
234         __u32                       minor;
235         __u32                       ino;
236         __u32                       nlink;
237         __u32                       generation;
238 };
239
240 struct mds_rep {
241         struct ll_fid               fid1;
242         struct ll_fid               fid2;
243         __u32                       namelen;
244         __u32                       tgtlen;
245         __u32                       valid;
246         __u32                       mode;
247         __u32                       uid;
248         __u32                       gid;
249         __u64                       objid;
250         __u64                       size;
251         __u32                       mtime;
252         __u32                       ctime;
253         __u32                       atime;
254         __u32                       flags;
255         __u32                       major;
256         __u32                       minor;
257         __u32                       ino;
258         __u32                       nlink;
259         __u32                       generation;
260 };
261
262 /* MDS update records */ 
263 struct mds_update_record_hdr { 
264         __u32 ur_reclen;
265         __u32 ur_opcode;
266 };
267
268 struct mds_rec_setattr { 
269         __u32           sa_reclen;
270         __u32           sa_opcode;
271         struct ll_fid   sa_fid;
272         __u32           sa_valid;
273         __u32           sa_mode;
274         __u32           sa_uid;
275         __u32           sa_gid;
276         __u64           sa_size;
277         __u64           sa_atime;
278         __u64           sa_mtime;
279         __u64           sa_ctime;
280         __u32           sa_attr_flags;
281 };
282
283 struct mds_rec_create { 
284         __u32           cr_reclen;
285         __u32           cr_opcode;
286         struct ll_fid   cr_fid;
287         __u32           cr_uid;
288         __u32           cr_gid;
289         __u64           cr_time;
290         __u32           cr_mode;
291         /* overloaded: id for create, tgtlen for symlink, rdev for mknod */ 
292         __u64           cr_id; 
293         __u32           cr_namelen;
294         __u32           cr_tgtlen;
295         /* name here */
296         /* symlink target here */ 
297 };
298
299 struct mds_rec_link { 
300         __u32           lk_reclen;
301         __u32           lk_opcode;
302         struct ll_fid   lk_fid1;
303         struct ll_fid   lk_fid2;
304         __u32           lk_namelen;
305 };
306
307 struct mds_rec_unlink { 
308         __u32           ul_reclen;
309         __u32           ul_opcode;
310         struct ll_fid   ul_fid1;
311         __u32           ul_namelen;
312 };
313
314 struct mds_rec_rename { 
315         __u32           rn_reclen;
316         __u32           rn_opcode;
317         struct ll_fid   rn_fid1;
318         struct ll_fid   rn_fid2;
319         __u32           rn_namelen;
320         __u32           rn_tgtlen;
321 };
322
323 #ifdef __KERNEL__ 
324
325 static inline void ll_ino2fid(struct ll_fid *fid, ino_t ino, __u32 generation,
326                               int type)
327 {
328         fid->id = HTON__u64((__u64)ino);
329         fid->generation = HTON__u32(generation);
330         fid->f_type = HTON__u32(type);
331 }
332
333 static inline void ll_inode2fid(struct ll_fid *fid, struct inode *inode)
334 {
335         ll_ino2fid(fid, inode->i_ino, inode->i_generation, inode->i_mode &S_IFMT);
336 }
337
338 #endif 
339
340 /* 
341  *   LDLM requests:
342  */
343
344 /* opcodes */
345 #define LDLM_ENQUEUE   1
346 #define LDLM_CONVERT   2
347 #define LDLM_CANCEL    3
348 #define LDLM_CALLBACK  4
349
350 #define RES_NAME_SIZE 3
351 #define RES_VERSION_SIZE 4
352
353 /* lock types */
354 typedef enum {
355         LCK_EX = 1,
356         LCK_PW,
357         LCK_PR,
358         LCK_CW,
359         LCK_CR,
360         LCK_NL
361 } ldlm_mode_t;
362
363 struct ldlm_handle {
364         __u64 addr;
365         __u64 cookie;
366 };
367
368 struct ldlm_request {
369         __u32 ns_id;
370         __u64 res_id[RES_NAME_SIZE];
371         __u32 flags;
372         struct ldlm_handle parent_res_handle;
373         struct ldlm_handle parent_lock_handle;
374         ldlm_mode_t mode;
375 };
376
377 struct ldlm_reply {
378         struct ldlm_handle lock_handle;
379 };
380
381 /* 
382  *   OBD IOCTLS
383  */
384
385
386 #define OBD_IOCTL_VERSION 0x00010001
387
388 struct obd_ioctl_data { 
389         uint32_t ioc_len;
390         uint32_t ioc_version;
391         uint32_t ioc_conn1;
392         uint32_t ioc_conn2;
393         struct obdo ioc_obdo1;
394         struct obdo ioc_obdo2;
395         obd_size         ioc_count;
396         obd_off          ioc_offset;
397         uint32_t         ioc_dev;
398
399         /* buffers the kernel will treat as user pointers */
400         uint32_t ioc_plen1;
401         char    *ioc_pbuf1;
402         uint32_t ioc_plen2;
403         char    *ioc_pbuf2;
404
405         /* two inline buffers */
406         uint32_t ioc_inllen1;
407         char    *ioc_inlbuf1;
408         uint32_t ioc_inllen2;
409         char    *ioc_inlbuf2;
410
411         char    ioc_bulk[0];
412 };
413
414 struct obd_ioctl_hdr { 
415         uint32_t ioc_len;
416         uint32_t ioc_version;
417 };
418
419 static inline int obd_ioctl_packlen(struct obd_ioctl_data *data)
420 {
421         int len = sizeof(struct obd_ioctl_data);
422         len += size_round(data->ioc_inllen1);
423         len += size_round(data->ioc_inllen2);
424         return len;
425 }
426
427 static inline int obd_ioctl_is_invalid(struct obd_ioctl_data *data)
428 {
429         if (data->ioc_len > (1<<30)) { 
430                 printk("OBD ioctl: ioc_len larger than 1<<30\n");
431                 return 1;
432         }
433         if (data->ioc_inllen1 > (1<<30)) { 
434                 printk("OBD ioctl: ioc_inllen1 larger than 1<<30\n");
435                 return 1;
436         }
437         if (data->ioc_inllen2 > (1<<30)) { 
438                 printk("OBD ioctl: ioc_inllen2 larger than 1<<30\n");
439                 return 1;
440         }
441         if (data->ioc_inlbuf1 && !data->ioc_inllen1) {
442                 printk("OBD ioctl: inlbuf1 pointer but 0 length\n");
443                 return 1;
444         }
445         if (data->ioc_inlbuf2 && !data->ioc_inllen2) {
446                 printk("OBD ioctl: inlbuf2 pointer but 0 length\n");
447                 return 1;
448         }
449         if (data->ioc_pbuf1 && !data->ioc_plen1) {
450                 printk("OBD ioctl: pbuf1 pointer but 0 length\n");
451                 return 1;
452         }
453         if (data->ioc_pbuf2 && !data->ioc_plen2) {
454                 printk("OBD ioctl: pbuf2 pointer but 0 length\n");
455                 return 1;
456         }
457         /*
458         if (data->ioc_inllen1 && !data->ioc_inlbuf1) {
459                 printk("OBD ioctl: inllen1 set but NULL pointer\n");
460                 return 1;
461         }
462         if (data->ioc_inllen2 && !data->ioc_inlbuf2) {
463                 printk("OBD ioctl: inllen2 set but NULL pointer\n");
464                 return 1;
465         }
466         if (data->ioc_plen1 && !data->ioc_pbuf1) {
467                 printk("OBD ioctl: plen1 set but NULL pointer\n");
468                 return 1;
469         }
470         if (data->ioc_plen2 && !data->ioc_pbuf2) {
471                 printk("OBD ioctl: plen2 set but NULL pointer\n");
472                 return 1;
473         }
474         */
475         if (obd_ioctl_packlen(data) != data->ioc_len ) {
476                 printk("OBD ioctl: packlen exceeds ioc_len\n");
477                 return 1;
478         }
479         if (data->ioc_inllen1 && 
480             data->ioc_bulk[data->ioc_inllen1 - 1] != '\0') { 
481                 printk("OBD ioctl: inlbuf1 not 0 terminated\n");
482                 return 1;
483         }
484         if (data->ioc_inllen2 && 
485             data->ioc_bulk[size_round(data->ioc_inllen1) + data->ioc_inllen2 - 1] != '\0') { 
486                 printk("OBD ioctl: inlbuf2 not 0 terminated\n");
487                 return 1;
488         }
489         return 0;
490 }
491
492 #ifndef __KERNEL__
493 static inline int obd_ioctl_pack(struct obd_ioctl_data *data, char **pbuf,
494                                  int max)
495 {
496         char *ptr;
497         struct obd_ioctl_data *overlay;
498         data->ioc_len = obd_ioctl_packlen(data);
499         data->ioc_version = OBD_IOCTL_VERSION;
500
501         if (*pbuf && obd_ioctl_packlen(data) > max) 
502                 return 1;
503         if (*pbuf == NULL) { 
504                 *pbuf = malloc(data->ioc_len);
505         }
506         if (!*pbuf)
507                 return 1;
508         overlay = (struct obd_ioctl_data *)*pbuf;
509         memcpy(*pbuf, data, sizeof(*data));
510
511         ptr = overlay->ioc_bulk;
512         if (data->ioc_inlbuf1)
513                 LOGL(data->ioc_inlbuf1, data->ioc_inllen1, ptr);
514         if (data->ioc_inlbuf2)
515                 LOGL(data->ioc_inlbuf2, data->ioc_inllen2, ptr);
516         if (obd_ioctl_is_invalid(overlay))
517                 return 1;
518
519         return 0;
520 }
521 #else
522
523
524 /* buffer MUST be at least the size of obd_ioctl_hdr */
525 static inline int obd_ioctl_getdata(char *buf, char *end, void *arg)
526 {
527         struct obd_ioctl_hdr *hdr;
528         struct obd_ioctl_data *data;
529         int err;
530         ENTRY;
531
532         hdr = (struct obd_ioctl_hdr *)buf;
533         data = (struct obd_ioctl_data *)buf;
534
535         err = copy_from_user(buf, (void *)arg, sizeof(*hdr));
536         if ( err ) {
537                 EXIT;
538                 return err;
539         }
540
541         if (hdr->ioc_version != OBD_IOCTL_VERSION) { 
542                 printk("OBD: version mismatch kernel vs application\n");
543                 return -EINVAL;
544         }
545
546         if (hdr->ioc_len + buf >= end) { 
547                 printk("OBD: user buffer exceeds kernel buffer\n");
548                 return -EINVAL;
549         }
550
551
552         if (hdr->ioc_len < sizeof(struct obd_ioctl_data)) { 
553                 printk("OBD: user buffer too small for ioctl\n");
554                 return -EINVAL;
555         }
556
557         err = copy_from_user(buf, (void *)arg, hdr->ioc_len);
558         if ( err ) {
559                 EXIT;
560                 return err;
561         }
562
563         if (obd_ioctl_is_invalid(data)) { 
564                 printk("OBD: ioctl not correctly formatted\n");
565                 return -EINVAL;
566         }
567
568         if (data->ioc_inllen1) { 
569                 data->ioc_inlbuf1 = &data->ioc_bulk[0];
570         }
571
572         if (data->ioc_inllen2) { 
573                 data->ioc_inlbuf2 = &data->ioc_bulk[0] + size_round(data->ioc_inllen1);
574         }
575
576         EXIT;
577         return 0;
578 }
579 #endif
580
581
582 #define OBD_IOC_CREATE                 _IOR ('f',  3, long)
583 #define OBD_IOC_SETUP                  _IOW ('f',  4, long)
584 #define OBD_IOC_CLEANUP                _IO  ('f',  5      )
585 #define OBD_IOC_DESTROY                _IOW ('f',  6, long)
586 #define OBD_IOC_PREALLOCATE            _IOWR('f',  7, long)
587 #define OBD_IOC_DEC_USE_COUNT          _IO  ('f',  8      )
588 #define OBD_IOC_SETATTR                _IOW ('f',  9, long)
589 #define OBD_IOC_GETATTR                _IOR ('f', 10, long)
590 #define OBD_IOC_READ                   _IOWR('f', 11, long)
591 #define OBD_IOC_WRITE                  _IOWR('f', 12, long)
592 #define OBD_IOC_CONNECT                _IOR ('f', 13, long)
593 #define OBD_IOC_DISCONNECT             _IOW ('f', 14, long)
594 #define OBD_IOC_STATFS                 _IOWR('f', 15, long)
595 #define OBD_IOC_SYNC                   _IOR ('f', 16, long)
596 #define OBD_IOC_READ2                  _IOWR('f', 17, long)
597 #define OBD_IOC_FORMAT                 _IOWR('f', 18, long)
598 #define OBD_IOC_PARTITION              _IOWR('f', 19, long)
599 #define OBD_IOC_ATTACH                 _IOWR('f', 20, long)
600 #define OBD_IOC_DETACH                 _IOWR('f', 21, long)
601 #define OBD_IOC_COPY                   _IOWR('f', 22, long)
602 #define OBD_IOC_MIGR                   _IOWR('f', 23, long)
603 #define OBD_IOC_PUNCH                  _IOWR('f', 24, long)
604 #define OBD_IOC_DEVICE                 _IOWR('f', 25, long)
605 #define OBD_IOC_MODULE_DEBUG           _IOWR('f', 26, long)
606 #define OBD_IOC_BRW_READ               _IOWR('f', 27, long)
607 #define OBD_IOC_BRW_WRITE              _IOWR('f', 28, long)
608
609 #define OBD_IOC_DEC_FS_USE_COUNT       _IO  ('f', 32      )
610
611
612 /* GENERAL THINGS */
613 union ptl_rep { 
614         struct mds_rep *mds;
615         struct ost_rep *ost;
616         struct lustre_msg *lustre;
617 };
618
619 union ptl_req { 
620         struct mds_req *mds;
621         struct ost_req *ost;
622         struct lustre_msg *lustre;
623 };
624
625 #endif