Whamcloud - gitweb
LU-9558 llite: generic_readlink is no longer exported
[fs/lustre-release.git] / lustre / contrib / mpich2-1.0.3.patch
1 Date: Fri, 08 Jun 2007 14:04:34 -0400
2 From: Weikuan Yu <weikuan.yu@gmail.com>
3 To: Weikuan Yu <weikuan.yu@gmail.com>
4 Subject: Re: [Lustre-discuss] MPI-IO for Lustre
5 Cc: lustre-discuss@clusterfs.com
6
7
8 This is the MPICH2 patch I originally started as a base for some ROMIO
9 optimizations over Lustre. It should work fine for MPICH2-1.0.3 on
10 experimental systems. However, use it as your risk :)
11
12 Given time, I will try to push out my optimizations after some cleanup. I
13 would very happy to hear feedbacks on what features people would need most
14 at the time.
15
16 --
17 Weikuan
18
19
20 diff -ruN romio-orig/adio/ad_lustre/ad_lustre.c romio/adio/ad_lustre/ad_lustre.c
21 --- romio-orig/adio/ad_lustre/ad_lustre.c       1969-12-31 19:00:00.000000000 -0500
22 +++ romio/adio/ad_lustre/ad_lustre.c    2006-09-06 18:40:56.000844619 -0400
23 @@ -0,0 +1,37 @@
24 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
25 +/*
26 + *   $Id: ad_lustre.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
27 + *
28 + *   Copyright (C) 2001 University of Chicago.
29 + *   See COPYRIGHT notice in top-level directory.
30 + */
31 +
32 +#include "ad_lustre.h"
33 +
34 +/* adioi.h has the ADIOI_Fns_struct define */
35 +#include "adioi.h"
36 +
37 +struct ADIOI_Fns_struct ADIO_LUSTRE_operations = {
38 +    ADIOI_LUSTRE_Open, /* Open */
39 +    ADIOI_LUSTRE_ReadContig, /* ReadContig */
40 +    ADIOI_LUSTRE_WriteContig, /* WriteContig */
41 +    ADIOI_GEN_ReadStridedColl, /* ReadStridedColl */
42 +    ADIOI_GEN_WriteStridedColl, /* WriteStridedColl */
43 +    ADIOI_GEN_SeekIndividual, /* SeekIndividual */
44 +    ADIOI_LUSTRE_Fcntl, /* Fcntl */
45 +    ADIOI_LUSTRE_SetInfo, /* SetInfo */
46 +    ADIOI_GEN_ReadStrided, /* ReadStrided */
47 +    ADIOI_GEN_WriteStrided, /* WriteStrided */
48 +    ADIOI_LUSTRE_Close, /* Close */
49 +    ADIOI_LUSTRE_IreadContig, /* IreadContig */
50 +    ADIOI_LUSTRE_IwriteContig, /* IwriteContig */
51 +    ADIOI_LUSTRE_ReadDone, /* ReadDone */
52 +    ADIOI_LUSTRE_WriteDone, /* WriteDone */
53 +    ADIOI_LUSTRE_ReadComplete, /* ReadComplete */
54 +    ADIOI_LUSTRE_WriteComplete, /* WriteComplete */
55 +    ADIOI_LUSTRE_IreadStrided, /* IreadStrided */
56 +    ADIOI_LUSTRE_IwriteStrided, /* IwriteStrided */
57 +    ADIOI_GEN_Flush, /* Flush */
58 +    ADIOI_LUSTRE_Resize, /* Resize */
59 +    ADIOI_GEN_Delete, /* Delete */
60 +};
61 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_close.c romio/adio/ad_lustre/ad_lustre_close.c
62 --- romio-orig/adio/ad_lustre/ad_lustre_close.c 1969-12-31 19:00:00.000000000 -0500
63 +++ romio/adio/ad_lustre/ad_lustre_close.c      2006-09-06 17:10:35.000683211 -0400
64 @@ -0,0 +1,32 @@
65 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
66 +/*
67 + *   $Id: ad_lustre_close.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
68 + *
69 + *   Copyright (C) 1997 University of Chicago.
70 + *   See COPYRIGHT notice in top-level directory.
71 + */
72 +
73 +#include "ad_lustre.h"
74 +
75 +void ADIOI_LUSTRE_Close(ADIO_File fd, int *error_code)
76 +{
77 +    int err;
78 +#if defined(MPICH2) || !defined(PRINT_ERR_MSG)
79 +    static char myname[] = "ADIOI_LUSTRE_CLOSE";
80 +#endif
81 +
82 +    err = close(fd->fd_sys);
83 +    if (err == -1) {
84 +#ifdef MPICH2
85 +       *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
86 +           "**io %s", strerror(errno));
87 +#elif defined(PRINT_ERR_MSG)
88 +                       *error_code = MPI_ERR_UNKNOWN;
89 +#else
90 +       *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
91 +                             myname, "I/O Error", "%s", strerror(errno));
92 +       ADIOI_Error(fd, *error_code, myname);
93 +#endif
94 +    }
95 +    else *error_code = MPI_SUCCESS;
96 +}
97 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_done.c romio/adio/ad_lustre/ad_lustre_done.c
98 --- romio-orig/adio/ad_lustre/ad_lustre_done.c  1969-12-31 19:00:00.000000000 -0500
99 +++ romio/adio/ad_lustre/ad_lustre_done.c       2006-09-06 17:10:35.000692922 -0400
100 @@ -0,0 +1,188 @@
101 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
102 +/*
103 + *   $Id: ad_lustre_done.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
104 + *
105 + *   Copyright (C) 1997 University of Chicago.
106 + *   See COPYRIGHT notice in top-level directory.
107 + */
108 +
109 +#include "ad_lustre.h"
110 +
111 +int ADIOI_LUSTRE_ReadDone(ADIO_Request *request, ADIO_Status *status, int *error_code)
112 +{
113 +#ifndef NO_AIO
114 +    int done=0;
115 +#if defined(MPICH2) || !defined(PRINT_ERR_MSG)
116 +    static char myname[] = "ADIOI_LUSTRE_READDONE";
117 +#endif
118 +#ifdef AIO_SUN
119 +    aio_result_t *result=0, *tmp;
120 +#else
121 +    int err;
122 +#endif
123 +#ifdef AIO_HANDLE_IN_AIOCB
124 +    struct aiocb *tmp1;
125 +#endif
126 +#endif
127 +
128 +    if (*request == ADIO_REQUEST_NULL) {
129 +       *error_code = MPI_SUCCESS;
130 +       return 1;
131 +    }
132 +
133 +#ifdef NO_AIO
134 +/* HP, FreeBSD, Linux */
135 +#ifdef HAVE_STATUS_SET_BYTES
136 +    MPIR_Status_set_bytes(status, (*request)->datatype, (*request)->nbytes);
137 +#endif
138 +    (*request)->fd->async_count--;
139 +    ADIOI_Free_request((ADIOI_Req_node *) (*request));
140 +    *request = ADIO_REQUEST_NULL;
141 +    *error_code = MPI_SUCCESS;
142 +    return 1;
143 +#endif
144 +
145 +#ifdef AIO_SUN
146 +    if ((*request)->queued) {
147 +       tmp = (aio_result_t *) (*request)->handle;
148 +       if (tmp->aio_return == AIO_INPROGRESS) {
149 +           done = 0;
150 +           *error_code = MPI_SUCCESS;
151 +       }
152 +       else if (tmp->aio_return != -1) {
153 +           result = (aio_result_t *) aiowait(0); /* dequeue any one request */
154 +           done = 1;
155 +           (*request)->nbytes = tmp->aio_return;
156 +           *error_code = MPI_SUCCESS;
157 +       }
158 +       else {
159 +#ifdef MPICH2
160 +           *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
161 +               "**io %s", strerror(tmp->aio_errno));
162 +           return;
163 +#elif defined(PRINT_ERR_MSG)
164 +           *error_code = MPI_ERR_UNKNOWN;
165 +#else
166 +           *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
167 +                        myname, "I/O Error", "%s", strerror(tmp->aio_errno));
168 +           ADIOI_Error((*request)->fd, *error_code, myname);
169 +#endif
170 +       }
171 +    } /* if ((*request)->queued) ... */
172 +    else {
173 +       /* ADIOI_Complete_Async completed this request, but request object
174 +           was not freed. */
175 +       done = 1;
176 +       *error_code = MPI_SUCCESS;
177 +    }
178 +#ifdef HAVE_STATUS_SET_BYTES
179 +    if (done && ((*request)->nbytes != -1))
180 +       MPIR_Status_set_bytes(status, (*request)->datatype, (*request)->nbytes);
181 +#endif
182 +
183 +#endif
184 +
185 +#ifdef AIO_HANDLE_IN_AIOCB
186 +/* IBM */
187 +    if ((*request)->queued) {
188 +       tmp1 = (struct aiocb *) (*request)->handle;
189 +       errno = aio_error(tmp1->aio_handle);
190 +       if (errno == EINPROG) {
191 +           done = 0;
192 +           *error_code = MPI_SUCCESS;
193 +       }
194 +       else {
195 +           err = aio_return(tmp1->aio_handle);
196 +           (*request)->nbytes = err;
197 +           errno = aio_error(tmp1->aio_handle);
198 +
199 +           done = 1;
200 +
201 +           if (err == -1) {
202 +#ifdef MPICH2
203 +               *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
204 +                   "**io %s", strerror(errno));
205 +               return;
206 +#elif defined(PRINT_ERR_MSG)
207 +                               *error_code = MPI_ERR_UNKNOWN;
208 +#else
209 +               *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
210 +                             myname, "I/O Error", "%s", strerror(errno));
211 +               ADIOI_Error((*request)->fd, *error_code, myname);
212 +#endif
213 +           }
214 +           else *error_code = MPI_SUCCESS;
215 +       }
216 +    } /* if ((*request)->queued) */
217 +    else {
218 +       done = 1;
219 +       *error_code = MPI_SUCCESS;
220 +    }
221 +#ifdef HAVE_STATUS_SET_BYTES
222 +    if (done && ((*request)->nbytes != -1))
223 +       MPIR_Status_set_bytes(status, (*request)->datatype, (*request)->nbytes);
224 +#endif
225 +
226 +#elif (!defined(NO_AIO) && !defined(AIO_SUN))
227 +/* DEC, SGI IRIX 5 and 6 */
228 +    if ((*request)->queued) {
229 +       errno = aio_error((const struct aiocb *) (*request)->handle);
230 +       if (errno == EINPROGRESS) {
231 +           done = 0;
232 +           *error_code = MPI_SUCCESS;
233 +       }
234 +       else {
235 +           err = aio_return((struct aiocb *) (*request)->handle);
236 +           (*request)->nbytes = err;
237 +           errno = aio_error((struct aiocb *) (*request)->handle);
238 +
239 +           done = 1;
240 +
241 +           if (err == -1) {
242 +#ifdef MPICH2
243 +               *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
244 +                   "**io %s", strerror(errno));
245 +               return;
246 +#elif defined(PRINT_ERR_MSG)
247 +                               *error_code = MPI_ERR_UNKNOWN;
248 +#else /* MPICH-1 */
249 +               *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
250 +                             myname, "I/O Error", "%s", strerror(errno));
251 +               ADIOI_Error((*request)->fd, *error_code, myname);
252 +#endif
253 +           }
254 +           else *error_code = MPI_SUCCESS;
255 +       }
256 +    } /* if ((*request)->queued) */
257 +    else {
258 +       done = 1;
259 +       *error_code = MPI_SUCCESS;
260 +    }
261 +#ifdef HAVE_STATUS_SET_BYTES
262 +    if (done && ((*request)->nbytes != -1))
263 +       MPIR_Status_set_bytes(status, (*request)->datatype, (*request)->nbytes);
264 +#endif
265 +
266 +#endif
267 +
268 +#ifndef NO_AIO
269 +    if (done) {
270 +       /* if request is still queued in the system, it is also there
271 +           on ADIOI_Async_list. Delete it from there. */
272 +       if ((*request)->queued) ADIOI_Del_req_from_list(request);
273 +
274 +       (*request)->fd->async_count--;
275 +       if ((*request)->handle) ADIOI_Free((*request)->handle);
276 +       ADIOI_Free_request((ADIOI_Req_node *) (*request));
277 +       *request = ADIO_REQUEST_NULL;
278 +    }
279 +    return done;
280 +#endif
281 +
282 +}
283 +
284 +
285 +int ADIOI_LUSTRE_WriteDone(ADIO_Request *request, ADIO_Status *status, int *error_code)
286 +{
287 +    return ADIOI_LUSTRE_ReadDone(request, status, error_code);
288 +}
289 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_fcntl.c romio/adio/ad_lustre/ad_lustre_fcntl.c
290 --- romio-orig/adio/ad_lustre/ad_lustre_fcntl.c 1969-12-31 19:00:00.000000000 -0500
291 +++ romio/adio/ad_lustre/ad_lustre_fcntl.c      2006-09-06 18:43:11.000365177 -0400
292 @@ -0,0 +1,127 @@
293 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
294 +/*
295 + *   $Id: ad_lustre_fcntl.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
296 + *
297 + *   Copyright (C) 1997 University of Chicago.
298 + *   See COPYRIGHT notice in top-level directory.
299 + */
300 +
301 +#include "ad_lustre.h"
302 +#include "adio_extern.h"
303 +/* #ifdef MPISGI
304 +#include "mpisgi2.h"
305 +#endif */
306 +
307 +void ADIOI_LUSTRE_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct, int *error_code)
308 +{
309 +    int i, ntimes;
310 +    ADIO_Offset curr_fsize, alloc_size, size, len, done;
311 +    ADIO_Status status;
312 +    char *buf;
313 +#if defined(MPICH2) || !defined(PRINT_ERR_MSG)
314 +    static char myname[] = "ADIOI_LUSTRE_FCNTL";
315 +#endif
316 +
317 +    switch(flag) {
318 +    case ADIO_FCNTL_GET_FSIZE:
319 +       fcntl_struct->fsize = lseek(fd->fd_sys, 0, SEEK_END);
320 +       if (fd->fp_sys_posn != -1)
321 +            lseek(fd->fd_sys, fd->fp_sys_posn, SEEK_SET);
322 +       if (fcntl_struct->fsize == -1) {
323 +#ifdef MPICH2
324 +           *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
325 +               "**io %s", strerror(errno));
326 +#elif defined(PRINT_ERR_MSG)
327 +                       *error_code = MPI_ERR_UNKNOWN;
328 +#else /* MPICH-1 */
329 +           *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
330 +                             myname, "I/O Error", "%s", strerror(errno));
331 +           ADIOI_Error(fd, *error_code, myname);
332 +#endif
333 +       }
334 +       else *error_code = MPI_SUCCESS;
335 +       break;
336 +
337 +    case ADIO_FCNTL_SET_DISKSPACE:
338 +       /* will be called by one process only */
339 +       /* On file systems with no preallocation function, I have to
340 +           explicitly write
341 +           to allocate space. Since there could be holes in the file,
342 +           I need to read up to the current file size, write it back,
343 +           and then write beyond that depending on how much
344 +           preallocation is needed.
345 +           read/write in sizes of no more than ADIOI_PREALLOC_BUFSZ */
346 +
347 +       curr_fsize = lseek(fd->fd_sys, 0, SEEK_END);
348 +       alloc_size = fcntl_struct->diskspace;
349 +
350 +       size = ADIOI_MIN(curr_fsize, alloc_size);
351 +
352 +       ntimes = (size + ADIOI_PREALLOC_BUFSZ - 1)/ADIOI_PREALLOC_BUFSZ;
353 +       buf = (char *) ADIOI_Malloc(ADIOI_PREALLOC_BUFSZ);
354 +       done = 0;
355 +
356 +       for (i=0; i<ntimes; i++) {
357 +           len = ADIOI_MIN(size-done, ADIOI_PREALLOC_BUFSZ);
358 +           ADIO_ReadContig(fd, buf, len, MPI_BYTE, ADIO_EXPLICIT_OFFSET, done,
359 +                           &status, error_code);
360 +           if (*error_code != MPI_SUCCESS) {
361 +#ifdef MPICH2
362 +               *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
363 +                   "**io %s", strerror(errno));
364 +#elif defined(PRINT_ERR_MSG)
365 +               FPRINTF(stderr, "ADIOI_LUSTRE_Fcntl: To preallocate disk space, ROMIO needs to read the file and write it back, but is unable to read the file. Please give the file read permission and open it with MPI_MODE_RDWR.\n");
366 +               MPI_Abort(MPI_COMM_WORLD, 1);
367 +#else /* MPICH-1 */
368 +               *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_PREALLOC_PERM,
369 +                             myname, (char *) 0, (char *) 0);
370 +               ADIOI_Error(fd, *error_code, myname);
371 +#endif
372 +                return;
373 +           }
374 +           ADIO_WriteContig(fd, buf, len, MPI_BYTE, ADIO_EXPLICIT_OFFSET,
375 +                             done, &status, error_code);
376 +           if (*error_code != MPI_SUCCESS) return;
377 +           done += len;
378 +       }
379 +
380 +       if (alloc_size > curr_fsize) {
381 +           memset(buf, 0, ADIOI_PREALLOC_BUFSZ);
382 +           size = alloc_size - curr_fsize;
383 +           ntimes = (size + ADIOI_PREALLOC_BUFSZ - 1)/ADIOI_PREALLOC_BUFSZ;
384 +           for (i=0; i<ntimes; i++) {
385 +               len = ADIOI_MIN(alloc_size-done, ADIOI_PREALLOC_BUFSZ);
386 +               ADIO_WriteContig(fd, buf, len, MPI_BYTE, ADIO_EXPLICIT_OFFSET,
387 +                                done, &status, error_code);
388 +               if (*error_code != MPI_SUCCESS) return;
389 +               done += len;
390 +           }
391 +       }
392 +       ADIOI_Free(buf);
393 +       if (fd->fp_sys_posn != -1)
394 +           lseek(fd->fd_sys, fd->fp_sys_posn, SEEK_SET);
395 +       *error_code = MPI_SUCCESS;
396 +       break;
397 +
398 +#if 0
399 +    case ADIO_FCNTL_SET_IOMODE:
400 +        /* for implementing PFS I/O modes. will not occur in MPI-IO
401 +           implementation.*/
402 +       if (fd->iomode != fcntl_struct->iomode) {
403 +           fd->iomode = fcntl_struct->iomode;
404 +           MPI_Barrier(MPI_COMM_WORLD);
405 +       }
406 +       *error_code = MPI_SUCCESS;
407 +       break;
408 +#endif
409 +
410 +    case ADIO_FCNTL_SET_ATOMICITY:
411 +       fd->atomicity = (fcntl_struct->atomicity == 0) ? 0 : 1;
412 +       *error_code = MPI_SUCCESS;
413 +       break;
414 +
415 +    default:
416 +       FPRINTF(stderr, "Unknown flag passed to ADIOI_LUSTRE_Fcntl\n");
417 +       MPI_Abort(MPI_COMM_WORLD, 1);
418 +    }
419 +}
420 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_flush.c romio/adio/ad_lustre/ad_lustre_flush.c
421 --- romio-orig/adio/ad_lustre/ad_lustre_flush.c 1969-12-31 19:00:00.000000000 -0500
422 +++ romio/adio/ad_lustre/ad_lustre_flush.c      2006-09-06 17:10:35.000711888 -0400
423 @@ -0,0 +1,14 @@
424 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
425 +/*
426 + *   $Id: ad_lustre_flush.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
427 + *
428 + *   Copyright (C) 1997 University of Chicago.
429 + *   See COPYRIGHT notice in top-level directory.
430 + */
431 +
432 +#include "ad_lustre.h"
433 +
434 +void ADIOI_LUSTRE_Flush(ADIO_File fd, int *error_code)
435 +{
436 +    ADIOI_GEN_Flush(fd, error_code);
437 +}
438 diff -ruN romio-orig/adio/ad_lustre/ad_lustre.h romio/adio/ad_lustre/ad_lustre.h
439 --- romio-orig/adio/ad_lustre/ad_lustre.h       1969-12-31 19:00:00.000000000 -0500
440 +++ romio/adio/ad_lustre/ad_lustre.h    2006-09-06 17:10:35.000722616 -0400
441 @@ -0,0 +1,36 @@
442 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
443 +/*
444 + *   $Id: ad_lustre.h,v 1.2 2005/07/07 14:38:17 liam Exp $
445 + *
446 + *   Copyright (C) 1997 University of Chicago.
447 + *   See COPYRIGHT notice in top-level directory.
448 + */
449 +
450 +#ifndef AD_UNIX_INCLUDE
451 +#define AD_UNIX_INCLUDE
452 +
453 +/* temp*/
454 +#define HAVE_ASM_TYPES_H 1
455 +
456 +#include <unistd.h>
457 +#include <linux/types.h>
458 +#include <fcntl.h>
459 +#include <sys/ioctl.h>
460 +#include "lustre/lustre_user.h"
461 +#include "adio.h"
462 +
463 +#ifndef NO_AIO
464 +#ifdef AIO_SUN
465 +#include <sys/asynch.h>
466 +#else
467 +#include <aio.h>
468 +#ifdef NEEDS_ADIOCB_T
469 +typedef struct adiocb adiocb_t;
470 +#endif
471 +#endif
472 +#endif
473 +
474 +int ADIOI_LUSTRE_aio(ADIO_File fd, void *buf, int len, ADIO_Offset offset,
475 +                 int wr, void *handle);
476 +
477 +#endif
478 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_hints.c romio/adio/ad_lustre/ad_lustre_hints.c
479 --- romio-orig/adio/ad_lustre/ad_lustre_hints.c 1969-12-31 19:00:00.000000000 -0500
480 +++ romio/adio/ad_lustre/ad_lustre_hints.c      2006-09-06 17:10:35.000741994 -0400
481 @@ -0,0 +1,130 @@
482 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
483 +/*
484 + *   $Id: ad_lustre_hints.c,v 1.2 2005/07/07 14:38:17 liam Exp $
485 + *
486 + *   Copyright (C) 1997 University of Chicago.
487 + *   See COPYRIGHT notice in top-level directory.
488 + */
489 +
490 +#include "ad_lustre.h"
491 +
492 +void ADIOI_LUSTRE_SetInfo(ADIO_File fd, MPI_Info users_info, int *error_code)
493 +{
494 +    char *value, *value_in_fd;
495 +    int flag, tmp_val, str_factor=-1, str_unit=0, start_iodev=-1;
496 +    struct lov_user_md lum = { 0 };
497 +    int err, myrank, fd_sys, perm, amode, old_mask;
498 +
499 +    if ( (fd->info) == MPI_INFO_NULL) {
500 +       /* This must be part of the open call. can set striping parameters
501 +           if necessary. */
502 +       MPI_Info_create(&(fd->info));
503 +
504 +       /* has user specified striping or server buffering parameters
505 +           and do they have the same value on all processes? */
506 +       if (users_info != MPI_INFO_NULL) {
507 +           value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
508 +
509 +           MPI_Info_get(users_info, "striping_factor", MPI_MAX_INFO_VAL,
510 +                        value, &flag);
511 +           if (flag) {
512 +               str_factor=atoi(value);
513 +               tmp_val = str_factor;
514 +               MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm);
515 +               if (tmp_val != str_factor) {
516 +                   FPRINTF(stderr, "ADIOI_LUSTRE_SetInfo: the value for key \"striping_factor\" must be the same on all processes\n");
517 +                   MPI_Abort(MPI_COMM_WORLD, 1);
518 +               }
519 +           }
520 +
521 +           MPI_Info_get(users_info, "striping_unit", MPI_MAX_INFO_VAL,
522 +                        value, &flag);
523 +           if (flag) {
524 +               str_unit=atoi(value);
525 +               tmp_val = str_unit;
526 +               MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm);
527 +               if (tmp_val != str_unit) {
528 +                   FPRINTF(stderr, "ADIOI_LUSTRE_SetInfo: the value for key \"striping_unit\" must be the same on all processes\n");
529 +                   MPI_Abort(MPI_COMM_WORLD, 1);
530 +               }
531 +           }
532 +
533 +           MPI_Info_get(users_info, "start_iodevice", MPI_MAX_INFO_VAL,
534 +                        value, &flag);
535 +           if (flag) {
536 +               start_iodev=atoi(value);
537 +               tmp_val = start_iodev;
538 +               MPI_Bcast(&tmp_val, 1, MPI_INT, 0, fd->comm);
539 +               if (tmp_val != start_iodev) {
540 +                   FPRINTF(stderr, "ADIOI_LUSTRE_SetInfo: the value for key \"start_iodevice\" must be the same on all processes\n");
541 +                   MPI_Abort(MPI_COMM_WORLD, 1);
542 +               }
543 +           }
544 +
545 +         /* if user has specified striping info, process 0 tries to set it */
546 +           if ((str_factor > 0) || (str_unit > 0) || (start_iodev >= 0)) {
547 +               MPI_Comm_rank(fd->comm, &myrank);
548 +               if (!myrank) {
549 +                   if (fd->perm == ADIO_PERM_NULL) {
550 +                       old_mask = umask(022);
551 +                       umask(old_mask);
552 +                       perm = old_mask ^ 0666;
553 +                   }
554 +                   else perm = fd->perm;
555 +
556 +                   amode = 0;
557 +                   if (fd->access_mode & ADIO_CREATE)
558 +                       amode = amode | O_CREAT;
559 +                   if (fd->access_mode & ADIO_RDONLY)
560 +                       amode = amode | O_RDONLY;
561 +                   if (fd->access_mode & ADIO_WRONLY)
562 +                       amode = amode | O_WRONLY;
563 +                   if (fd->access_mode & ADIO_RDWR)
564 +                       amode = amode | O_RDWR;
565 +                   if (fd->access_mode & ADIO_EXCL)
566 +                       amode = amode | O_EXCL;
567 +
568 +                   /* we need to create file so ensure this is set */
569 +                    amode = amode | O_LOV_DELAY_CREATE | O_CREAT;
570 +
571 +                    fd_sys = open(fd->filename, amode, perm);
572 +                    if (fd_sys == -1) {
573 +                       if (errno != EEXIST)
574 +                           printf("Failure to open file %s %d %d\n",strerror(errno), amode, perm);
575 +                    } else {
576 +                        lum.lmm_magic = LOV_USER_MAGIC;
577 +                        lum.lmm_pattern = 0;
578 +                        lum.lmm_stripe_size = str_unit;
579 +                        lum.lmm_stripe_count = str_factor;
580 +                        lum.lmm_stripe_offset = start_iodev;
581 +
582 +                        err = ioctl(fd_sys, LL_IOC_LOV_SETSTRIPE, &lum);
583 +                        if (err == -1 && errno != EEXIST) {
584 +                           printf("Failure to set stripe info %s \n",strerror(errno));
585 +                        }
586 +
587 +                        close(fd_sys);
588 +                   }
589 +
590 +               }
591 +               MPI_Barrier(fd->comm);
592 +           }
593 +
594 +           ADIOI_Free(value);
595 +       }
596 +
597 +       /* set the values for collective I/O and data sieving parameters */
598 +       ADIOI_GEN_SetInfo(fd, users_info, error_code);
599 +    }
600 +
601 +    else {
602 +       /* The file has been opened previously and fd->fd_sys is a valid
603 +           file descriptor. cannot set striping parameters now. */
604 +
605 +       /* set the values for collective I/O and data sieving parameters */
606 +       ADIOI_GEN_SetInfo(fd, users_info, error_code);
607 +
608 +    }
609 +
610 +    *error_code = MPI_SUCCESS;
611 +}
612 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_iread.c romio/adio/ad_lustre/ad_lustre_iread.c
613 --- romio-orig/adio/ad_lustre/ad_lustre_iread.c 1969-12-31 19:00:00.000000000 -0500
614 +++ romio/adio/ad_lustre/ad_lustre_iread.c      2006-09-06 17:10:35.000751765 -0400
615 @@ -0,0 +1,106 @@
616 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
617 +/*
618 + *   $Id: ad_lustre_iread.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
619 + *
620 + *   Copyright (C) 1997 University of Chicago.
621 + *   See COPYRIGHT notice in top-level directory.
622 + */
623 +
624 +#include "ad_lustre.h"
625 +
626 +void ADIOI_LUSTRE_IreadContig(ADIO_File fd, void *buf, int count,
627 +                MPI_Datatype datatype, int file_ptr_type,
628 +                ADIO_Offset offset, ADIO_Request *request, int *error_code)
629 +{
630 +    int len, typesize;
631 +#ifdef NO_AIO
632 +    ADIO_Status status;
633 +#else
634 +    int err=-1;
635 +#if defined(MPICH2) || !defined(PRINT_ERR_MSG)
636 +    static char myname[] = "ADIOI_LUSTRE_IREADCONTIG";
637 +#endif
638 +#endif
639 +
640 +    (*request) = ADIOI_Malloc_request();
641 +    (*request)->optype = ADIOI_READ;
642 +    (*request)->fd = fd;
643 +    (*request)->datatype = datatype;
644 +
645 +    MPI_Type_size(datatype, &typesize);
646 +    len = count * typesize;
647 +
648 +#ifdef NO_AIO
649 +    /* HP, FreeBSD, Linux */
650 +    /* no support for nonblocking I/O. Use blocking I/O. */
651 +
652 +    ADIOI_LUSTRE_ReadContig(fd, buf, len, MPI_BYTE, file_ptr_type, offset,
653 +                        &status, error_code);
654 +    (*request)->queued = 0;
655 +#ifdef HAVE_STATUS_SET_BYTES
656 +    if (*error_code == MPI_SUCCESS) {
657 +       MPI_Get_elements(&status, MPI_BYTE, &len);
658 +       (*request)->nbytes = len;
659 +    }
660 +#endif
661 +
662 +#else
663 +    if (file_ptr_type == ADIO_INDIVIDUAL) offset = fd->fp_ind;
664 +    err = ADIOI_LUSTRE_aio(fd, buf, len, offset, 0, &((*request)->handle));
665 +    if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind += len;
666 +
667 +    (*request)->queued = 1;
668 +    ADIOI_Add_req_to_list(request);
669 +
670 +    if (err == -1) {
671 +#ifdef MPICH2
672 +       *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
673 +           "**io %s", strerror(errno));
674 +       return;
675 +#elif defined(PRINT_ERR_MSG)
676 +                       *error_code = MPI_ERR_UNKNOWN;
677 +#else /* MPICH-1 */
678 +       *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
679 +                             myname, "I/O Error", "%s", strerror(errno));
680 +       ADIOI_Error(fd, *error_code, myname);
681 +#endif
682 +    }
683 +    else *error_code = MPI_SUCCESS;
684 +#endif  /* NO_AIO */
685 +
686 +    fd->fp_sys_posn = -1;   /* set it to null. */
687 +    fd->async_count++;
688 +}
689 +
690 +
691 +
692 +void ADIOI_LUSTRE_IreadStrided(ADIO_File fd, void *buf, int count,
693 +                      MPI_Datatype datatype, int file_ptr_type,
694 +                       ADIO_Offset offset, ADIO_Request *request, int
695 +                       *error_code)
696 +{
697 +    ADIO_Status status;
698 +#ifdef HAVE_STATUS_SET_BYTES
699 +    int typesize;
700 +#endif
701 +
702 +    *request = ADIOI_Malloc_request();
703 +    (*request)->optype = ADIOI_READ;
704 +    (*request)->fd = fd;
705 +    (*request)->datatype = datatype;
706 +    (*request)->queued = 0;
707 +    (*request)->handle = 0;
708 +
709 +/* call the blocking version. It is faster because it does data sieving. */
710 +    ADIOI_LUSTRE_ReadStrided(fd, buf, count, datatype, file_ptr_type,
711 +                            offset, &status, error_code);
712 +
713 +    fd->async_count++;
714 +
715 +#ifdef HAVE_STATUS_SET_BYTES
716 +    if (*error_code == MPI_SUCCESS) {
717 +       MPI_Type_size(datatype, &typesize);
718 +       (*request)->nbytes = count * typesize;
719 +    }
720 +#endif
721 +}
722 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_iwrite.c romio/adio/ad_lustre/ad_lustre_iwrite.c
723 --- romio-orig/adio/ad_lustre/ad_lustre_iwrite.c        1969-12-31 19:00:00.000000000 -0500
724 +++ romio/adio/ad_lustre/ad_lustre_iwrite.c     2006-09-06 17:10:35.000761678 -0400
725 @@ -0,0 +1,268 @@
726 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
727 +/*
728 + *   $Id: ad_lustre_iwrite.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
729 + *
730 + *   Copyright (C) 1997 University of Chicago.
731 + *   See COPYRIGHT notice in top-level directory.
732 + */
733 +
734 +#include "ad_lustre.h"
735 +
736 +void ADIOI_LUSTRE_IwriteContig(ADIO_File fd, void *buf, int count,
737 +                MPI_Datatype datatype, int file_ptr_type,
738 +                ADIO_Offset offset, ADIO_Request *request, int *error_code)
739 +{
740 +    int len, typesize;
741 +#ifdef NO_AIO
742 +    ADIO_Status status;
743 +#else
744 +    int err=-1;
745 +#if defined(MPICH2) || !defined(PRINT_ERR_MSG)
746 +    static char myname[] = "ADIOI_LUSTRE_IWRITECONTIG";
747 +#endif
748 +#endif
749 +
750 +    *request = ADIOI_Malloc_request();
751 +    (*request)->optype = ADIOI_WRITE;
752 +    (*request)->fd = fd;
753 +    (*request)->datatype = datatype;
754 +
755 +    MPI_Type_size(datatype, &typesize);
756 +    len = count * typesize;
757 +
758 +#ifdef NO_AIO
759 +    /* HP, FreeBSD, Linux */
760 +    /* no support for nonblocking I/O. Use blocking I/O. */
761 +
762 +    ADIOI_LUSTRE_WriteContig(fd, buf, len, MPI_BYTE, file_ptr_type, offset,
763 +                         &status, error_code);
764 +    (*request)->queued = 0;
765 +#ifdef HAVE_STATUS_SET_BYTES
766 +    if (*error_code == MPI_SUCCESS) {
767 +       MPI_Get_elements(&status, MPI_BYTE, &len);
768 +       (*request)->nbytes = len;
769 +    }
770 +#endif
771 +
772 +#else
773 +    if (file_ptr_type == ADIO_INDIVIDUAL) offset = fd->fp_ind;
774 +    err = ADIOI_LUSTRE_aio(fd, buf, len, offset, 1, &((*request)->handle));
775 +    if (file_ptr_type == ADIO_INDIVIDUAL) fd->fp_ind += len;
776 +
777 +    (*request)->queued = 1;
778 +    ADIOI_Add_req_to_list(request);
779 +
780 +    if (err == -1) {
781 +#ifdef MPICH2
782 +       *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
783 +           "**io %s", strerror(errno));
784 +       return;
785 +#elif defined(PRINT_ERR_MSG)
786 +                       *error_code = MPI_ERR_UNKNOWN;
787 +#else /* MPICH-1 */
788 +       *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
789 +                             myname, "I/O Error", "%s", strerror(errno));
790 +       ADIOI_Error(fd, *error_code, myname);
791 +#endif
792 +    }
793 +    else *error_code = MPI_SUCCESS;
794 +#endif /* NO_AIO */
795 +
796 +    fd->fp_sys_posn = -1;   /* set it to null. */
797 +    fd->async_count++;
798 +}
799 +
800 +
801 +
802 +
803 +void ADIOI_LUSTRE_IwriteStrided(ADIO_File fd, void *buf, int count,
804 +                      MPI_Datatype datatype, int file_ptr_type,
805 +                       ADIO_Offset offset, ADIO_Request *request, int
806 +                       *error_code)
807 +{
808 +    ADIO_Status status;
809 +#ifdef HAVE_STATUS_SET_BYTES
810 +    int typesize;
811 +#endif
812 +
813 +    *request = ADIOI_Malloc_request();
814 +    (*request)->optype = ADIOI_WRITE;
815 +    (*request)->fd = fd;
816 +    (*request)->datatype = datatype;
817 +    (*request)->queued = 0;
818 +    (*request)->handle = 0;
819 +
820 +/* call the blocking version. It is faster because it does data sieving. */
821 +    ADIOI_LUSTRE_WriteStrided(fd, buf, count, datatype, file_ptr_type,
822 +                            offset, &status, error_code);
823 +
824 +    fd->async_count++;
825 +
826 +#ifdef HAVE_STATUS_SET_BYTES
827 +    if (*error_code == MPI_SUCCESS) {
828 +       MPI_Type_size(datatype, &typesize);
829 +       (*request)->nbytes = count * typesize;
830 +    }
831 +#endif
832 +}
833 +
834 +
835 +/* This function is for implementation convenience. It is not user-visible.
836 +   It takes care of the differences in the interface for nonblocking I/O
837 +   on various Unix machines! If wr==1 write, wr==0 read. */
838 +
839 +int ADIOI_LUSTRE_aio(ADIO_File fd, void *buf, int len, ADIO_Offset offset,
840 +                 int wr, void *handle)
841 +{
842 +    int err=-1, fd_sys;
843 +
844 +#ifndef NO_AIO
845 +    int error_code;
846 +#ifdef AIO_SUN
847 +    aio_result_t *result;
848 +#else
849 +    struct aiocb *aiocbp;
850 +#endif
851 +#endif
852 +
853 +    fd_sys = fd->fd_sys;
854 +
855 +#ifdef AIO_SUN
856 +    result = (aio_result_t *) ADIOI_Malloc(sizeof(aio_result_t));
857 +    result->aio_return = AIO_INPROGRESS;
858 +    if (wr) err = aiowrite(fd_sys, buf, len, offset, SEEK_SET, result);
859 +    else err = aioread(fd_sys, buf, len, offset, SEEK_SET, result);
860 +
861 +    if (err == -1) {
862 +       if (errno == EAGAIN) {
863 +       /* the man pages say EPROCLIM, but in reality errno is set to EAGAIN! */
864 +
865 +        /* exceeded the max. no. of outstanding requests.
866 +           complete all previous async. requests and try again.*/
867 +
868 +           ADIOI_Complete_async(&error_code);
869 +           if (wr) err = aiowrite(fd_sys, buf, len, offset, SEEK_SET, result);
870 +           else err = aioread(fd_sys, buf, len, offset, SEEK_SET, result);
871 +
872 +           while (err == -1) {
873 +               if (errno == EAGAIN) {
874 +                    /* sleep and try again */
875 +                    sleep(1);
876 +                   if (wr) err = aiowrite(fd_sys, buf, len, offset, SEEK_SET, result);
877 +                   else err = aioread(fd_sys, buf, len, offset, SEEK_SET, result);
878 +               }
879 +                else {
880 +                    FPRINTF(stderr, "Unknown errno %d in ADIOI_LUSTRE_aio\n", errno);
881 +                    MPI_Abort(MPI_COMM_WORLD, 1);
882 +                }
883 +           }
884 +       }
885 +        else {
886 +            FPRINTF(stderr, "Unknown errno %d in ADIOI_LUSTRE_aio\n", errno);
887 +            MPI_Abort(MPI_COMM_WORLD, 1);
888 +        }
889 +    }
890 +
891 +    *((aio_result_t **) handle) = result;
892 +#endif
893 +
894 +#ifdef NO_FD_IN_AIOCB
895 +/* IBM */
896 +    aiocbp = (struct aiocb *) ADIOI_Malloc(sizeof(struct aiocb));
897 +    aiocbp->aio_whence = SEEK_SET;
898 +    aiocbp->aio_offset = offset;
899 +    aiocbp->aio_buf = buf;
900 +    aiocbp->aio_nbytes = len;
901 +    if (wr) err = aio_write(fd_sys, aiocbp);
902 +    else err = aio_read(fd_sys, aiocbp);
903 +
904 +    if (err == -1) {
905 +       if (errno == EAGAIN) {
906 +        /* exceeded the max. no. of outstanding requests.
907 +          complete all previous async. requests and try again. */
908 +
909 +           ADIOI_Complete_async(&error_code);
910 +           if (wr) err = aio_write(fd_sys, aiocbp);
911 +           else err = aio_read(fd_sys, aiocbp);
912 +
913 +            while (err == -1) {
914 +                if (errno == EAGAIN) {
915 +                    /* sleep and try again */
916 +                    sleep(1);
917 +                   if (wr) err = aio_write(fd_sys, aiocbp);
918 +                   else err = aio_read(fd_sys, aiocbp);
919 +               }
920 +                else {
921 +                    FPRINTF(stderr, "Unknown errno %d in ADIOI_LUSTRE_aio\n", errno);
922 +                    MPI_Abort(MPI_COMM_WORLD, 1);
923 +                }
924 +            }
925 +       }
926 +        else {
927 +            FPRINTF(stderr, "Unknown errno %d in ADIOI_LUSTRE_aio\n", errno);
928 +            MPI_Abort(MPI_COMM_WORLD, 1);
929 +        }
930 +    }
931 +
932 +    *((struct aiocb **) handle) = aiocbp;
933 +
934 +#elif (!defined(NO_AIO) && !defined(AIO_SUN))
935 +/* DEC, SGI IRIX 5 and 6 */
936 +
937 +    aiocbp = (struct aiocb *) ADIOI_Calloc(sizeof(struct aiocb), 1);
938 +    aiocbp->aio_fildes = fd_sys;
939 +    aiocbp->aio_offset = offset;
940 +    aiocbp->aio_buf = buf;
941 +    aiocbp->aio_nbytes = len;
942 +
943 +#ifdef AIO_PRIORITY_DEFAULT
944 +/* DEC */
945 +    aiocbp->aio_reqprio = AIO_PRIO_DFL;   /* not needed in DEC Unix 4.0 */
946 +    aiocbp->aio_sigevent.sigev_signo = 0;
947 +#else
948 +    aiocbp->aio_reqprio = 0;
949 +#endif
950 +
951 +#ifdef AIO_SIGNOTIFY_NONE
952 +/* SGI IRIX 6 */
953 +    aiocbp->aio_sigevent.sigev_notify = SIGEV_NONE;
954 +#else
955 +    aiocbp->aio_sigevent.sigev_signo = 0;
956 +#endif
957 +
958 +    if (wr) err = aio_write(aiocbp);
959 +    else err = aio_read(aiocbp);
960 +
961 +    if (err == -1) {
962 +       if (errno == EAGAIN) {
963 +        /* exceeded the max. no. of outstanding requests.
964 +           complete all previous async. requests and try again. */
965 +
966 +           ADIOI_Complete_async(&error_code);
967 +           if (wr) err = aio_write(aiocbp);
968 +           else err = aio_read(aiocbp);
969 +
970 +           while (err == -1) {
971 +               if (errno == EAGAIN) {
972 +                   /* sleep and try again */
973 +                   sleep(1);
974 +                   if (wr) err = aio_write(aiocbp);
975 +                   else err = aio_read(aiocbp);
976 +               }
977 +               else {
978 +                   FPRINTF(stderr, "Unknown errno %d in ADIOI_LUSTRE_aio\n", errno);
979 +                   MPI_Abort(MPI_COMM_WORLD, 1);
980 +               }
981 +           }
982 +        }
983 +       else {
984 +           FPRINTF(stderr, "Unknown errno %d in ADIOI_LUSTRE_aio\n", errno);
985 +           MPI_Abort(MPI_COMM_WORLD, 1);
986 +       }
987 +    }
988 +
989 +    *((struct aiocb **) handle) = aiocbp;
990 +#endif
991 +
992 +    return err;
993 +}
994 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_open.c romio/adio/ad_lustre/ad_lustre_open.c
995 --- romio-orig/adio/ad_lustre/ad_lustre_open.c  1969-12-31 19:00:00.000000000 -0500
996 +++ romio/adio/ad_lustre/ad_lustre_open.c       2006-09-06 17:10:35.000771351 -0400
997 @@ -0,0 +1,100 @@
998 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
999 +/*
1000 + *   $Id: ad_lustre_open.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
1001 + *
1002 + *   Copyright (C) 1997 University of Chicago.
1003 + *   See COPYRIGHT notice in top-level directory.
1004 + */
1005 +
1006 +#include "ad_lustre.h"
1007 +
1008 +void ADIOI_LUSTRE_Open(ADIO_File fd, int *error_code)
1009 +{
1010 +    int perm, old_mask, amode;
1011 +    struct lov_user_md lum = { 0 };
1012 +    char *value;
1013 +
1014 +#if defined(MPICH2) || !defined(PRINT_ERR_MSG)
1015 +    static char myname[] = "ADIOI_LUSTRE_OPEN";
1016 +#endif
1017 +
1018 +    if (fd->perm == ADIO_PERM_NULL) {
1019 +       old_mask = umask(022);
1020 +       umask(old_mask);
1021 +       perm = old_mask ^ 0666;
1022 +    }
1023 +    else perm = fd->perm;
1024 +
1025 +    amode = 0;
1026 +    if (fd->access_mode & ADIO_CREATE)
1027 +       amode = amode | O_CREAT;
1028 +    if (fd->access_mode & ADIO_RDONLY)
1029 +       amode = amode | O_RDONLY;
1030 +    if (fd->access_mode & ADIO_WRONLY)
1031 +       amode = amode | O_WRONLY;
1032 +    if (fd->access_mode & ADIO_RDWR)
1033 +       amode = amode | O_RDWR;
1034 +    if (fd->access_mode & ADIO_EXCL)
1035 +       amode = amode | O_EXCL;
1036 +
1037 +    fd->fd_sys = open(fd->filename, amode, perm);
1038 +
1039 +    if (fd->fd_sys != -1) {
1040 +        int err;
1041 +
1042 +        value = (char *) ADIOI_Malloc((MPI_MAX_INFO_VAL+1)*sizeof(char));
1043 +
1044 +        /* get file striping information and set it in info */
1045 +        lum.lmm_magic = LOV_USER_MAGIC;
1046 +        err = ioctl(fd->fd_sys, LL_IOC_LOV_GETSTRIPE, (void *) &lum);
1047 +
1048 +        if (!err) {
1049 +            sprintf(value, "%d", lum.lmm_stripe_size);
1050 +            MPI_Info_set(fd->info, "striping_unit", value);
1051 +
1052 +            sprintf(value, "%d", lum.lmm_stripe_count);
1053 +            MPI_Info_set(fd->info, "striping_factor", value);
1054 +
1055 +            sprintf(value, "%d", lum.lmm_stripe_offset);
1056 +            MPI_Info_set(fd->info, "start_iodevice", value);
1057 +        }
1058 +        ADIOI_Free(value);
1059 +
1060 +        if (fd->access_mode & ADIO_APPEND)
1061 +            fd->fp_ind = fd->fp_sys_posn = lseek(fd->fd_sys, 0, SEEK_END);
1062 +    }
1063 +
1064 +
1065 +    if ((fd->fd_sys != -1) && (fd->access_mode & ADIO_APPEND))
1066 +       fd->fp_ind = fd->fp_sys_posn = lseek(fd->fd_sys, 0, SEEK_END);
1067 +
1068 +    if (fd->fd_sys == -1) {
1069 +#ifdef MPICH2
1070 +       if (errno == ENAMETOOLONG)
1071 +           *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_BAD_FILE, "**filenamelong", "**filenamelong %s %d", fd->filename, strlen(fd->filename));
1072 +       else if (errno == ENOENT)
1073 +           *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_NO_SUCH_FILE, "**filenoexist", "**filenoexist %s", fd->filename);
1074 +       else if (errno == ENOTDIR || errno == ELOOP)
1075 +           *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_BAD_FILE, "**filenamedir", "**filenamedir %s", fd->filename);
1076 +       else if (errno == EACCES) {
1077 +           *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_ACCESS, "**fileaccess", "**fileaccess %s",
1078 +                                              fd->filename);
1079 +       }
1080 +       else if (errno == EROFS) {
1081 +           /* Read only file or file system and write access requested */
1082 +           *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_READ_ONLY, "**ioneedrd", 0);
1083 +       }
1084 +       else {
1085 +           *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
1086 +           "**io %s", strerror(errno));
1087 +       }
1088 +#elif defined(PRINT_ERR_MSG)
1089 +                       *error_code = MPI_ERR_UNKNOWN;
1090 +#else /* MPICH-1 */
1091 +       *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
1092 +                             myname, "I/O Error", "%s", strerror(errno));
1093 +       ADIOI_Error(ADIO_FILE_NULL, *error_code, myname);
1094 +#endif
1095 +    }
1096 +    else *error_code = MPI_SUCCESS;
1097 +}
1098 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_rdcoll.c romio/adio/ad_lustre/ad_lustre_rdcoll.c
1099 --- romio-orig/adio/ad_lustre/ad_lustre_rdcoll.c        1969-12-31 19:00:00.000000000 -0500
1100 +++ romio/adio/ad_lustre/ad_lustre_rdcoll.c     2006-09-06 17:10:35.000780880 -0400
1101 @@ -0,0 +1,18 @@
1102 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
1103 +/*
1104 + *   $Id: ad_lustre_rdcoll.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
1105 + *
1106 + *   Copyright (C) 1997 University of Chicago.
1107 + *   See COPYRIGHT notice in top-level directory.
1108 + */
1109 +
1110 +#include "ad_lustre.h"
1111 +
1112 +void ADIOI_LUSTRE_ReadStridedColl(ADIO_File fd, void *buf, int count,
1113 +                       MPI_Datatype datatype, int file_ptr_type,
1114 +                       ADIO_Offset offset, ADIO_Status *status, int
1115 +                       *error_code)
1116 +{
1117 +    ADIOI_GEN_ReadStridedColl(fd, buf, count, datatype, file_ptr_type,
1118 +                             offset, status, error_code);
1119 +}
1120 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_read.c romio/adio/ad_lustre/ad_lustre_read.c
1121 --- romio-orig/adio/ad_lustre/ad_lustre_read.c  1969-12-31 19:00:00.000000000 -0500
1122 +++ romio/adio/ad_lustre/ad_lustre_read.c       2006-09-06 17:10:35.000790846 -0400
1123 @@ -0,0 +1,67 @@
1124 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
1125 +/*
1126 + *   $Id: ad_lustre_read.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
1127 + *
1128 + *   Copyright (C) 1997 University of Chicago.
1129 + *   See COPYRIGHT notice in top-level directory.
1130 + */
1131 +
1132 +#include "ad_lustre.h"
1133 +
1134 +void ADIOI_LUSTRE_ReadContig(ADIO_File fd, void *buf, int count,
1135 +                     MPI_Datatype datatype, int file_ptr_type,
1136 +                    ADIO_Offset offset, ADIO_Status *status, int *error_code)
1137 +{
1138 +    int err=-1, datatype_size, len;
1139 +#if defined(MPICH2) || !defined(PRINT_ERR_MSG)
1140 +    static char myname[] = "ADIOI_LUSTRE_READCONTIG";
1141 +#endif
1142 +
1143 +    MPI_Type_size(datatype, &datatype_size);
1144 +    len = datatype_size * count;
1145 +
1146 +    if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
1147 +       if (fd->fp_sys_posn != offset)
1148 +           lseek(fd->fd_sys, offset, SEEK_SET);
1149 +       err = read(fd->fd_sys, buf, len);
1150 +       fd->fp_sys_posn = offset + len;
1151 +       /* individual file pointer not updated */
1152 +    }
1153 +    else {  /* read from curr. location of ind. file pointer */
1154 +       if (fd->fp_sys_posn != fd->fp_ind)
1155 +           lseek(fd->fd_sys, fd->fp_ind, SEEK_SET);
1156 +       err = read(fd->fd_sys, buf, len);
1157 +       fd->fp_ind += err;
1158 +       fd->fp_sys_posn = fd->fp_ind;
1159 +    }
1160 +
1161 +#ifdef HAVE_STATUS_SET_BYTES
1162 +    if (err != -1) MPIR_Status_set_bytes(status, datatype, err);
1163 +#endif
1164 +
1165 +    if (err == -1) {
1166 +#ifdef MPICH2
1167 +       *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
1168 +           "**io %s", strerror(errno));
1169 +#elif defined(PRINT_ERR_MSG)
1170 +                       *error_code = MPI_ERR_UNKNOWN;
1171 +#else /* MPICH-1 */
1172 +       *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
1173 +                             myname, "I/O Error", "%s", strerror(errno));
1174 +       ADIOI_Error(fd, *error_code, myname);
1175 +#endif
1176 +    }
1177 +    else *error_code = MPI_SUCCESS;
1178 +}
1179 +
1180 +
1181 +
1182 +
1183 +void ADIOI_LUSTRE_ReadStrided(ADIO_File fd, void *buf, int count,
1184 +                       MPI_Datatype datatype, int file_ptr_type,
1185 +                       ADIO_Offset offset, ADIO_Status *status, int
1186 +                       *error_code)
1187 +{
1188 +    ADIOI_GEN_ReadStrided(fd, buf, count, datatype, file_ptr_type,
1189 +                        offset, status, error_code);
1190 +}
1191 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_resize.c romio/adio/ad_lustre/ad_lustre_resize.c
1192 --- romio-orig/adio/ad_lustre/ad_lustre_resize.c        1969-12-31 19:00:00.000000000 -0500
1193 +++ romio/adio/ad_lustre/ad_lustre_resize.c     2006-09-06 17:10:35.000807397 -0400
1194 @@ -0,0 +1,32 @@
1195 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
1196 +/*
1197 + *   $Id: ad_lustre_resize.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
1198 + *
1199 + *   Copyright (C) 1997 University of Chicago.
1200 + *   See COPYRIGHT notice in top-level directory.
1201 + */
1202 +
1203 +#include "ad_lustre.h"
1204 +
1205 +void ADIOI_LUSTRE_Resize(ADIO_File fd, ADIO_Offset size, int *error_code)
1206 +{
1207 +    int err;
1208 +#if defined(MPICH2) || !defined(PRINT_ERR_MSG)
1209 +    static char myname[] = "ADIOI_LUSTRE_RESIZE";
1210 +#endif
1211 +
1212 +    err = ftruncate(fd->fd_sys, size);
1213 +    if (err == -1) {
1214 +#ifdef MPICH2
1215 +       *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
1216 +           "**io %s", strerror(errno));
1217 +#elif defined(PRINT_ERR_MSG)
1218 +                       *error_code = MPI_ERR_UNKNOWN;
1219 +#else /* MPICH-1 */
1220 +       *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
1221 +                             myname, "I/O Error", "%s", strerror(errno));
1222 +       ADIOI_Error(fd, *error_code, myname);
1223 +#endif
1224 +    }
1225 +    else *error_code = MPI_SUCCESS;
1226 +}
1227 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_seek.c romio/adio/ad_lustre/ad_lustre_seek.c
1228 --- romio-orig/adio/ad_lustre/ad_lustre_seek.c  1969-12-31 19:00:00.000000000 -0500
1229 +++ romio/adio/ad_lustre/ad_lustre_seek.c       2006-09-06 17:10:35.000816583 -0400
1230 @@ -0,0 +1,15 @@
1231 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
1232 +/*
1233 + *   $Id: ad_lustre_seek.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
1234 + *
1235 + *   Copyright (C) 1997 University of Chicago.
1236 + *   See COPYRIGHT notice in top-level directory.
1237 + */
1238 +
1239 +#include "ad_lustre.h"
1240 +
1241 +ADIO_Offset ADIOI_LUSTRE_SeekIndividual(ADIO_File fd, ADIO_Offset offset,
1242 +                     int whence, int *error_code)
1243 +{
1244 +    return ADIOI_GEN_SeekIndividual(fd, offset, whence, error_code);
1245 +}
1246 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_wait.c romio/adio/ad_lustre/ad_lustre_wait.c
1247 --- romio-orig/adio/ad_lustre/ad_lustre_wait.c  1969-12-31 19:00:00.000000000 -0500
1248 +++ romio/adio/ad_lustre/ad_lustre_wait.c       2006-09-06 18:45:39.000190529 -0400
1249 @@ -0,0 +1,188 @@
1250 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
1251 +/*
1252 + *   $Id: ad_lustre_wait.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
1253 + *
1254 + *   Copyright (C) 1997 University of Chicago.
1255 + *   See COPYRIGHT notice in top-level directory.
1256 + */
1257 +
1258 +#include "ad_lustre.h"
1259 +
1260 +void ADIOI_LUSTRE_ReadComplete(ADIO_Request *request, ADIO_Status *status, int *error_code)
1261 +{
1262 +#ifndef NO_AIO
1263 +#if defined(MPICH2) || !defined(PRINT_ERR_MSG)
1264 +    static char myname[] = "ADIOI_LUSTRE_READCOMPLETE";
1265 +#endif
1266 +#ifdef AIO_SUN
1267 +    aio_result_t *result=0, *tmp;
1268 +#else
1269 +    int err;
1270 +#endif
1271 +#ifdef AIO_HANDLE_IN_AIOCB
1272 +    struct aiocb *tmp1;
1273 +#endif
1274 +#endif
1275 +
1276 +    if (*request == ADIO_REQUEST_NULL) {
1277 +       *error_code = MPI_SUCCESS;
1278 +       return;
1279 +    }
1280 +
1281 +#ifdef AIO_SUN
1282 +    if ((*request)->queued) {  /* dequeue it */
1283 +       tmp = (aio_result_t *) (*request)->handle;
1284 +       while (tmp->aio_return == AIO_INPROGRESS) usleep(1000);
1285 +       /* sleep for 1 ms., until done. Is 1 ms. a good number? */
1286 +       /* when done, dequeue any one request */
1287 +       result = (aio_result_t *) aiowait(0);
1288 +
1289 +        (*request)->nbytes = tmp->aio_return;
1290 +
1291 +       if (tmp->aio_return == -1) {
1292 +#ifdef MPICH2
1293 +           *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
1294 +               "**io %s", strerror(tmp->aio_errno));
1295 +           return;
1296 +#elif defined(PRINT_ERR_MSG)
1297 +                       *error_code = MPI_ERR_UNKNOWN;
1298 +#else /* MPICH-1 */
1299 +           *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
1300 +                         myname, "I/O Error", "%s", strerror(tmp->aio_errno));
1301 +           ADIOI_Error((*request)->fd, *error_code, myname);
1302 +#endif
1303 +       }
1304 +       else *error_code = MPI_SUCCESS;
1305 +
1306 +/* aiowait only dequeues a request. The completion of a request can be
1307 +   checked by just checking the aio_return flag in the handle passed
1308 +   to the original aioread()/aiowrite(). Therefore, I need to ensure
1309 +   that aiowait() is called exactly once for each previous
1310 +   aioread()/aiowrite(). This is also taken care of in ADIOI_xxxDone */
1311 +    }
1312 +    else *error_code = MPI_SUCCESS;
1313 +
1314 +#ifdef HAVE_STATUS_SET_BYTES
1315 +    if ((*request)->nbytes != -1)
1316 +       MPIR_Status_set_bytes(status, (*request)->datatype, (*request)->nbytes);
1317 +#endif
1318 +
1319 +#endif
1320 +
1321 +#ifdef AIO_HANDLE_IN_AIOCB
1322 +/* IBM */
1323 +    if ((*request)->queued) {
1324 +       do {
1325 +           err = aio_suspend(1, (struct aiocb **) &((*request)->handle));
1326 +       } while ((err == -1) && (errno == EINTR));
1327 +
1328 +       tmp1 = (struct aiocb *) (*request)->handle;
1329 +       if (err != -1) {
1330 +           err = aio_return(tmp1->aio_handle);
1331 +           (*request)->nbytes = err;
1332 +           errno = aio_error(tmp1->aio_handle);
1333 +       }
1334 +       else (*request)->nbytes = -1;
1335 +
1336 +/* on DEC, it is required to call aio_return to dequeue the request.
1337 +   IBM man pages don't indicate what function to use for dequeue.
1338 +   I'm assuming it is aio_return! POSIX says aio_return may be called
1339 +   only once on a given handle. */
1340 +
1341 +       if (err == -1) {
1342 +#ifdef MPICH2
1343 +           *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
1344 +               "**io %s", strerror(errno));
1345 +           return;
1346 +#elif defined(PRINT_ERR_MSG)
1347 +                       *error_code = MPI_ERR_UNKNOWN;
1348 +#else /* MPICH-1 */
1349 +           *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
1350 +             myname, "I/O Error", "%s", strerror(errno));
1351 +           ADIOI_Error((*request)->fd, *error_code, myname);
1352 +#endif
1353 +       }
1354 +       else *error_code = MPI_SUCCESS;
1355 +    } /* if ((*request)->queued)  */
1356 +    else *error_code = MPI_SUCCESS;
1357 +
1358 +#ifdef HAVE_STATUS_SET_BYTES
1359 +    if ((*request)->nbytes != -1)
1360 +       MPIR_Status_set_bytes(status, (*request)->datatype, (*request)->nbytes);
1361 +#endif
1362 +
1363 +#elif (!defined(NO_AIO) && !defined(AIO_SUN))
1364 +/* DEC, SGI IRIX 5 and 6 */
1365 +    if ((*request)->queued) {
1366 +       do {
1367 +           err = aio_suspend((const struct aiocb_t **) &((*request)->handle), 1, 0);
1368 +       } while ((err == -1) && (errno == EINTR));
1369 +
1370 +       if (err != -1) {
1371 +           err = aio_return((struct aiocb *) (*request)->handle);
1372 +           (*request)->nbytes = err;
1373 +           errno = aio_error((struct aiocb *) (*request)->handle);
1374 +       }
1375 +       else (*request)->nbytes = -1;
1376 +
1377 +       if (err == -1) {
1378 +#ifdef MPICH2
1379 +           *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
1380 +               "**io %s", strerror(errno));
1381 +           return;
1382 +#elif defined(PRINT_ERR_MSG)
1383 +                       *error_code = MPI_ERR_UNKNOWN;
1384 +#else /* MPICH-1 */
1385 +           *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
1386 +                           myname, "I/O Error", "%s", strerror(errno));
1387 +           ADIOI_Error((*request)->fd, *error_code, myname);
1388 +#endif
1389 +       }
1390 +       else *error_code = MPI_SUCCESS;
1391 +    } /* if ((*request)->queued) */
1392 +    else *error_code = MPI_SUCCESS;
1393 +#ifdef HAVE_STATUS_SET_BYTES
1394 +    if ((*request)->nbytes != -1)
1395 +       MPIR_Status_set_bytes(status, (*request)->datatype, (*request)->nbytes);
1396 +#endif
1397 +#endif
1398 +
1399 +#ifndef NO_AIO
1400 +    if ((*request)->queued != -1) {
1401 +
1402 +       /* queued = -1 is an internal hack used when the request must
1403 +          be completed, but the request object should not be
1404 +          freed. This is used in ADIOI_Complete_async, because the user
1405 +          will call MPI_Wait later, which would require status to
1406 +          be filled. Ugly but works. queued = -1 should be used only
1407 +          in ADIOI_Complete_async.
1408 +           This should not affect the user in any way. */
1409 +
1410 +       /* if request is still queued in the system, it is also there
1411 +           on ADIOI_Async_list. Delete it from there. */
1412 +       if ((*request)->queued) ADIOI_Del_req_from_list(request);
1413 +
1414 +       (*request)->fd->async_count--;
1415 +       if ((*request)->handle) ADIOI_Free((*request)->handle);
1416 +       ADIOI_Free_request((ADIOI_Req_node *) (*request));
1417 +       *request = ADIO_REQUEST_NULL;
1418 +    }
1419 +
1420 +#else
1421 +/* HP, FreeBSD, Linux */
1422 +
1423 +#ifdef HAVE_STATUS_SET_BYTES
1424 +    MPIR_Status_set_bytes(status, (*request)->datatype, (*request)->nbytes);
1425 +#endif
1426 +    (*request)->fd->async_count--;
1427 +    ADIOI_Free_request((ADIOI_Req_node *) (*request));
1428 +    *request = ADIO_REQUEST_NULL;
1429 +    *error_code = MPI_SUCCESS;
1430 +#endif
1431 +}
1432 +
1433 +
1434 +void ADIOI_LUSTRE_WriteComplete(ADIO_Request *request, ADIO_Status *status, int *error_code)
1435 +{
1436 +    ADIOI_LUSTRE_ReadComplete(request, status, error_code);
1437 +}
1438 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_wrcoll.c romio/adio/ad_lustre/ad_lustre_wrcoll.c
1439 --- romio-orig/adio/ad_lustre/ad_lustre_wrcoll.c        1969-12-31 19:00:00.000000000 -0500
1440 +++ romio/adio/ad_lustre/ad_lustre_wrcoll.c     2006-09-06 17:10:35.000835460 -0400
1441 @@ -0,0 +1,18 @@
1442 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
1443 +/*
1444 + *   $Id: ad_lustre_wrcoll.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
1445 + *
1446 + *   Copyright (C) 1997 University of Chicago.
1447 + *   See COPYRIGHT notice in top-level directory.
1448 + */
1449 +
1450 +#include "ad_lustre.h"
1451 +
1452 +void ADIOI_LUSTRE_WriteStridedColl(ADIO_File fd, void *buf, int count,
1453 +                       MPI_Datatype datatype, int file_ptr_type,
1454 +                       ADIO_Offset offset, ADIO_Status *status, int
1455 +                       *error_code)
1456 +{
1457 +    ADIOI_GEN_WriteStridedColl(fd, buf, count, datatype, file_ptr_type,
1458 +                             offset, status, error_code);
1459 +}
1460 diff -ruN romio-orig/adio/ad_lustre/ad_lustre_write.c romio/adio/ad_lustre/ad_lustre_write.c
1461 --- romio-orig/adio/ad_lustre/ad_lustre_write.c 1969-12-31 19:00:00.000000000 -0500
1462 +++ romio/adio/ad_lustre/ad_lustre_write.c      2006-09-06 17:10:35.000844658 -0400
1463 @@ -0,0 +1,66 @@
1464 +/* -*- Mode: C; c-basic-offset:4 ; -*- */
1465 +/*
1466 + *   $Id: ad_lustre_write.c,v 1.1.1.1 2004/11/04 11:03:38 liam Exp $
1467 + *
1468 + *   Copyright (C) 1997 University of Chicago.
1469 + *   See COPYRIGHT notice in top-level directory.
1470 + */
1471 +
1472 +#include "ad_lustre.h"
1473 +
1474 +void ADIOI_LUSTRE_WriteContig(ADIO_File fd, void *buf, int count,
1475 +                   MPI_Datatype datatype, int file_ptr_type,
1476 +                  ADIO_Offset offset, ADIO_Status *status, int *error_code)
1477 +{
1478 +    int err=-1, datatype_size, len;
1479 +#if defined(MPICH2) || !defined(PRINT_ERR_MSG)
1480 +    static char myname[] = "ADIOI_LUSTRE_WRITECONTIG";
1481 +#endif
1482 +
1483 +    MPI_Type_size(datatype, &datatype_size);
1484 +    len = datatype_size * count;
1485 +
1486 +    if (file_ptr_type == ADIO_EXPLICIT_OFFSET) {
1487 +       if (fd->fp_sys_posn != offset)
1488 +           lseek(fd->fd_sys, offset, SEEK_SET);
1489 +       err = write(fd->fd_sys, buf, len);
1490 +       fd->fp_sys_posn = offset + err;
1491 +       /* individual file pointer not updated */
1492 +    }
1493 +    else { /* write from curr. location of ind. file pointer */
1494 +       if (fd->fp_sys_posn != fd->fp_ind)
1495 +           lseek(fd->fd_sys, fd->fp_ind, SEEK_SET);
1496 +       err = write(fd->fd_sys, buf, len);
1497 +       fd->fp_ind += err;
1498 +       fd->fp_sys_posn = fd->fp_ind;
1499 +    }
1500 +
1501 +#ifdef HAVE_STATUS_SET_BYTES
1502 +    if (err != -1 && status) MPIR_Status_set_bytes(status, datatype, err);
1503 +#endif
1504 +
1505 +    if (err == -1) {
1506 +#ifdef MPICH2
1507 +       *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**io",
1508 +           "**io %s", strerror(errno));
1509 +#elif defined(PRINT_ERR_MSG)
1510 +                       *error_code = MPI_ERR_UNKNOWN;
1511 +#else
1512 +       *error_code = MPIR_Err_setmsg(MPI_ERR_IO, MPIR_ADIO_ERROR,
1513 +                             myname, "I/O Error", "%s", strerror(errno));
1514 +       ADIOI_Error(fd, *error_code, myname);
1515 +#endif
1516 +    }
1517 +    else *error_code = MPI_SUCCESS;
1518 +}
1519 +
1520 +
1521 +
1522 +void ADIOI_LUSTRE_WriteStrided(ADIO_File fd, void *buf, int count,
1523 +                       MPI_Datatype datatype, int file_ptr_type,
1524 +                       ADIO_Offset offset, ADIO_Status *status, int
1525 +                       *error_code)
1526 +{
1527 +    ADIOI_GEN_WriteStrided(fd, buf, count, datatype, file_ptr_type,
1528 +                        offset, status, error_code);
1529 +}
1530 diff -ruN romio-orig/adio/ad_lustre/Makefile.in romio/adio/ad_lustre/Makefile.in
1531 --- romio-orig/adio/ad_lustre/Makefile.in       1969-12-31 19:00:00.000000000 -0500
1532 +++ romio/adio/ad_lustre/Makefile.in    2006-09-06 18:48:56.000800829 -0400
1533 @@ -0,0 +1,51 @@
1534 +CC          = @CC@
1535 +AR          = @AR@
1536 +RANLIB      = @RANLIB@
1537 +LIBNAME     = @LIBNAME@
1538 +srcdir      = @srcdir@
1539 +CC_SHL      = @CC_SHL@
1540 +SHLIBNAME   = @SHLIBNAME@
1541 +
1542 +INCLUDE_DIR = -I@MPI_INCLUDE_DIR@ -I${srcdir}/../include -I../include -I../../include -I${srcdir}/../../../../include -I../../../../include
1543 +CFLAGS      = @CPPFLAGS@ @CFLAGS@ $(INCLUDE_DIR)
1544 +
1545 +top_builddir  = @master_topbuild_dir@
1546 +LIBTOOL       = @LIBTOOL@
1547 +C_COMPILE_SHL = $(CC_SHL) @CFLAGS@ $(INCLUDE_DIR)
1548 +
1549 +@VPATH@
1550 +
1551 +AD_LUSTRE_OBJECTS = ad_lustre.o ad_lustre_close.o ad_lustre_read.o \
1552 +      ad_lustre_open.o ad_lustre_write.o ad_lustre_done.o \
1553 +      ad_lustre_fcntl.o ad_lustre_iread.o ad_lustre_iwrite.o ad_lustre_wait.o \
1554 +      ad_lustre_resize.o ad_lustre_hints.o
1555 +
1556 +default: $(LIBNAME)
1557 +       @if [ "@ENABLE_SHLIB@" != "none" ] ; then \
1558 +           $(MAKE) $(SHLIBNAME).la ;\
1559 +       fi
1560 +
1561 +.SUFFIXES: $(SUFFIXES) .p .lo
1562 +
1563 +.c.o:
1564 +       $(CC) $(CFLAGS) -c $<
1565 +.c.lo:
1566 +       $(C_COMPILE_SHL) -c $< -o _s$*.o
1567 +       @mv -f _s$*.o $*.lo
1568 +#      $(C_COMPILE_SHL) -c $<
1569 +#      @mv -f $*.o $*.lo
1570 +
1571 +$(LIBNAME): $(AD_LUSTRE_OBJECTS)
1572 +       $(AR) $(LIBNAME) $(AD_LUSTRE_OBJECTS)
1573 +       $(RANLIB) $(LIBNAME)
1574 +
1575 +AD_LUSTRE_LOOBJECTS=$(AD_LUSTRE_OBJECTS:.o=.lo)
1576 +$(SHLIBNAME).la: $(AD_LUSTRE_LOOBJECTS)
1577 +       $(AR) $(SHLIBNAME).la $(AD_LUSTRE_LOOBJECTS)
1578 +
1579 +coverage:
1580 +       -@for file in  ${AD_LUSTRE_OBJECTS:.o=.c} ; do \
1581 +               gcov -b -f $$file ; done
1582 +
1583 +clean:
1584 +       @rm -f *.o *.lo
1585 diff -ruN romio-orig/adio/common/ad_fstype.c romio/adio/common/ad_fstype.c
1586 --- romio-orig/adio/common/ad_fstype.c  2005-08-11 19:33:46.000000000 -0400
1587 +++ romio/adio/common/ad_fstype.c       2006-09-06 17:41:20.000830936 -0400
1588 @@ -265,6 +265,9 @@
1589      /* if UFS support is enabled, default to that */
1590      *fstype = ADIO_UFS;
1591      return;
1592 +# elif defined(LINUX) && defined(ROMIO_LUSTRE)
1593 +# warning use correct include
1594 +# define LL_SUPER_MAGIC 0x0BD00BD0
1595  # endif
1596  
1597      /* --BEGIN ERROR HANDLING-- */
1598 @@ -308,6 +311,13 @@
1599      }
1600  # endif
1601  
1602 +# ifdef LL_SUPER_MAGIC
1603 +    if (fsbuf.f_type == LL_SUPER_MAGIC) {
1604 +       *fstype = ADIO_LUSTRE;
1605 +       return;
1606 +    }
1607 +# endif
1608 +
1609  # ifdef PAN_KERNEL_FS_CLIENT_SUPER_MAGIC
1610      if (fsbuf.f_type == PAN_KERNEL_FS_CLIENT_SUPER_MAGIC) {
1611         *fstype = ADIO_PANFS;
1612 @@ -458,6 +468,11 @@
1613      {
1614         *fstype = ADIO_GRIDFTP;
1615      }
1616 +    else if (!strncmp(filename, "lustre:", 7)
1617 +            || !strncmp(filename, "LUSTRE:", 7))
1618 +    {
1619 +       *fstype = ADIO_LUSTRE;
1620 +    }
1621      else {
1622  #ifdef ROMIO_NTFS
1623         *fstype = ADIO_NTFS;
1624 @@ -657,6 +672,14 @@
1625         *ops = &ADIO_GRIDFTP_operations;
1626  #endif
1627      }
1628 +    if (file_system == ADIO_LUSTRE) {
1629 +#ifndef ROMIO_LUSTRE
1630 +       *error_code = MPIR_Err_create_code(MPI_SUCCESS, MPIR_ERR_RECOVERABLE, myname, __LINE__, MPI_ERR_IO, "**iofstypeunsupported", 0);
1631 +       return;
1632 +#else
1633 +       *ops = &ADIO_LUSTRE_operations;
1634 +#endif
1635 +    }
1636      *error_code = MPI_SUCCESS;
1637      *fstype = file_system;
1638      return;
1639 diff -ruN romio-orig/adio/include/adio.h romio/adio/include/adio.h
1640 --- romio-orig/adio/include/adio.h      2006-06-09 17:45:04.000000000 -0400
1641 +++ romio/adio/include/adio.h   2006-09-06 17:44:16.000614058 -0400
1642 @@ -302,6 +302,7 @@
1643  #define ADIO_PVFS2               160   /* PVFS2: 2nd generation PVFS */
1644  #define ADIO_PANFS               161   /* Panasas FS */
1645  #define ADIO_GRIDFTP             162   /* Globus GridFTP */
1646 +#define ADIO_LUSTRE              163   /* Lustre */
1647  
1648  #define ADIO_SEEK_SET            SEEK_SET
1649  #define ADIO_SEEK_CUR            SEEK_CUR
1650 diff -ruN romio-orig/adio/include/adioi_fs_proto.h romio/adio/include/adioi_fs_proto.h
1651 --- romio-orig/adio/include/adioi_fs_proto.h    2005-06-08 17:16:39.000000000 -0400
1652 +++ romio/adio/include/adioi_fs_proto.h 2006-09-06 17:48:11.000523566 -0400
1653 @@ -49,6 +49,68 @@
1654  /* prototypes are in adio/ad_sfs/ad_sfs.h */
1655  #endif
1656  
1657 +#ifdef ROMIO_LUSTRE
1658 +extern struct ADIOI_Fns_struct ADIO_LUSTRE_operations;
1659 +
1660 +void ADIOI_LUSTRE_Open(ADIO_File fd, int *error_code);
1661 +void ADIOI_LUSTRE_Close(ADIO_File fd, int *error_code);
1662 +void ADIOI_LUSTRE_ReadContig(ADIO_File fd, void *buf, int count,
1663 +                      MPI_Datatype datatype, int file_ptr_type,
1664 +                     ADIO_Offset offset, ADIO_Status *status, int
1665 +                    *error_code);
1666 +void ADIOI_LUSTRE_WriteContig(ADIO_File fd, void *buf, int count,
1667 +                      MPI_Datatype datatype, int file_ptr_type,
1668 +                      ADIO_Offset offset, ADIO_Status *status, int
1669 +                     *error_code);
1670 +void ADIOI_LUSTRE_IwriteContig(ADIO_File fd, void *buf, int count,
1671 +                      MPI_Datatype datatype, int file_ptr_type,
1672 +                      ADIO_Offset offset, ADIO_Request *request, int
1673 +                     *error_code);
1674 +void ADIOI_LUSTRE_IreadContig(ADIO_File fd, void *buf, int count,
1675 +                      MPI_Datatype datatype, int file_ptr_type,
1676 +                      ADIO_Offset offset, ADIO_Request *request, int
1677 +                     *error_code);
1678 +int ADIOI_LUSTRE_ReadDone(ADIO_Request *request, ADIO_Status *status, int
1679 +                      *error_code);
1680 +int ADIOI_LUSTRE_WriteDone(ADIO_Request *request, ADIO_Status *status, int
1681 +                      *error_code);
1682 +void ADIOI_LUSTRE_ReadComplete(ADIO_Request *request, ADIO_Status *status, int
1683 +                      *error_code);
1684 +void ADIOI_LUSTRE_WriteComplete(ADIO_Request *request, ADIO_Status *status,
1685 +                       int *error_code);
1686 +void ADIOI_LUSTRE_Fcntl(ADIO_File fd, int flag, ADIO_Fcntl_t *fcntl_struct, int
1687 +               *error_code);
1688 +void ADIOI_LUSTRE_WriteStrided(ADIO_File fd, void *buf, int count,
1689 +                      MPI_Datatype datatype, int file_ptr_type,
1690 +                      ADIO_Offset offset, ADIO_Status *status, int
1691 +                      *error_code);
1692 +void ADIOI_LUSTRE_ReadStrided(ADIO_File fd, void *buf, int count,
1693 +                      MPI_Datatype datatype, int file_ptr_type,
1694 +                      ADIO_Offset offset, ADIO_Status *status, int
1695 +                      *error_code);
1696 +void ADIOI_LUSTRE_WriteStridedColl(ADIO_File fd, void *buf, int count,
1697 +                      MPI_Datatype datatype, int file_ptr_type,
1698 +                      ADIO_Offset offset, ADIO_Status *status, int
1699 +                      *error_code);
1700 +void ADIOI_LUSTRE_ReadStridedColl(ADIO_File fd, void *buf, int count,
1701 +                      MPI_Datatype datatype, int file_ptr_type,
1702 +                      ADIO_Offset offset, ADIO_Status *status, int
1703 +                      *error_code);
1704 +void ADIOI_LUSTRE_IreadStrided(ADIO_File fd, void *buf, int count,
1705 +                      MPI_Datatype datatype, int file_ptr_type,
1706 +                      ADIO_Offset offset, ADIO_Request *request, int
1707 +                      *error_code);
1708 +void ADIOI_LUSTRE_IwriteStrided(ADIO_File fd, void *buf, int count,
1709 +                      MPI_Datatype datatype, int file_ptr_type,
1710 +                      ADIO_Offset offset, ADIO_Request *request, int
1711 +                      *error_code);
1712 +void ADIOI_LUSTRE_Flush(ADIO_File fd, int *error_code);
1713 +void ADIOI_LUSTRE_Resize(ADIO_File fd, ADIO_Offset size, int *error_code);
1714 +ADIO_Offset ADIOI_LUSTRE_SeekIndividual(ADIO_File fd, ADIO_Offset offset,
1715 +                       int whence, int *error_code);
1716 +void ADIOI_LUSTRE_SetInfo(ADIO_File fd, MPI_Info users_info, int *error_code);
1717 +#endif
1718 +
1719  #ifdef ROMIO_NTFS
1720  extern struct ADIOI_Fns_struct ADIO_NTFS_operations;
1721  /* prototypes are in adio/ad_ntfs/ad_ntfs.h */
1722 diff -ruN romio-orig/adio/include/mpio_error.h romio/adio/include/mpio_error.h
1723 --- romio-orig/adio/include/mpio_error.h        2005-05-23 19:27:50.000000000 -0400
1724 +++ romio/adio/include/mpio_error.h     2006-09-06 17:10:35.000984078 -0400
1725 @@ -63,6 +63,7 @@
1726  #define MPIR_ERR_FILETYPE 33 
1727  #define MPIR_ERR_NO_NTFS 35
1728  #define MPIR_ERR_NO_TESTFS 36
1729 +#define MPIR_ERR_NO_LUSTRE 37
1730  
1731  /* MPI_ERR_COMM */
1732  #ifndef MPIR_ERR_COMM_NULL
1733 diff -ruN romio-orig/adio/include/romioconf.h.in romio/adio/include/romioconf.h.in
1734 --- romio-orig/adio/include/romioconf.h.in      2006-08-11 09:48:44.000000000 -0400
1735 +++ romio/adio/include/romioconf.h.in   2006-09-06 17:43:08.000599274 -0400
1736 @@ -276,6 +276,9 @@
1737  /* Define for ROMIO with PVFS2 */
1738  #undef ROMIO_PVFS2
1739  
1740 +/* Define for ROMIO with LUSTRE */
1741 +#undef ROMIO_LUSTRE
1742 +
1743  /* Define if int64_t must be defined for PVFS */
1744  #undef ROMIO_PVFS_NEEDS_INT64_DEFINITION
1745  
1746 diff -ruN romio-orig/configure romio/configure
1747 --- romio-orig/configure        2006-08-11 09:48:45.000000000 -0400
1748 +++ romio/configure     2006-09-06 17:20:57.000555513 -0400
1749 @@ -1400,7 +1400,7 @@
1750  #
1751  have_aio=no
1752  #
1753 -known_filesystems="nfs ufs pfs pvfs pvfs2 testfs xfs panfs gridftp"
1754 +known_filesystems="nfs ufs pfs pvfs pvfs2 testfs xfs panfs gridftp lustre"
1755  known_mpi_impls="mpich2_mpi mpich_mpi sgi_mpi hp_mpi cray_mpi lam_mpi"
1756  #
1757  # Defaults
1758 @@ -7490,6 +7490,14 @@
1759  
1760  fi
1761  
1762 +if test -n "$file_system_lustre"; then
1763 +
1764 +cat >>confdefs.h <<\_ACEOF
1765 +#define ROMIO_LUSTRE 1
1766 +_ACEOF
1767 +
1768 +fi
1769 +
1770  #
1771  # Check for presence and characteristics of async. I/O calls if
1772  # not disabled.
1773 @@ -11977,7 +11985,7 @@
1774  # are active will be called by the top level ROMIO make
1775            ac_config_commands="$ac_config_commands default-1"
1776  
1777 -                                                                                                                                                                                                                                                                                                                                          ac_config_files="$ac_config_files Makefile localdefs mpi-io/Makefile mpi2-other/info/Makefile mpi2-other/array/Makefile adio/common/Makefile test/Makefile test/misc.c test/large_file.c test/runtests util/romioinstall include/mpio.h include/mpiof.h adio/ad_nfs/Makefile adio/ad_ufs/Makefile adio/ad_panfs/Makefile adio/ad_xfs/Makefile adio/ad_sfs/Makefile adio/ad_pfs/Makefile adio/ad_testfs/Makefile adio/ad_pvfs/Makefile adio/ad_pvfs2/Makefile adio/ad_gridftp/Makefile mpi-io/fortran/Makefile mpi2-other/info/fortran/Makefile mpi2-other/array/fortran/Makefile test/fmisc.f test/fcoll_test.f test/pfcoll_test.f test/fperf.f mpi-io/glue/mpich2/Makefile mpi-io/glue/mpich1/Makefile mpi-io/glue/default/Makefile"
1778 +                                                                                                                                                                                                                                                                                                                                          ac_config_files="$ac_config_files Makefile localdefs mpi-io/Makefile mpi2-other/info/Makefile mpi2-other/array/Makefile adio/common/Makefile test/Makefile test/misc.c test/large_file.c test/runtests util/romioinstall include/mpio.h include/mpiof.h adio/ad_nfs/Makefile adio/ad_ufs/Makefile adio/ad_panfs/Makefile adio/ad_xfs/Makefile adio/ad_sfs/Makefile adio/ad_pfs/Makefile adio/ad_testfs/Makefile adio/ad_pvfs/Makefile adio/ad_pvfs2/Makefile adio/ad_gridftp/Makefile adio/ad_lustre/Makefile mpi-io/fortran/Makefile mpi2-other/info/fortran/Makefile mpi2-other/array/fortran/Makefile test/fmisc.f test/fcoll_test.f test/pfcoll_test.f test/fperf.f mpi-io/glue/mpich2/Makefile mpi-io/glue/mpich1/Makefile mpi-io/glue/default/Makefile"
1779  cat >confcache <<\_ACEOF
1780  # This file is a shell script that caches the results of configure
1781  # tests run on this system so they can be shared between configure
1782 @@ -12535,6 +12543,7 @@
1783    "adio/ad_pvfs/Makefile" ) CONFIG_FILES="$CONFIG_FILES adio/ad_pvfs/Makefile" ;;
1784    "adio/ad_pvfs2/Makefile" ) CONFIG_FILES="$CONFIG_FILES adio/ad_pvfs2/Makefile" ;;
1785    "adio/ad_gridftp/Makefile" ) CONFIG_FILES="$CONFIG_FILES adio/ad_gridftp/Makefile" ;;
1786 +  "adio/ad_lustre/Makefile" ) CONFIG_FILES="$CONFIG_FILES adio/ad_lustre/Makefile" ;;
1787    "mpi-io/fortran/Makefile" ) CONFIG_FILES="$CONFIG_FILES mpi-io/fortran/Makefile" ;;
1788    "mpi2-other/info/fortran/Makefile" ) CONFIG_FILES="$CONFIG_FILES mpi2-other/info/fortran/Makefile" ;;
1789    "mpi2-other/array/fortran/Makefile" ) CONFIG_FILES="$CONFIG_FILES mpi2-other/array/fortran/Makefile" ;;
1790 diff -ruN romio-orig/configure.in romio/configure.in
1791 --- romio-orig/configure.in     2006-07-24 17:55:57.000000000 -0400
1792 +++ romio/configure.in  2006-09-06 17:16:13.000525117 -0400
1793 @@ -93,7 +93,7 @@
1794  #
1795  have_aio=no
1796  #
1797 -known_filesystems="nfs ufs pfs pvfs pvfs2 testfs xfs panfs gridftp"
1798 +known_filesystems="nfs ufs pfs pvfs pvfs2 testfs xfs panfs gridftp lustre"
1799  known_mpi_impls="mpich2_mpi mpich_mpi sgi_mpi hp_mpi cray_mpi lam_mpi"
1800  #
1801  # Defaults
1802 @@ -1062,6 +1062,9 @@
1803  if test -n "$file_system_testfs"; then
1804      AC_DEFINE(ROMIO_TESTFS,1,[Define for ROMIO with TESTFS])
1805  fi
1806 +if test -n "$file_system_lustre"; then
1807 +    AC_DEFINE(ROMIO_LUSTRE,1,[Define for ROMIO with LUSTRE])
1808 +fi
1809  
1810  if test -n "$file_system_xfs"; then
1811      AC_DEFINE(ROMIO_XFS,1,[Define for ROMIO with XFS])
1812 @@ -2024,6 +2027,7 @@
1813                    adio/ad_testfs/Makefile adio/ad_pvfs/Makefile \
1814                    adio/ad_pvfs2/Makefile \
1815                    adio/ad_gridftp/Makefile \
1816 +                  adio/ad_lustre/Makefile \
1817                     mpi-io/fortran/Makefile mpi2-other/info/fortran/Makefile \
1818                     mpi2-other/array/fortran/Makefile test/fmisc.f \
1819                     test/fcoll_test.f test/pfcoll_test.f test/fperf.f \
1820 diff -ruN romio-orig/Makefile.in romio/Makefile.in
1821 --- romio-orig/Makefile.in      2005-05-24 18:53:11.000000000 -0400
1822 +++ romio/Makefile.in   2006-09-06 17:13:25.000393429 -0400
1823 @@ -14,7 +14,7 @@
1824  MPIO_DIRS   = mpi-io
1825  EXTRA_SRC_DIRS = @EXTRA_SRC_DIRS@
1826  FILE_SYS_DIRS = @FILE_SYS_DIRS@
1827 -ALL_DIRS    = mpi-io mpi-io/fortran mpi2-other/info mpi2-other/info/fortran mpi2-other/array mpi2-other/array/fortran adio/common adio/ad_pfs adio/ad_piofs adio/ad_nfs adio/ad_ufs adio/ad_xfs adio/ad_hfs adio/ad_sfs adio/ad_testfs adio/ad_pvfs adio/ad_pvfs2 adio/ad_panfs adio/ad_gridftp test
1828 +ALL_DIRS    = mpi-io mpi-io/fortran mpi2-other/info mpi2-other/info/fortran mpi2-other/array mpi2-other/array/fortran adio/common adio/ad_pfs adio/ad_piofs adio/ad_nfs adio/ad_ufs adio/ad_xfs adio/ad_hfs adio/ad_sfs adio/ad_testfs adio/ad_pvfs adio/ad_pvfs2 adio/ad_panfs adio/ad_gridftp adio/ad_lustre test
1829  SHELL       = /bin/sh
1830  
1831  @VPATH@