4 * Copyright (C) 2008 Adam Williams <broadcast at earthling dot net>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 // Disable 64 bit indirections so we can override both functions.
23 #undef _LARGEFILE64_SOURCE
24 #undef _LARGEFILE_SOURCE
25 #undef _FILE_OFFSET_BITS
29 #include "renderfarm.h"
30 #include "renderfarmclient.h"
31 #include "renderfarmfsclient.h"
32 #include "renderfarmfsserver.h"
46 // These are hacks to get all the file I/O libraries to transparently
47 // go over the network without rewriting them.
59 RenderFarmFSClient *renderfarm_fs_global = 0;
62 // open doesn't seem overridable
63 // int open (__const char *path, int flags, ...)
65 // static int (*func)(__const char *__file, int __oflag) = 0;
67 // printf("open %s\n", path);
70 // func = (int(*)(const char *path, int flags))dlsym(RTLD_NEXT, "open");
72 // result = (*func)(path, flags);
77 FILE* fopen(const char *path, const char *mode)
79 static FILE* (*func)(const char *path, const char *mode) = 0;
80 // This pointer is meaningless except on the server.
84 func = (FILE*(*)(const char *path, const char *mode))dlsym(RTLD_NEXT, "fopen");
87 if(!strncmp(path, RENDERFARM_FS_PREFIX, strlen(RENDERFARM_FS_PREFIX)))
89 renderfarm_fs_global->lock();
90 result = renderfarm_fs_global->fopen(path, mode);
91 renderfarm_fs_global->unlock();
94 result = (*func)(path, mode);
99 FILE* fopen64(const char *path, const char *mode)
101 static FILE* (*func)(const char *path, const char *mode) = 0;
102 // This pointer is meaningless except on the server.
106 func = (FILE*(*)(const char *path, const char *mode))dlsym(RTLD_NEXT, "fopen64");
109 if(!strncmp(path, RENDERFARM_FS_PREFIX, strlen(RENDERFARM_FS_PREFIX)))
111 renderfarm_fs_global->lock();
112 result = renderfarm_fs_global->fopen(path, mode);
113 renderfarm_fs_global->unlock();
116 result = (*func)(path, mode);
123 int fclose(FILE *file)
125 static int (*func)(FILE *) = 0;
126 int result = 0, done = 0;
128 func = (int(*)(FILE *))dlsym(RTLD_NEXT, "fclose");
129 //printf("fclose\n");
131 if(renderfarm_fs_global)
133 renderfarm_fs_global->lock();
134 if(renderfarm_fs_global->is_open(file))
136 result = renderfarm_fs_global->fclose(file);
139 renderfarm_fs_global->unlock();
142 if(!done) result = (*func)(file);
146 int fileno (FILE *stream)
148 static int (*func)(FILE *) = 0;
151 func = (int(*)(FILE *))dlsym(RTLD_NEXT, "fileno");
152 if(renderfarm_fs_global)
154 renderfarm_fs_global->lock();
155 if(renderfarm_fs_global->is_open(stream))
157 result = renderfarm_fs_global->fileno(stream);
159 renderfarm_fs_global->unlock();
162 result = (*func)(stream);
166 // int fflush(FILE *file)
168 // static int (*func)(FILE *) = 0;
169 // int result = 0, done = 0;
171 // func = (int(*)(FILE *))dlsym(RTLD_NEXT, "fflush");
172 // //printf("fflush\n");
174 // renderfarm_fs_global->lock();
175 // if(renderfarm_fs_global->is_open(file))
177 // result = renderfarm_fs_global->fflush(file);
180 // renderfarm_fs_global->unlock();
182 // if(!done) result = (*func)(file);
186 int remove (__const char *__filename)
188 static int (*func)(__const char *) = 0;
191 func = (int(*)(__const char *))dlsym(RTLD_NEXT, "remove");
192 //printf("remove\n");
195 if(!strncmp(__filename, RENDERFARM_FS_PREFIX, strlen(RENDERFARM_FS_PREFIX)))
197 renderfarm_fs_global->lock();
198 result = renderfarm_fs_global->remove(__filename);
199 renderfarm_fs_global->unlock();
202 result = (*func)(__filename);
207 int rename (__const char *__old, __const char *__new)
209 static int (*func)(__const char *, __const char *) = 0;
212 func = (int(*)(__const char *, __const char *))dlsym(RTLD_NEXT, "rename");
213 //printf("rename\n");
216 if(!strncmp(__old, RENDERFARM_FS_PREFIX, strlen(RENDERFARM_FS_PREFIX)))
218 renderfarm_fs_global->lock();
219 result = renderfarm_fs_global->rename(__old, __new);
220 renderfarm_fs_global->unlock();
223 result = (*func)(__old, __new);
228 int fgetc (FILE *__stream)
230 static int (*func)(FILE *) = 0;
231 int result = 0, done = 0;
233 func = (int(*)(FILE *))dlsym(RTLD_NEXT, "fgetc");
236 if(renderfarm_fs_global)
238 renderfarm_fs_global->lock();
239 if(renderfarm_fs_global->is_open(__stream))
241 result = renderfarm_fs_global->fgetc(__stream);
244 renderfarm_fs_global->unlock();
247 if(!done) result = (*func)(__stream);
251 int getc (FILE *__stream)
253 return fgetc(__stream);
256 int fputc (int __c, FILE *__stream)
258 static int (*func)(int, FILE *) = 0;
259 int result = 0, done = 0;
261 func = (int(*)(int, FILE *))dlsym(RTLD_NEXT, "fputc");
264 if(renderfarm_fs_global)
266 renderfarm_fs_global->lock();
267 if(renderfarm_fs_global->is_open(__stream))
269 result = renderfarm_fs_global->fputc(__c, __stream);
272 renderfarm_fs_global->unlock();
275 if(!done) result = (*func)(__c, __stream);
279 int putc (int __c, FILE *__stream)
281 return fputc(__c, __stream);
284 size_t fread (void *__restrict __ptr, size_t __size,
285 size_t __n, FILE *__restrict __stream)
287 static int (*func)(void *, size_t, size_t, FILE *) = 0;
291 func = (int(*)(void *, size_t, size_t, FILE *))dlsym(RTLD_NEXT, "fread");
294 if(renderfarm_fs_global)
296 renderfarm_fs_global->lock();
297 if(renderfarm_fs_global->is_open(__stream))
299 result = renderfarm_fs_global->fread(__ptr, __size, __n, __stream);
302 renderfarm_fs_global->unlock();
305 if(!done) result = (*func)(__ptr, __size, __n, __stream);
310 size_t fwrite (__const void *__restrict __ptr, size_t __size,
311 size_t __n, FILE *__restrict __s)
313 static int (*func)(__const void *, size_t, size_t, FILE *) = 0;
317 func = (int(*)(__const void *, size_t, size_t, FILE *))dlsym(RTLD_NEXT, "fwrite");
319 if(renderfarm_fs_global)
321 renderfarm_fs_global->lock();
322 if(renderfarm_fs_global->is_open(__s))
324 result = renderfarm_fs_global->fwrite(__ptr, __size, __n, __s);
327 renderfarm_fs_global->unlock();
330 if(!done) result = (*func)(__ptr, __size, __n, __s);
335 int fseek (FILE *__stream, long int __off, int __whence)
337 static int (*func)(FILE *, long int, int) = 0;
341 func = (int(*)(FILE *, long int, int))dlsym(RTLD_NEXT, "fseek");
344 if(renderfarm_fs_global)
346 renderfarm_fs_global->lock();
347 if(renderfarm_fs_global->is_open(__stream))
349 result = renderfarm_fs_global->fseek(__stream, __off, __whence);
352 renderfarm_fs_global->unlock();
355 if(!done) result = (*func)(__stream, __off, __whence);
360 int fseeko64 (FILE *__stream, __off64_t __off, int __whence)
362 static int (*func)(FILE *, __off64_t, int) = 0;
366 func = (int(*)(FILE *, __off64_t, int))dlsym(RTLD_NEXT, "fseeko64");
367 //printf("fseeko64\n");
369 if(renderfarm_fs_global)
371 renderfarm_fs_global->lock();
372 if(renderfarm_fs_global->is_open(__stream))
374 result = renderfarm_fs_global->fseek(__stream, __off, __whence);
377 renderfarm_fs_global->unlock();
380 if(!done) result = (*func)(__stream, __off, __whence);
385 long int ftell (FILE *__stream)
387 static long int (*func)(FILE *) = 0;
391 func = (long int(*)(FILE *))dlsym(RTLD_NEXT, "ftell");
394 if(renderfarm_fs_global)
396 renderfarm_fs_global->lock();
397 if(renderfarm_fs_global->is_open(__stream))
399 result = renderfarm_fs_global->ftell(__stream);
402 renderfarm_fs_global->unlock();
405 if(!done) result = (*func)(__stream);
410 __off64_t ftello64 (FILE *__stream)
412 static __off64_t (*func)(FILE *) = 0;
413 __off64_t result = 0;
416 func = (__off64_t(*)(FILE *))dlsym(RTLD_NEXT, "ftello64");
418 if(renderfarm_fs_global)
420 renderfarm_fs_global->lock();
421 if(renderfarm_fs_global->is_open(__stream))
423 result = renderfarm_fs_global->ftell(__stream);
426 renderfarm_fs_global->unlock();
429 if(!done) result = (*func)(__stream);
432 return (*func)(__stream);
436 // Glibc inlines the stat functions and redirects them to __xstat functions
437 int __xstat (int __ver, __const char *__filename,
438 struct stat *__stat_buf)
440 static int (*func)(int __ver, __const char *__filename,
441 struct stat *__stat_buf) = 0;
443 // This pointer is meaningless except on the server.
447 func = (int(*)(int __ver, __const char *__filename,
448 struct stat *__stat_buf))dlsym(RTLD_NEXT, "__xstat");
451 if(!strncmp(__filename, RENDERFARM_FS_PREFIX, strlen(RENDERFARM_FS_PREFIX)))
453 renderfarm_fs_global->lock();
454 result = renderfarm_fs_global->stat(__filename, __stat_buf);
455 renderfarm_fs_global->unlock();
459 result = (*func)(__ver, __filename, __stat_buf);
465 int __xstat64 (int __ver, __const char *__filename,
466 struct stat64 *__stat_buf)
468 static int (*func)(int __ver, __const char *__restrict __file,
469 struct stat64 *__restrict __buf) = 0;
470 // This pointer is meaningless except on the server.
474 func = (int(*)(int __ver, __const char *__restrict __file,
475 struct stat64 *__restrict __buf))dlsym(RTLD_NEXT, "__xstat64");
478 if(!strncmp(__filename, RENDERFARM_FS_PREFIX, strlen(RENDERFARM_FS_PREFIX)))
480 renderfarm_fs_global->lock();
481 result = renderfarm_fs_global->stat64(__filename, __stat_buf);
482 renderfarm_fs_global->unlock();
485 result = (*func)(__ver, __filename, __stat_buf);
490 char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
492 static char* (*func)(char *__restrict __s, int __n, FILE *__restrict __stream) = 0;
496 func = (char*(*)(char *__restrict __s, int __n, FILE *__restrict __stream))dlsym(RTLD_NEXT, "fgets");
498 if(renderfarm_fs_global)
500 renderfarm_fs_global->lock();
501 if(renderfarm_fs_global->is_open(__stream))
503 result = renderfarm_fs_global->fgets(__s, __n, __stream);
506 renderfarm_fs_global->unlock();
509 if(!done) result = (*func)(__s, __n, __stream);
514 int fscanf (FILE *__restrict __stream,
515 __const char *__restrict __format, ...)
520 va_start(ap, __format);
522 if(renderfarm_fs_global)
524 renderfarm_fs_global->lock();
525 if(renderfarm_fs_global->is_open(__stream))
527 // Since this is currently only used in one place in dcraw, leave it blank.
528 // The future implementation may just read until the next \n and scan the string.
529 result = renderfarm_fs_global->fscanf(__stream, __format, ap);
532 renderfarm_fs_global->unlock();
535 if(!done) result = vfscanf(__stream, __format, ap);
561 RenderFarmFSClient::RenderFarmFSClient(RenderFarmClientThread *client)
563 mutex_lock = new Mutex("RenderFarmFSClient::mutex_lock");
564 this->client = client;
567 RenderFarmFSClient::~RenderFarmFSClient()
570 // Must not access filesystem until we get here
571 renderfarm_fs_global = 0;
574 void RenderFarmFSClient::initialize()
576 renderfarm_fs_global = this;
579 void RenderFarmFSClient::lock()
581 mutex_lock->lock("RenderFarmFSClient::lock");
584 void RenderFarmFSClient::unlock()
586 mutex_lock->unlock();
589 int RenderFarmFSClient::is_open(FILE *ptr)
591 for(int i = 0; i < files.total; i++)
592 if(files.values[i] == ptr) return 1;
596 void RenderFarmFSClient::set_open(FILE *ptr, int64_t pointer)
599 if(sizeof(FILE*) == 4)
600 pointers.append(pointer);
603 void RenderFarmFSClient::unset_open(FILE *ptr, int64_t pointer)
606 if(sizeof(FILE*) == 4)
607 pointers.remove(pointer);
610 int64_t RenderFarmFSClient::get_64(FILE *ptr)
612 if(sizeof(FILE*) == 4)
614 for(int i = 0; i < files.total; i++)
616 if(files.values[i] == ptr)
617 return pointers.values[i];
621 return Units::ptr_to_int64(ptr);
623 printf("RenderFarmFSClient::get_64 file %p not found\n", ptr);
628 FILE* RenderFarmFSClient::fopen(const char *path, const char *mode)
631 printf("RenderFarmFSClient::fopen 1\n");
632 int len = strlen(path) - strlen(RENDERFARM_FS_PREFIX) + strlen(mode) + 2;
633 char *buffer = new char[len];
636 strcpy(buffer, path + strlen(RENDERFARM_FS_PREFIX));
637 strcpy(buffer + strlen(buffer) + 1, mode);
640 client->lock("RenderFarmFSClient::fopen");
641 if(!client->send_request_header(RENDERFARM_FOPEN,
644 if(client->write_socket(buffer, len, RENDERFARM_TIMEOUT) == len)
646 unsigned char data[8];
647 if(client->read_socket((char*)data, 8, RENDERFARM_TIMEOUT) == 8)
649 file_int64 = READ_INT64(data);
650 file = (FILE*)Units::int64_to_ptr(file_int64);
655 if(file) set_open(file, file_int64);
659 printf("RenderFarmFSClient::fopen path=%s mode=%s file=%p\n", path, mode, file);
664 int RenderFarmFSClient::fclose(FILE *file)
667 unsigned char datagram[8];
669 int64_t file_int64 = get_64(file);
670 STORE_INT64(file_int64);
672 client->lock("RenderFarmFSClient::fclose");
673 if(!client->send_request_header(RENDERFARM_FCLOSE, 8))
675 if(client->write_socket((char*)datagram, 8, RENDERFARM_TIMEOUT) == 8)
683 unset_open(file, file_int64);
685 printf("RenderFarmFSClient::fclose file=%p\n", file);
689 int RenderFarmFSClient::fileno(FILE *file)
692 printf("RenderFarmFSClient::fileno file=%p\n", file);
694 unsigned char datagram[8];
696 int64_t file_int64 = get_64(file);
697 STORE_INT64(file_int64);
699 client->lock("RenderFarmFSClient::fileno");
700 if(!client->send_request_header(RENDERFARM_FILENO, 8))
702 if(client->write_socket((char*)datagram, 8, RENDERFARM_TIMEOUT) == 8)
704 unsigned char data[4];
705 if(client->read_socket((char*)data, 4, RENDERFARM_TIMEOUT) == 4)
707 result = READ_INT32(data);
717 printf("RenderFarmFSClient::fileno file=%p result=%d\n", file, result);
721 int RenderFarmFSClient::remove (__const char *__filename)
724 int len = strlen(__filename) + 1;
725 char *datagram = new char[len];
726 strcpy(datagram, __filename);
728 client->lock("RenderFarmFSClient::remove");
729 if(!client->send_request_header(RENDERFARM_REMOVE, len))
731 if(client->write_socket(datagram, len, RENDERFARM_TIMEOUT) != len)
742 printf("RenderFarmFSClient::remove path=%s\n", __filename);
746 int RenderFarmFSClient::rename (__const char *__old, __const char *__new)
749 int len = strlen(__old) + 1 + strlen(__new) + 1;
750 char *datagram = new char[len];
751 strcpy(datagram, __old);
752 strcpy(datagram + strlen(__old) + 1, __new);
754 client->lock("RenderFarmFSClient::rename");
755 if(!client->send_request_header(RENDERFARM_RENAME, len))
757 if(client->write_socket(datagram, len, RENDERFARM_TIMEOUT) != len)
768 printf("RenderFarmFSClient::remove old=%s new=%s\n", __old, __new);
772 int RenderFarmFSClient::fgetc (FILE *__stream)
775 printf("RenderFarmFSClient::fgetc 1\n");
777 unsigned char datagram[8];
779 int64_t file_int64 = get_64(__stream);
780 STORE_INT64(file_int64);
782 client->lock("RenderFarmFSClient::fgetc");
783 if(!client->send_request_header(RENDERFARM_FGETC, 8))
785 if(client->write_socket((char*)datagram, 8, RENDERFARM_TIMEOUT) != 8)
789 if(client->read_socket((char*)datagram, 1, RENDERFARM_TIMEOUT) != 1)
793 result = datagram[0];
801 printf("RenderFarmFSClient::fgetc file=%p result=%02x\n", __stream, result);
806 int RenderFarmFSClient::fputc (int __c, FILE *__stream)
809 printf("RenderFarmFSClient::fputc 1\n");
811 unsigned char datagram[9];
813 int64_t file_int64 = get_64(__stream);
814 STORE_INT64(file_int64);
817 client->lock("RenderFarmFSClient::fputc");
818 if(!client->send_request_header(RENDERFARM_FPUTC, 9))
820 if(client->write_socket((char*)datagram, 9, RENDERFARM_TIMEOUT) != 9)
829 printf("RenderFarmFSClient::fputc file=%p result=%02x\n", __stream, result);
834 int RenderFarmFSClient::fscanf(FILE *__restrict stream, const char *__restrict format, va_list ap)
836 char string[BCTEXTLEN];
837 fgets (string, BCTEXTLEN, stream);
841 char* RenderFarmFSClient::fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
845 unsigned char datagram[12];
847 int64_t file_int64 = get_64(__stream);
848 STORE_INT64(file_int64);
851 client->lock("RenderFarmFSClient::fgets");
852 if(!client->send_request_header(RENDERFARM_FGETS, 12))
854 if(client->write_socket((char*)datagram, 12, RENDERFARM_TIMEOUT) == 12)
856 // fgets bytes to follow
857 if(client->read_socket((char*)datagram, 4, RENDERFARM_TIMEOUT) == 4)
860 bytes = READ_INT32(datagram);
863 if(client->read_socket((char*)__s, bytes, RENDERFARM_TIMEOUT) == bytes)
875 printf("RenderFarmFSClient::fgets file=%p string=%p size=%d bytes=%p\n",
876 __stream, __s, bytes, bytes);
882 size_t RenderFarmFSClient::fread (void *__restrict __ptr, size_t __size,
883 size_t __n, FILE *__restrict __stream)
886 unsigned char datagram[16];
888 int64_t file_int64 = get_64(__stream);
889 STORE_INT64(file_int64);
893 client->lock("RenderFarmFSClient::fread");
894 if(!client->send_request_header(RENDERFARM_FREAD, 16))
896 if(client->write_socket((char*)datagram, 16, RENDERFARM_TIMEOUT) != 16)
901 if(client->read_socket((char*)datagram, 4, RENDERFARM_TIMEOUT) != 4)
906 result = READ_INT32(datagram);
907 if(client->read_socket((char*)__ptr, __size * result, RENDERFARM_TIMEOUT) !=
917 printf("RenderFarmFSClient::fread file=%p size=%d num=%d result=%d\n",
918 __stream, __size, __n, result);
923 size_t RenderFarmFSClient::fwrite (__const void *__restrict __ptr, size_t __size,
924 size_t __n, FILE *__restrict __s)
927 printf("RenderFarmFSClient::fwrite 1\n");
929 unsigned char datagram[16];
931 int64_t file_int64 = get_64(__s);
932 STORE_INT64(file_int64);
936 client->lock("RenderFarmFSClient::fwrite");
937 if(!client->send_request_header(RENDERFARM_FWRITE, 16))
939 if(client->write_socket((char*)datagram, 16, RENDERFARM_TIMEOUT) != 16)
944 if(client->write_socket((char*)__ptr, __size * __n, RENDERFARM_TIMEOUT) !=
950 if(client->read_socket((char*)datagram, 4, RENDERFARM_TIMEOUT) != 4)
954 result = READ_INT32(datagram);
963 printf("RenderFarmFSClient::fwrite file=%p size=%d num=%d result=%d\n",
964 __s, __size, __n, result);
969 int RenderFarmFSClient::fseek (FILE *__stream, int64_t __off, int __whence)
972 printf("RenderFarmFSClient::fseek 1\n");
974 unsigned char datagram[20];
976 int64_t file_int64 = get_64(__stream);
977 STORE_INT64(file_int64);
979 STORE_INT32(__whence);
981 // printf("RenderFarmFSClient::fseek %p %llx datagram=%02x%02x%02x%02x%02x%02x%02x%02x\n",
982 // __stream, file_int64, datagram[0], datagram[1], datagram[2], datagram[3], datagram[4], datagram[5], datagram[6], datagram[7]);
983 client->lock("RenderFarmFSClient::fseek");
984 if(!client->send_request_header(RENDERFARM_FSEEK, 20))
986 if(client->write_socket((char*)datagram, 20, RENDERFARM_TIMEOUT) != 20)
990 if(client->read_socket((char*)datagram, 4, RENDERFARM_TIMEOUT) != 4)
993 result = READ_INT32(datagram);
1000 printf("RenderFarmFSClient::fseek stream=%p offset=" _LD " whence=%d result=%d\n",
1001 __stream, __off, __whence, result);
1005 int64_t RenderFarmFSClient::ftell (FILE *__stream)
1008 unsigned char datagram[8];
1010 int64_t file_int64 = get_64(__stream);
1011 STORE_INT64(file_int64);
1013 client->lock("RenderFarmFSClient::ftell");
1014 if(!client->send_request_header(RENDERFARM_FTELL, 8))
1016 if(client->write_socket((char*)datagram, 8, RENDERFARM_TIMEOUT) != 8)
1020 if(client->read_socket((char*)datagram, 8, RENDERFARM_TIMEOUT) != 8)
1023 result = READ_INT64(datagram);
1030 printf("RenderFarmFSClient::fseek stream=%p result=" _LD "\n",
1035 int RenderFarmFSClient::stat (__const char *__restrict __file,
1036 struct stat *__restrict __buf)
1038 int len = strlen(__file) + 1;
1041 client->lock("RenderFarmFSClient::stat");
1042 if(!client->send_request_header(RENDERFARM_STAT, len))
1044 if(client->write_socket((char*)__file + strlen(RENDERFARM_FS_PREFIX), len, RENDERFARM_TIMEOUT) == len)
1046 if(client->read_socket((char*)__buf, sizeof(struct stat), RENDERFARM_TIMEOUT) == sizeof(struct stat))
1060 printf("RenderFarmFSClient::stat path=%s\n", __file);
1067 int RenderFarmFSClient::stat64 (__const char *__restrict __file,
1068 struct stat64 *__restrict __buf)
1070 int len = strlen(__file) + 1;
1072 bzero(__buf, sizeof(struct stat64));
1074 client->lock("RenderFarmFSClient::stat64");
1075 if(!client->send_request_header(RENDERFARM_STAT64, len))
1077 if(client->write_socket((char*)__file + strlen(RENDERFARM_FS_PREFIX), len, RENDERFARM_TIMEOUT) == len)
1080 if(client->read_socket((char*)&arg, sizeof(arg), RENDERFARM_TIMEOUT) == sizeof(arg))
1082 __buf->st_dev = arg.dev;
1083 // __buf->__st_ino = arg.ino32;
1084 __buf->st_ino = arg.ino;
1085 __buf->st_mode = arg.mode;
1086 __buf->st_nlink = arg.nlink;
1087 __buf->st_uid = arg.uid;
1088 __buf->st_gid = arg.gid;
1089 __buf->st_rdev = arg.rdev;
1090 __buf->st_size = arg.size;
1091 __buf->st_blksize = arg.blksize;
1092 __buf->st_blocks = arg.blocks;
1093 __buf->st_atim.tv_sec = arg.atim;
1094 __buf->st_mtim.tv_sec = arg.mtim;
1095 __buf->st_ctim.tv_sec = arg.ctim;
1107 printf("RenderFarmFSClient::stat64 path=%s\n", __file);