1. Why does a different version of stat(), lstat(), exist that treats symbolic l

ID: 3598332 • Letter: 1

Question

1. Why does a different version of stat(), lstat(), exist that treats symbolic links differently? Why isn't a different version needed for hard links?

2. How can you modify 3000pc so the producer stops producing once it fills the queue?

3. If the two signal handling functions in 3000pc were replaced by one function, would there be any significant loss of functionality? Briefly explain.

4. What is one way simple way you can modify 3000pc so the consumer consumes as the producer produces, i.e., the producer and the consumer move essentially in lock step? Your modification should not involve sleeping by either the producer or the consumer. Why does your change work? (To do this precisely is hard; to do this approximately involves a change to one line. The approximate solution is sufficient.)

5.How does the behavior of 3000pc change if you delete lines 149 and 152 (the if statement in wakeup_consumer())? Why? (Explain what the program does after this change and why it may be problematic.)

6. What happens if you delete line 231 (the call to wakeup_producer()) in 3000pc? Why?

/* 3000pc.c */

2 /* producer-consumer example using signals, processes and mmap */

3 /* v1 Oct. 15, 2017 */

4 /* Licenced under the GPLv3, copyright Anil Somayaji */

5 /* You really shouldn't be incorporating parts of this in any other code,

6 it is meant for teaching, not production */

8 #include <stdio.h>

9 #include <stdlib.h>

10 #include <unistd.h>

11 #include <sys/mman.h>

12 #include <errno.h>

13 #include <string.h>

14 #include <sys/types.h>

15 #include <sys/wait.h>

16 #include <semaphore.h>

17 #include <string.h>

18 #include <time.h>

20 #define QUEUESIZE 32

21 #define WORDSIZE 16

23 const int wordlist_size = 27;

24 const char *wordlist[] = {

25 "Alpha",

26 "Bravo",

27 "Charlie",

28 "Delta",

29 "Echo",

30 "Foxtrot",

31 "Golf",

32 "Hotel",

33 "India",

34 "Juliet",

35 "Kilo",

36 "Lima",

37 "Mike",

38 "November",

39 "Oscar",

40 "Papa",

41 "Quebec",

42 "Romeo",

43 "Sierra",

44 "Tango",

45 "Uniform",

46 "Victor",

47 "Whiskey",

48 "X-ray",

49 "Yankee",

50 "Zulu",

51 "Dash"

52 };

54 typedef struct entry {

55 char word[WORDSIZE];

56 sem_t lock;

57 } entry;

59 typedef struct shared {

60 int prod_waiting;

61 int con_waiting;

62 entry queue[QUEUESIZE];

63 int last_produced;

64 int last_consumed;

65 pid_t prod_pid;

66 pid_t con_pid;

67 int prod_count;

68 int con_count;

69 } shared;

72 void report_error(char *error)

73 {

74 fprintf(stderr, "Error: %s ", error);

75 }

77 void usage_exit(char *progname)

78 {

79 fprintf(stderr,

80 "Usage: %s <event count> <prod delay int> <con delay int> ",

81 progname);

82 exit(-1);

83 }

85 void producer_handler(int the_signal)

86 {

87 if (the_signal == SIGUSR1) {

88 fprintf(stderr, "Producer received SIGUSR1. ");

89 return;

91 } else {

92 fprintf(stderr, "Producer: No handler for for signal %d?! ",

93 the_signal);

94 return;

95 }

96 }

98 void consumer_handler(int the_signal)

99 {

100 if (the_signal == SIGUSR1) {

101 fprintf(stderr, "Consumer received SIGUSR1. ");

102 return;

103 } else {

104 fprintf(stderr, "Consumer: No handler for for signal %d?! ",

105 the_signal);

106 return;

107 }

108 }

109

110 void pick_word(char *word)

111 {

112 int pick;

113

114 pick = random() % wordlist_size;

115

116 strcpy(word, wordlist[pick]);

117 }

118

119 void wait_for_producer(shared *s)

120 {

121 struct timespec delay;

122

123 delay.tv_sec = 100;

124 delay.tv_nsec = 0;

125

126 s->con_waiting = 1;

127

128 while (s->con_waiting) {

129 nanosleep(&delay, NULL);

130 }

131 }

132

133 void wait_for_consumer(shared *s)

134 {

135 struct timespec delay;

136

137 delay.tv_sec = 100;

138 delay.tv_nsec = 0;

139

140 s->prod_waiting = 1;

141

142 while (s->prod_waiting) {

143 nanosleep(&delay, NULL);

144 }

145 }

146

147 void wakeup_consumer(shared *s)

148 {

149 if (s->con_waiting) {

150 s->con_waiting = 0;

151 kill(s->con_pid, SIGUSR1);

152 }

153 }

154

155 void wakeup_producer(shared *s)

156 {

157 if (s->prod_waiting) {

158 s->prod_waiting = 0;

159 kill(s->prod_pid, SIGUSR1);

160 }

161 }

162

163 void output_word(int c, char *w)

164 {

165 printf("Word %d: %s ", c, w);

166 }

167

168 int queue_word(char *word, shared *s)

169 {

170 entry *e;

171 int current, retval;

172

173 current = (s->last_produced + 1) % QUEUESIZE;

174

175 e = &s->queue[current];

176

177 sem_wait(&e->lock);

178

179 if (e->word[0] != '') {

180 /* consumer hasn't consumed this entry yet */

181 sem_post(&e->lock);

182 wait_for_consumer(s);

183 sem_wait(&e->lock);

184 }

185

186 if (e->word[0] != '') {

187 fprintf(stderr, "ERROR: No room for producer after waiting! ");

188 retval = -1;

189 goto done;

190 } else {

191 strncpy(e->word, word, WORDSIZE);

192 s->last_produced = current;

193 s->prod_count++;

194 wakeup_consumer(s);

195 retval = 0;

196 goto done;

197 }

198

199 done:

200 sem_post(&e->lock);

201 return retval;

202 }

203

204 int get_next_word(char *word, shared *s)

205 {

206 entry *e;

207 int current, retval;

208

209 current = (s->last_consumed + 1) % QUEUESIZE;

210

211 e = &s->queue[current];

212

213 sem_wait(&e->lock);

214

215 if (e->word[0] == '') {

216 /* producer hasn't filled in this entry yet */

217 sem_post(&e->lock);

218 wait_for_producer(s);

219 sem_wait(&e->lock);

220 }

221

222 if (e->word[0] == '') {

223 fprintf(stderr, "ERROR: Nothing for consumer after waiting! ");

224 retval = -1;

225 goto done;

226 } else {

227 strncpy(word, e->word, WORDSIZE);

228 e->word[0] = '';

229 s->last_consumed = current;

230 s->con_count++;

231 wakeup_producer(s);

232 retval = 0;

233 goto done;

234 }

235

236 done:

237 sem_post(&e->lock);

238 return retval;

239 }

240

241 void producer(shared *s, int event_count, int producer_delay_interval)

242 {

243 char word[WORDSIZE];

244 int i;

245 struct sigaction signal_handler_struct;

246

247 memset (&signal_handler_struct, 0, sizeof(signal_handler_struct));

248 signal_handler_struct.sa_handler = producer_handler;

249

250 if (sigaction(SIGUSR1, &signal_handler_struct, NULL)) {

251 fprintf(stderr, "Producer couldn't register SIGUSR1 handler. ");

252 }

253

254 for (i=0; i < event_count; i++) {

255 pick_word(word);

256 queue_word(word, s);

257 if (producer_delay_interval > 0) {

258 if (i % producer_delay_interval == 0) {

259 sleep(1);

260 }

261 }

262 }

263

264 printf("Producer finished. ");

265 exit(0);

266 }

267

268 void consumer(shared *s, int event_count, int consumer_delay_interval)

269 {

270 char word[WORDSIZE];

271 int i;

272 struct sigaction signal_handler_struct;

273

274 memset (&signal_handler_struct, 0, sizeof(signal_handler_struct));

275 signal_handler_struct.sa_handler = consumer_handler;

276

277 if (sigaction(SIGUSR1, &signal_handler_struct, NULL)) {

278 fprintf(stderr, "Consumer couldn't register SIGUSR1 handler. ");

279 }

280

281 for (i=0; i < event_count; i++) {

282 get_next_word(word, s);

283 output_word(s->con_count, word);

284 if (consumer_delay_interval > 0) {

285 if (i % consumer_delay_interval == 0) {

286 sleep(1);

287 }

288 }

289 }

290

291 printf("Consumer finished. ");

292 exit(0);

293 }

294

295 void init_shared(shared *s)

296 {

297 int i;

298

299 s->con_waiting = 0;

300 s->last_consumed = -1;

301

302 s->prod_waiting = 0;

303 s->last_produced = -1;

304

305 s->prod_pid = -1;

306 s->con_pid = -1;

307

308 s->prod_count = 0;

309 s->con_count = 0;

310

311 for (i=0; i<QUEUESIZE; i++) {

312 s->queue[i].word[0] = '';

313 /* semaphore is shared between processes,

314 and initial value is 1 (unlocked) */

315 sem_init(&s->queue[i].lock, 1, 1);

316 }

317 }

318

319 int main(int argc, char *argv[])

320 {

321 int pid, count, prod_interval, con_interval;

322

323 shared *s;

324

325 srandom(42);

326

327 if (argc < 4) {

328 if (argc < 1) {

329 report_error("no command line");

330 usage_exit(argv[0]);

331 } else {

332 report_error("Not enough arguments");

333 usage_exit(argv[0]);

334 }

335 }

336

337 count = atoi(argv[1]);

338 prod_interval = atoi(argv[2]);

339 con_interval = atoi(argv[3]);

340

341 s = (shared *) mmap(NULL, sizeof(shared),

342 PROT_READ|PROT_WRITE,

343 MAP_SHARED|MAP_ANONYMOUS, -1, 0);

344

345 if (s == MAP_FAILED) {

346 report_error(strerror(errno));

347 }

348

349 init_shared(s);

350

351 pid = fork();

352

353 if (pid) {

354 /* producer */

355 s->prod_pid = getpid();

356 producer(s, count, prod_interval);

357 } else {

358 /* consumer */

359 s->con_pid = getpid();

360 consumer(s, count, con_interval);

361 }

362

363 /* This line should never be reached */

364 return -1;

365 }

Explanation / Answer

Question : Why does a different version of stat(), lstat(), exist that treats symbolic links differently? Why isn't a different version needed for hard links?

Solution : Both the function stat and lstat is used to get description about a file. Both these functions return information about a file. In some cases, we need to find out information about the symbolic link, where it is pointing to, where the actual file resides and other things, in such cases lstat() is required,. lstat() is same as stat(, just that it gives information about the link, instead of the file, if the file is a symbolic link instead of an actual file.

In case of hardlinks we dont need any other specific function as, stat() already gives us the information that we need in case of hard links.

stat() reads the file and stores the file in the file buffer.

All these function return a stat structure, which contain all the possible information about the file, such as ID of the device containing the file, no. of hard links, userID of owner, groupId etc. all the information that can be needed in case of hard link can already be retrieved using stat(). thus, no other function is required for hard links.

Navigate

1. Why does W. L. Gore’s unique management structure work? 2. What trade-offs do

1. Why does a patient who had a URI that developed into mengitis have hypertensi

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.

1. Why does a different version of stat(), lstat(), exist that treats symbolic l

Question

Explanation / Answer

Related Questions

Navigate