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